Problem:
Problem A: Whist

Whist is a game played by four players with a standard deck of playing cards. The players seat
around a table, namely, in north, east, south, and west. This game is played in a team-play
basis: the players seating opposite to each other become a team. In other words, they make two
teams we could call the north-south team and the east-west team.

Remember that the standard deck consists of 52 cards each of which has a rank and a suit. The
rank indicates the strength of the card and is one of the following: 2, 3, 4, 5, 6, 7, 8, 9, 10, jack,
queen, king, and ace (from the lowest to the highest). The suit refers to the type of symbols
printed on the card, namely, spades, hearts, diamonds, and clubs. The deck contains exactly
one card for every possible pair of a rank and a suit, thus 52 cards.

One of the four players (called a dealer) shuffles the deck and deals out all the cards face down,
one by one, clockwise from the player left to him or her. Each player should have thirteen cards.
Then the last dealt card, which belongs to the dealer, is turned face up. The suit of this card is
called trumps and has a special meaning as mentioned below.

A deal of this game consists of thirteen tricks. The objective for each team is winning more
tricks than another team. The player left to the dealer leads the first trick by playing one of
the cards in his or her hand. Then the other players make their plays in the clockwise order.
They have to play a card of the suit led if they have one; they can play any card otherwise. The
trick is won by the player with the highest card of the suit led if no one plays a trump, or with
the highest trump otherwise. The winner of this trick leads the next trick, and the remaining
part of the deal is played similarly. After the thirteen tricks have been played, the team winning
more tricks gains a score, one point per trick in excess of six.

Your task is to write a program that determines the winning team and their score for given
plays of a deal.

Input

The input is a sequence of datasets. Each dataset corresponds to a single deal and has the
following format:

Trump

CardN,1 CardN,2 ... CardN,13

CardE,1 CardE,2 ... CardE,13

CardS,1 CardS,2 ... CardS,13

CardW,1 CardW,2 ... CardW,13

Trump indicates the trump suit. CardN,i, CardE,i, CardS,i, and CardW,i denote the card played in the i-th trick by the north, east, south, and west players respectively. Each card is represented
by two characters; the first and second character indicates the rank and the suit respectively.

The rank is represented by one of the following characters: ‘2’, ‘3’, ‘4’, ‘5’, ‘6’, ‘7’, ‘8’, ‘9’, ‘T’ (10), ‘J’ (jack), ‘Q’ (queen), ‘K’ (king), and ‘A’ (ace). The suit is represented by one of the following characters: ‘S’ (spades), ‘H’ (hearts), ‘D’ (diamonds), and ‘C’ (clubs).

You should assume the cards have been dealt out by the west player. Thus the first trick is led
by the north player. Also, the input does not contain any illegal plays.

The input is terminated by a line with “#”. This is not part of any dataset and thus should not
be processed.

Output

For each dataset, print the winner and their score of the deal in a line, with a single space
between them as a separator. The winner should be either “NS” (the north-south team) or “EW”
(the east-west team). No extra character or whitespace should appear in the output.

Sample Input

H
4C 8H QS 5D JD KS 8S AH 6H 7H 3S 7S 6D
TC JC JS KD AC QC QD 2H QH 3H 3C 7C 4D
6C 9C AS TD 5H 6S 5S KH TH AD 9S 8D 2D
8C 5C 2S 7D KC 4S TS JH 4H 9H 2C 9D 3D
D
8D 9D 9S QS 4H 5H JD JS 9H 6S TH 6H QH
QD 9C 5S 7S 7H AC 2D KD 6C 3D 8C TC 7C
5D QC 3S 4S 3H 3C 6D KS JC AS 5C 8H TS
4D 4C 8S 2S 2H KC TD JH 2C AH 7D AD KH
#

Output for the Sample Input

EW 1
EW 2

The winners of the tricks in the first dataset are as follows (in the order of tricks): east, north,
south, east, south, north, west, north, east, west, east, east, north.

Solution in JAVA (judge verdict: Accepted)

import java.util.ArrayList;
import java.util.Scanner;

public class Main {

	Scanner sc = new Scanner(System.in);
	public void run() {
		while(sc.hasNext()){
			String trump = sc.next();
			
			if(trump.equals("#")) break;
			else calc(trump);
		}
	}
	public void calc(String trump){
		String[][] cards = new String[4][13];
		for(int i = 0; i < 4; i++){
			for(int j = 0; j < 13; j++){
				cards[i][j] = sc.next();
			}
		}
		
		int led = 0;
		int nsPoint = 0;
		int ewPoint = 0;
		for(int i = 0; i < 13; i++){
			String[] turn = new String[]{cards[0][i], cards[1][i], cards[2][i], cards[3][i]};			
			String ledSuit = turn[led].substring(1, 2);
			
			int winner = win(turn, ledSuit, trump);
			
			if(winner == 0 || winner == 2) nsPoint++;
			else ewPoint++;
			
			led = winner;
		}
		
		if(nsPoint > ewPoint){
			int point = nsPoint - 6;
			System.out.println("NS " + point);
		}
		else{
			int point = ewPoint - 6;
			System.out.println("EW " + point);
		}
	}

	public int win(String[] turn, String ledSuit, String trump){
		int winner = 0;
		int winNum = getNum(turn[0].substring(0, 1));
		String winSuit = turn[0].substring(1,2);
		
		for(int i = 1; i < 4; i++){
			int turnNum = getNum(turn[i].substring(0, 1));
			String turnSuit = turn[i].substring(1, 2);
			
			if(turnSuit.equals(trump)){
				if(!winSuit.equals(trump)){
					winner = i;
					winNum = turnNum;
					winSuit = turnSuit;
				}
				else if(turnNum > winNum){
					winner = i;
					winNum = turnNum;
					winSuit = turnSuit;
				}
			}
			else if(turnSuit.equals(ledSuit)){
				if(!winSuit.equals(trump)){
					if(!winSuit.equals(ledSuit)){
						winner = i;
						winNum = turnNum;
						winSuit = turnSuit;
					}
					else if(turnNum > winNum){
						winner = i;
						winNum = turnNum;
						winSuit = turnSuit;
					}
				}
			}
		}
		return winner;
	}
	
	public int getNum(String card){
		if(card.equals("T")) return 10;
		else if(card.equals("J")) return 11;
		else if(card.equals("Q")) return 12;
		else if(card.equals("K")) return 13;
		else if(card.equals("A")) return 14;
		else return Integer.valueOf(card);
	}
	
	public static void main(String[] args) {
		new Main().run();
	}
}