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 Ruby (judge verdict: Accepted)

def suite(card)
  card[1]
end
def rank(card)
  case card[0]
    when "2".."9"
      return card[0].to_i
    when "T"
      return 10
    when "J"
      return 11
    when "Q"
      return 12
    when "K"
      return 13
    when "A"
      return 14
  end
end
def less(card1, card2, lead, trump)
  cost1 = rank(card1)
  cost1 += 13 if suite(card1) == lead
  cost1 += 26 if suite(card1) == trump
  cost2 = rank(card2)
  cost2 += 13 if suite(card2) == lead
  cost2 += 26 if suite(card2) == trump
  cost1 < cost2
end

N, E, S, W = (0...4).to_a
while (trump = gets.chomp) != "#" do
  card = Array.new
  4.times do
    card.push(gets.chomp.split)
  end
  point = Array.new(2, 0)
  lead = E
  13.times do |trick|
    winner = lead
    4.times do |i|
      winner = i if less(card[winner][trick], card[i][trick], suite(card[lead][trick]), trump)
    end
    lead = winner
    point[winner&1] += 1
  end
  puts point[0]>point[1] ? "NS #{point[0]-6}" : "EW #{point[1]-6}"
end