꿈을 꾸다...

/* 

Subject: #162 - Beggar My Neighbour

e-mail: morcavon@gmail.com

Homepage: http://www.morcavon.com

Building: 13/07/2005 ~ 19/07/2005

Last Update: 19/07/2005

*/



/*

<PURPOSE>

Simulate playing card game contains 52 cards.

-

<PREDICATE>

J: 1 cards

Q: 2 cards

K: 3 cards

A: 4 cards

-

<INPUT>

A standard deck(shuffled) 52 cards

....

#

-

<OUTPUT>

winner #of cards in the winner's hand

*/



#include <stdio.h>

#include <stdlib.h>







typedef struct _card* pCard;

typedef struct _card

{

	char value; /* 숫자값일경우 쌓인 카드의 수, 문자값(A,K,Q,J)일 경우 face card */

	pCard next;

} card;







#define ONLINE_JUDGE



void push(pCard *top, char value);

char pop(pCard *top);



void deal_card(pCard *player, char card_value);

void add_heap(pCard (*heap)[2], char value);

void take_heap(pCard *player, pCard (*heap)[2]);

int count_deck(pCard player, pCard heap);

void output(int winner, pCard player, pCard heap);

int is_face(char value);

char face_off(pCard *player, pCard (*heap)[2]);





int main()

{

	pCard dealer_top, non_dealer_top, heap[2];

	char in_data[3];

	int i;

	int turn; /* 0: dealer, 1: non-dealer */

	char result;

	int end_game;

	char face_val[26];

	int count;

	face_val['J' - 'A'] = 1;

	face_val['Q' - 'A'] = 2;

	face_val['K' - 'A'] = 3;

	face_val['A' - 'A'] = 4;









	while (scanf("%s", in_data) != 0) {

		if (in_data[0] == '#')

			break;



		/* initialize */

		dealer_top = non_dealer_top = heap[0] = heap[1] = NULL;

		end_game = 0;

		count = 0;





		/* deal cards */

		turn = 1; /* start */

		for (i = 0; i < 51; i++) {

			deal_card((turn == 0? &dealer_top : &non_dealer_top), in_data[1]);

			scanf("%s", in_data);

			turn = !turn;

		}

		deal_card(&dealer_top, in_data[1]);









		/************************** play the game *************************/

		turn = 1; /* first to play */

		while (!end_game) {

			result = face_off((turn == 0? &dealer_top : &non_dealer_top), &heap);

			if (result == 0) {

				output(!turn + 1, (!turn == 0? dealer_top : non_dealer_top), heap[0]);

				break;

			}





			if (is_face(result)) {







				/* 카드를 던지는 중 face카드가 나올 경우

				*상대방이 face카드에 해당하는 카드만큼을 내야한다.

				*상대방이 face가 낸다면 내가 다시 얼마만큼의 카드를 내야함

				*이 시퀀스가 끝난후 마지막으로 face를 낸 사람이 heap의 카드를 다 가져감

				*가져간 카드들은 플레이어의 스택 밑에 넣어야 해~~ (순서에 주의!!@_@)

				*/

				turn = !turn;

				for (i = face_val[result - 'A']; i > 0; ) {

					result = face_off((turn == 0? &dealer_top : &non_dealer_top), &heap);

					if (result == 0) {

						output(!turn + 1, (!turn == 0? dealer_top : non_dealer_top), heap[0]);

						end_game = 1;

						break;

					}





					if (is_face(result)) {

						turn = !turn;

						i = face_val[result - 'A'];

						continue;

					}

					i--;

				}



				/* face 시퀀스 끝. heap 처리 */

				/* 마지막으로 face를 낸 사람은 !turn */

				if (!end_game) {

					take_heap((!turn == 0? &dealer_top : &non_dealer_top), &heap);

					turn = !turn;

					count++;

				}

			}

			else

				turn = !turn; /* 상대방에게 턴을 넘김 */

		} /* end of one game */



	}





	return 0;

}









void add_heap(pCard (*heap)[2], char value)

{

	/*

	* heap[0]: front, hea[1]: rear

	* heap의 끝부분에 새로운 값을 추가

	*/

	pCard new_card;



	if ((*heap)[0] == NULL) {

		new_card = (pCard)malloc(sizeof(card));

		new_card->next = NULL;

		if (is_face(value))

			new_card->value =value;

		else

			new_card->value = 1;



		(*heap)[0] = (*heap)[1] = new_card;

	}

	else {

		if (is_face(value) || is_face(((*heap)[1])->value)) {

			new_card = (pCard)malloc(sizeof(card));

			new_card->next = NULL;

			if (is_face(value))

				new_card->value =value;

			else

				new_card->value = 1;

			(*heap)[1] = (*heap)[1]->next = new_card;

		}

		else {

			((*heap)[1])->value++;

		}

	}

}







void output(int winner, pCard player, pCard heap)

{

	printf("%d%3d\n", winner, count_deck(player, heap));

}





void take_heap(pCard *player, pCard (*heap)[2])

{

	/* heap(front)을 player의 스택 밑에 붙여넣고 heap을 초기화 */

	pCard w_ptr;



	if (*player == NULL) {

		*player = (*heap)[0];

	}

	else { /* player 덱의 맨밑에 heap을 집어넣는다 */

		for (w_ptr = *player; w_ptr->next != NULL; w_ptr = w_ptr->next)

			;



		w_ptr->next = (*heap)[0];

	}



	(*heap)[0] = (*heap)[1] = NULL;

}





char face_off(pCard *player, pCard (*heap)[2])

{

	/* 카드를 heap에 던지고 카드의 값을 리턴 */

	/* face 카드일 경우 해당 값을 리턴하고, 숫자카드일 경우는 1을 리턴 */



	if (*player == NULL) {

		return 0;

	}



	add_heap(heap, (*player)->value);



	if (is_face((*player)->value)) {

		return pop(player);

	}

	else {

		/* 카운트를 감소시키는데 감소시켜 0이 될경우 pop하여 없앤다. */

		if (--((*player)->value) == 0)

			pop(player);

		return 1;

	}

}









void deal_card(pCard *player, char card_value)

{

	/* player의 덱에 card_value를 추가한다. */

	if (is_face(card_value)) { /* face카드 */

		push(player, card_value);

	}

	else { /* 숫자카드 */

		/* 덱에 카드가 없거나 맨위에 face카드가 있으면 새 카드로 쌓음 */

		if (*player == NULL || is_face((*player)->value))

			push(player, 1);

		else {

			/* 덱의 top카드가 숫자카드일 경우 카운트만 증가시킴 */

			(*player)->value++;

		}

	}

}





void push(pCard *top, char value)

{

	pCard new_node = (pCard)malloc(sizeof(card));

	new_node->value = value;

	new_node->next = *top;

	*top = new_node;

}



char pop(pCard *top)

{

	card ret_val;

	/*

	if (*top == NULL) {

	printf("비어있는 스택은 팝 할 수 없음.!!\n");

	exit(1);

	}

	*/

	ret_val = **top;

	free(*top);

	*top = ret_val.next;



	return ret_val.value;

}





int is_face(char value)

{

	return (value >= 'A' && value != 'T');

}





int count_deck(pCard player, pCard heap)

{

	/* player 덱에 있는 카드의 갯수 리턴 */

	/* 리스트를 훑으면서 겸사겸사 메모리까지 해제=_= */

	int count;

	pCard t_ptr;



	for (count = 0; player != NULL; ) {

		if (is_face(player->value))

			count++; /* face 카드는 한개씩 들어있음 */

		else

			count += player->value;



		t_ptr = player->next;

		free(player);

		player = t_ptr;

	}



	/* heap 해제 */

	for (; heap != NULL; ) {

		t_ptr = heap->next;

		free(heap);

		heap = t_ptr;

	}



	return count;

}