문제 10 : 포커 패 (Poker Hands)

포커용 카드는 52개의 카드로 이루어집니다.

 

각 카드는 클럽, 다이아몬드, 하트, 스페이드의 무늬을 가집니다.

이 모양은 C, D, H, S 로 표기합니다. 

 

또한 각 카드는 2에서 10까지, 그리고 잭, 퀸, 킹 또는 에이스의 값을 갖습니다. 

이 값은 2, 3, 4, 5, 6, 7, 8, 9, T, J, Q, K, A 로 표기합니다. 

 

점수를 매길 때 위에 열거한 순서대로 등급이 매겨지며 2가 가장 낮고 에이스가 가장 높습니다.

무늬는 값에 영향을 끼치지 않습니다.

 

포커 패는 다섯 장의 카드로 구성되며 다음과 같은 순서대로 등급이 매겨집니다.

 

하이카드 : 아래에 있는 것 가운데 어떤 범주에도 속하지 않는 패. 가장 높은 카드의 값에 따라 등급이 매겨집니다. 가장 높은 카드의 값이 같으면 그 다음 카드, 그 다음 카드도 같으면 그 다음 카드, 이런 식으로 등급이 매겨집니다.

 

원 페어 : 다섯 장의 카드 가운데 두 장이 같은 경우. 같은 원 페어끼리 맞붙는 경우에는 그 중 더 높은 페어의 값에 의해 더 높은 등급이 매겨집니다. 두 쌍의 값이 모두 같으면 남은 카드에 의해 더 높은 패가 결정됩니다.

 

쓰리 카드 : 다섯 장 가운데 세 장이 같은 값을 가지는 경우. 스트레이트끼리 맞붙을 경우에는 가장 높은 카드에 의해 더 높은 패가 결정됩니다.

 

스트레이트 : 다섯 장의 카드가 연속적인 값을 가지는 경우. 스트레이트끼리 맞붙을 경우에는 가장 높은 카드에 의해 더 높은 패가 결정됩니다.

 

플러시 : 다섯 장의 카드의 무늬가 모두 같은 경우. 플러시끼리 맞붙을 경우에는 하이 카드의 규칙에 따라서 더 높은 패가 결정됩니다. 

 

풀 하우스 : 세 장의 카드가 같은 값을 가지고 나머지 두 장의 카드가 같은 값을 가지는 경우. 같은 값을 가지는 세장의 카드의 우열에 의해 더 높은 패가 결정됩니다.

 

포 카드 : 네 장의 카드가 같은 값을 가지는 경우. 포 카드끼리 맞붙는 경우에는 네 장의 같은 값을 가지는 카드의 값에 의해 더 높은 패가 결정됩니다.

 

스트레이트 플러시 : 다섯 장의 카드가 무늬가 같으면서 모두 연속적인 값을 가지는 경우. 패에 있는 것 중 가장 높은 카드에 의해서 더 높은 패가 결정됩니다.

 

포커패를 비교해서 어느 쪽이 이겼는지 아니면 무승부인지를 알아내는 프로그램을 만들어 봅시다.

 

입력

입력은 한 줄을 입력 받습니다. 이 줄에는 열 장의 카드를 나타내는 값이 들어가 있습니다.

앞에 있는 다섯 장의 카드는 "Black" 참가자의 카드고, 뒤의 카드는 "White" 참가자의 카드입니다.

 

출력

입력된 각 줄에 대해 다음 중 한가지가 들어있는 행을 출력합니다.

 

Black wins.

White wins.

Tie 

 

예제

※ 중간에 디버깅을 위해, 각 참가자의 카드를 출력하고 패의 종류를 표기하는 것을 추가했습니다.

---

해설

포커에 경험이 있어야 이해가 쉬울 수 있습니다. 포커에 대한 내용은 다른 사이트를 참조해보시면 좋을 것 같습니다.

처리하면서 골치아픈 중의 하나가 에이스 (A) 의 처리입니다. 에이스 (A)는 1일 수도 있고, 14를 의미할 수도 있기 때문입니다. 그리고 같은 등급의 패일 경우, 각 카드를 검색해서 더 높은 패를 가려야 하는 부분이 은근히 귀찮습니다.

# Quiz 0010, Poker Hands
# written by badsaram

import sys
import re

from enum import IntEnum

class Color(IntEnum):
    BLACK = 0
    RED = 1

class Mark(IntEnum):
    SPADE = 0
    HEART = 1
    DIAMOND = 2
    CLOVER = 3

class Hand(IntEnum):
    HIGHCARD = 0
    ONEPAIR = 1
    TWOPAIR = 2
    THREECARD = 3
    STRAIGHT = 4
    FLUSH = 5
    FULLHOUSE = 6
    FOURCARD = 7
    STFLUSH = 8
    RSTFLUSH = 9

class PokerCard(object):
    def __init__(self, strCard):
        self.convertCard(strCard)

    def getMark(self):
        return self.mark

    def getColor(self):
        return self.color

    def getNumber(self):
        return self.number

    def getPrint(self):
        print_num = ('A', '2', '3', '4', '5', '6', '7', '8', '9', 'T', 'J', 'Q', 'K')
        print_mark = ('S', 'H', 'D', 'C')

        ret = "{num}{mark}".format(num = print_num[self.number - 1], mark = print_mark[self.mark])
        return ret

    def convertCard(self, strCard):
        tempStr = strCard.upper()

        if (re.match("[2-9]+", tempStr[0]) != None):
            self.number = int(tempStr[0])
        elif (tempStr[0] == 'T'):
            self.number = 10
        elif (tempStr[0] == 'J'):
            self.number = 11
        elif (tempStr[0] == 'Q'):
            self.number = 12
        elif (tempStr[0] == 'K'):
            self.number = 13
        elif (tempStr[0] == 'A'):
            self.number = 1
        else:
            pass

        if (tempStr[1]) == 'S':
            self.mark = Mark.SPADE
            self.color = Color.BLACK
        elif (tempStr[1]) == 'H':
            self.mark = Mark.HEART
            self.color = Color.RED
        elif (tempStr[1]) == 'D':
            self.mark = Mark.DIAMOND
            self.color = Color.RED
        else:
            self.mark = Mark.CLOVER
            self.color = Color.BLACK

class PokerHands(object):
    def __init__(self):
        self.card1 = []
        self.card2 = []

    def input(self):
        str = input()

        # The order of black and white are changed
        str_cards = str.split(' ')

        if (len(str_cards) == 10):
            self.card2.append(PokerCard(str_cards[0]))
            self.card2.append(PokerCard(str_cards[1]))
            self.card2.append(PokerCard(str_cards[2]))
            self.card2.append(PokerCard(str_cards[3]))
            self.card2.append(PokerCard(str_cards[4]))

            self.card1.append(PokerCard(str_cards[5]))
            self.card1.append(PokerCard(str_cards[6]))
            self.card1.append(PokerCard(str_cards[7]))
            self.card1.append(PokerCard(str_cards[8]))
            self.card1.append(PokerCard(str_cards[9]))
        else:
            pass

    def run(self):
        if ((len(self.card1) != 5) or (len(self.card2) != 5)):
            print("Error")
            return

        white_rank = self.checkHandRanking(self.card1)
        black_rank = self.checkHandRanking(self.card2)

        self.printHands(self.card1, "White", white_rank)
        self.printHands(self.card2, "Black", black_rank)

        if (white_rank > black_rank):
            print("White wins.")
        elif (white_rank < black_rank):
            print("Black wins.")
        else:
            if (white_rank == Hand.RSTFLUSH):
                ret = 0
            elif (white_rank == Hand.STFLUSH):
                ret = self.checkTieForStFlush(self.card1, self.card2)
            elif (white_rank == Hand.FOURCARD):
                ret = self.checkTieForFourCard(self.card1, self.card2)
            elif (white_rank == Hand.FULLHOUSE):
                ret = self.checkTieForFullHouse(self.card1, self.card2)
            elif (white_rank == Hand.FLUSH):
                ret = self.checkTieForFlush(self.card1, self.card2)
            elif (white_rank == Hand.STRAIGHT):
                ret = self.checkTieForStraight(self.card1, self.card2)
            elif (white_rank == Hand.THREECARD):
                ret = self.checkTieForThreeCard(self.card1, self.card2)
            elif (white_rank == Hand.TWOPAIR):
                ret = self.checkTieForTwoPair(self.card1, self.card2)
            elif (white_rank == Hand.ONEPAIR):
                ret = self.checkTieForOnePair(self.card1, self.card2)
            else:
                ret = self.checkTieForHighCard(self.card1, self.card2)

            if (ret > 0):
                print("White wins")
            elif (ret < 0):
                print("Black wins")
            else:
                print("Tie.")

    def getRankPrint(self, rank):
        print_rank = ("High Card", "One Pair", "Two Pair", "Three Card", "Straight", "Flush", "Full House", \
                      "Four Card", "Straight Flush", "Royal Straight Flush")

        return print_rank[rank]

    def printHands(self, hands, prompt, rank):
        print("%s : %s %s %s %s %s -> %s" % (prompt, hands[0].getPrint(), hands[1].getPrint(), hands[2].getPrint(), \
                                    hands[3].getPrint(), hands[4].getPrint(), self.getRankPrint(rank)))

    def getNumArray(self, hands):
        ret = []

        for hand in hands:
            ret.append(hand.getNumber())

        return ret

    def checkHandRanking(self, hands):
        rank = Hand.HIGHCARD

        if (self.isRstFlush(hands) == True):
            rank = Hand.RSTFLUSH
        elif (self.isStFlush(hands) == True):
            rank = Hand.STFLUSH
        elif (self.isFourCard(hands) == True):
            rank = Hand.FOURCARD
        elif (self.isFullHouse(hands) == True):
            rank = Hand.FULLHOUSE
        elif (self.isFlush(hands) == True):
            rank = Hand.FLUSH
        elif (self.isStraight(hands) == True):
            rank = Hand.STRAIGHT
        elif (self.isThreeCard(hands) == True):
            rank = Hand.THREECARD
        elif (self.isTwoPair(hands) == True):
            rank = Hand.TWOPAIR
        elif (self.isOnePair(hands) == True):
            rank = Hand.ONEPAIR
        else:
            rank = Hand.HIGHCARD

        return rank

    def isRstFlush(self, hands):
        ret = False

        if (self.isStFlush(hands) == True):
            num_array = self.getNumArray(hands)
            num_array.sort()
            if ((num_array[0] == 1) and (num_array[1] == 10)):
                ret = True

        return ret

    def isStFlush(self, hands):
        ret = False

        if ((self.isFlush(hands) == True) and (self.isStraight(hands) == True)):
            ret = True

        return ret

    def isFourCard(self, hands):
        ret = False

        check_array = [ 0 for i in range(13) ]
        for hand in hands:
            check_array[hand.getNumber() - 1] += 1

        if ((4 in check_array) == True):
            ret = True

        return ret

    def isFullHouse(self, hands):
        ret = False

        check_array = [ 0 for i in range(13) ]
        for hand in hands:
            check_array[hand.getNumber() - 1] += 1

        if ((check_array.count(3) == 1) and (check_array.count(2) == 1)):
            ret = True

        return ret

    def isFlush(self, hands):
        ret = True

        check_mark = hands[0].getMark()
        for hand in hands:
            if (hand.getMark() != check_mark):
                ret = False

        return ret

    def isStraight(self, hands):
        ret = False

        check_array = [ 0 for i in range(13) ]
        for hand in hands:
            check_array[hand.getNumber() - 1] += 1

        if (check_array.count(1) != 5):
            ret = False
        else:
            num_array = self.getNumArray(hands)
            num_array.sort()
            if ((num_array[4] - num_array[0]) == 4):
                ret = True
            elif ((num_array[0] == 1) and (num_array[1] == 10)):
                ret = True
            else:
                pass

        return ret

    def isThreeCard(self, hands):
        ret = False

        check_array = [ 0 for i in range(13) ]
        for hand in hands:
            check_array[hand.getNumber() - 1] += 1

        if ((3 in check_array) == True) and (2 not in check_array):
            ret = True

        return ret

    def isTwoPair(self, hands):
        ret = False

        check_array = [ 0 for i in range(13) ]
        for hand in hands:
            check_array[hand.getNumber() - 1] += 1

        if (check_array.count(2) == 2):
            ret = True

        return ret

    def isOnePair(self, hands):
        ret = False

        check_array = [ 0 for i in range(13) ]
        for hand in hands:
            check_array[hand.getNumber() - 1] += 1

        if ((check_array.count(2) == 1) and (3 not in check_array)):
            ret = True

        return ret

    def checkTieForRstFlush(self, hands1, hands2):
        ret = 0

        return ret

    def checkTieForStFlush(self, hands1, hands2):
        ret = self.checkTieForHighCard()

        return ret

    def checkTieForFourCard(self, hands1, hands2):
        ret = 0

        paircard1 = 0
        paircard2 = 0

        check_array1 = [ 0 for i in range(13) ]
        for hand1 in hands1:
            check_array1[hand1.getNumber() - 1] += 1
            if (check_array1[hand1.getNumber() - 1] >= 4):
                paircard1 = hand1.getNumber()

        check_array2 = [ 0 for i in range(13) ]
        for hand2 in hands2:
            check_array2[hand2.getNumber() - 1] += 1
            if (check_array2[hand2.getNumber() - 1] >= 4):
                paircard2 = hand2.getNumber()

        if (paircard1 != paircard2):
            if (paircard1 == 1):
                paircard1 = 14
            if (paircard2 == 1):
                paircard2 = 14

            if (paircard1 > paircard2):
                ret = 1
            else:
                ret = -1
        else:
            num_array1 = self.getNumArray(hands1)
            num_array2 = self.getNumArray(hands2)

            num_array1.sort()
            num_array2.sort()

            if ((1 in num_array1) and (1 not in num_array2)):
                ret = 1
            elif ((1 not in num_array1) and (1 in num_array2)):
                ret = -1
            else:
                for i in range(4, 0, -1):
                    if (num_array1[i] > num_array2[i]):
                        ret = 1
                        break
                    elif (num_array1[i] < num_array2[i]):
                        ret = -1
                        break

        return ret

    def checkTieForFullHouse(self, hands1, hands2):
        ret = 0

        paircard1_3 = 0
        paircard1_2 = 0
        paircard2_3 = 0
        paircard2_1 = 0

        check_array1 = [ 0 for i in range(13) ]
        for hand1 in hands1:
            check_array1[hand1.getNumber() - 1] += 1

        check_array2 = [ 0 for i in range(13) ]
        for hand2 in hands2:
            check_array2[hand2.getNumber() - 1] += 1

        for i in range(13):
            if (check_array1[i] >= 3):
                if (i == 1):
                    paircard1_3 = 14
                else:
                    paircard1_3 = i
            elif (check_array1[i] >= 2):
                if (i == 1):
                    paircard1_2 = 14
                else:
                    paircard1_2 = i
            else:
                pass

            if (check_array2[i] >= 3):
                if (i == 1):
                    paircard2_3 = 14
                else:
                    paircard2_3 = i
            elif (check_array2[i] >= 2):
                if (i == 1):
                    paircard2_2 = 14
                else:
                    paircard2_2 = i
            else:
                pass

        if (paircard1_3 > paircard2_3):
            ret = -1
        elif (paircard1_3 < paircard2_3):
            ret = 1
        else:
            if (paircard1_2 > paircard2_2):
                ret = -1
            elif (paircard1_2 < paircard2_2):
                ret = 1
            else:
                ret = 0

        return ret

    def checkTieForFlush(self, hands1, hands2):
        ret = self.checkTieForHighCard(hands1, hands2)

        return ret

    def checkTieForStraight(self, hands1, hands2):
        ret = self.checkTieForHighCard(hands1, hands2)

        return ret

    def checkTieForThreeCard(self, hands1, hands2):
        ret = 0

        paircard1 = 0
        paircard2 = 0

        check_array1 = [ 0 for i in range(13) ]
        for hand1 in hands1:
            check_array1[hand1.getNumber() - 1] += 1
            if (check_array1[hand1.getNumber() - 1] >= 3):
                paircard1 = hand1.getNumber()

        check_array2 = [ 0 for i in range(13) ]
        for hand2 in hands2:
            check_array2[hand2.getNumber() - 1] += 1
            if (check_array2[hand2.getNumber() - 1] >= 3):
                paircard2 = hand2.getNumber()

        if (paircard1 != paircard2):
            if (paircard1 == 1):
                paircard1 = 14
            if (paircard2 == 1):
                paircard2 = 14

            if (paircard1 > paircard2):
                ret = 1
            else:
                ret = -1
        else:
            num_array1 = self.getNumArray(hands1)
            num_array2 = self.getNumArray(hands2)

            num_array1.sort()
            num_array2.sort()

            if ((1 in num_array1) and (1 not in num_array2)):
                ret = 1
            elif ((1 not in num_array1) and (1 in num_array2)):
                ret = -1
            else:
                for i in range(4, 0, -1):
                    if (num_array1[i] > num_array2[i]):
                        ret = 1
                        break
                    elif (num_array1[i] < num_array2[i]):
                        ret = -1
                        break

        return ret

    def checkTieForTwoPair(self, hands1, hands2):
        ret = 0

        paircard1 = []
        paircard2 = []

        check_array1 = [ 0 for i in range(13) ]
        for hand1 in hands1:
            check_array1[hand1.getNumber() - 1] += 1
            if (check_array1[hand1.getNumber() - 1] >= 2):
                paircard1.append(hand1.getNumber())

        check_array2 = [ 0 for i in range(13) ]
        for hand2 in hands2:
            check_array2[hand2.getNumber() - 1] += 1
            if (check_array2[hand2.getNumber() - 1] >= 2):
                paircard2.append(hand2.getNumber())

        if ((1 in paircard1) and (1 not in paircard2)):
            ret = 1
        elif ((1 not in paircard1) and (1 in paircard2)):
            ret = -1
        else:
            num_array1 = self.getNumArray(hands1)
            num_array2 = self.getNumArray(hands2)

            num_array1.sort()
            num_array2.sort()

            if ((1 in num_array1) and (1 not in num_array2)):
                ret = 1
            elif ((1 not in num_array1) and (1 in num_array2)):
                ret = -1
            else:
                for i in range(4, 0, -1):
                    if (num_array1[i] > num_array2[i]):
                        ret = 1
                        break
                    elif (num_array1[i] < num_array2[i]):
                        ret = -1
                        break

        return ret

    def checkTieForOnePair(self, hands1, hands2):
        ret = 0

        paircard1 = 0
        paircard2 = 0

        check_array1 = [ 0 for i in range(13) ]
        for hand1 in hands1:
            check_array1[hand1.getNumber() - 1] += 1
            if (check_array1[hand1.getNumber() - 1] >= 2):
                paircard1 = hand1.getNumber()

        check_array2 = [ 0 for i in range(13) ]
        for hand2 in hands2:
            check_array2[hand2.getNumber() - 1] += 1
            if (check_array2[hand2.getNumber() - 1] >= 2):
                paircard2 = hand2.getNumber()

        if (paircard1 != paircard2):
            if (paircard1 == 1):
                paircard1 = 14
            if (paircard2 == 1):
                paircard2 = 14

            if (paircard1 > paircard2):
                ret = 1
            else:
                ret = -1
        else:
            num_array1 = self.getNumArray(hands1)
            num_array2 = self.getNumArray(hands2)

            num_array1.sort()
            num_array2.sort()

            if ((1 in num_array1) and (1 not in num_array2)):
                ret = 1
            elif ((1 not in num_array1) and (1 in num_array2)):
                ret = -1
            else:
                for i in range(4, 0, -1):
                    if (num_array1[i] > num_array2[i]):
                        ret = 1
                        break
                    elif (num_array1[i] < num_array2[i]):
                        ret = -1
                        break

        return ret

    def checkTieForHighCard(self, hands1, hands2):
        ret = 0

        num_array1 = self.getNumArray(hands1)
        num_array2 = self.getNumArray(hands2)

        num_array1.sort()
        num_array2.sort()

        if ((1 in num_array1) and (1 not in num_array2)):
            ret = 1
        elif ((1 not in num_array1) and (1 in num_array2)):
            ret = -1
        else:
            for i in range(4, 0, -1):
                if (num_array1[i] > num_array2[i]):
                    ret = 1
                    break
                elif (num_array1[i] < num_array2[i]):
                    ret = -1
                    break

        return ret

    def makePattern1(self):
        self.card1.append(PokerCard("AS"))
        self.card1.append(PokerCard("2S"))
        self.card1.append(PokerCard("3S"))
        self.card1.append(PokerCard("4S"))
        self.card1.append(PokerCard("5S"))

        self.card2.append(PokerCard("AD"))
        self.card2.append(PokerCard("2C"))
        self.card2.append(PokerCard("3D"))
        self.card2.append(PokerCard("4C"))
        self.card2.append(PokerCard("5H"))

    def makePattern2(self):
        self.card1.append(PokerCard("AS"))
        self.card1.append(PokerCard("KS"))
        self.card1.append(PokerCard("TS"))
        self.card1.append(PokerCard("QS"))
        self.card1.append(PokerCard("JS"))

        self.card2.append(PokerCard("AD"))
        self.card2.append(PokerCard("2C"))
        self.card2.append(PokerCard("3D"))
        self.card2.append(PokerCard("4C"))
        self.card2.append(PokerCard("5H"))

    def makePattern3(self):
        self.card1.append(PokerCard("AC"))
        self.card1.append(PokerCard("2S"))
        self.card1.append(PokerCard("3S"))
        self.card1.append(PokerCard("4S"))
        self.card1.append(PokerCard("5S"))

        self.card2.append(PokerCard("AD"))
        self.card2.append(PokerCard("2C"))
        self.card2.append(PokerCard("3D"))
        self.card2.append(PokerCard("4C"))
        self.card2.append(PokerCard("5H"))

    def makePatternTieHighcard(self):
        self.card1.append(PokerCard("AC"))
        self.card1.append(PokerCard("3S"))
        self.card1.append(PokerCard("5S"))
        self.card1.append(PokerCard("7S"))
        self.card1.append(PokerCard("9S"))

        self.card2.append(PokerCard("2D"))
        self.card2.append(PokerCard("4C"))
        self.card2.append(PokerCard("6D"))
        self.card2.append(PokerCard("8C"))
        self.card2.append(PokerCard("9H"))

    def makePatternTieOnePair(self):
        self.card1.append(PokerCard("2C"))
        self.card1.append(PokerCard("3S"))
        self.card1.append(PokerCard("5S"))
        self.card1.append(PokerCard("AD"))
        self.card1.append(PokerCard("AS"))

        self.card2.append(PokerCard("2D"))
        self.card2.append(PokerCard("4C"))
        self.card2.append(PokerCard("6D"))
        self.card2.append(PokerCard("9C"))
        self.card2.append(PokerCard("9H"))

    def makePatternTieTwoPair(self):
        self.card1.append(PokerCard("AC"))
        self.card1.append(PokerCard("3S"))
        self.card1.append(PokerCard("3H"))
        self.card1.append(PokerCard("6D"))
        self.card1.append(PokerCard("6S"))

        self.card2.append(PokerCard("2D"))
        self.card2.append(PokerCard("3C"))
        self.card2.append(PokerCard("3D"))
        self.card2.append(PokerCard("AD"))
        self.card2.append(PokerCard("AH"))

    def makePatternTieThreeCard(self):
        self.card1.append(PokerCard("AC"))
        self.card1.append(PokerCard("3S"))
        self.card1.append(PokerCard("6H"))
        self.card1.append(PokerCard("6D"))
        self.card1.append(PokerCard("6S"))

        self.card2.append(PokerCard("2D"))
        self.card2.append(PokerCard("3C"))
        self.card2.append(PokerCard("AS"))
        self.card2.append(PokerCard("AD"))
        self.card2.append(PokerCard("AH"))

    def makePatternTieStraight(self):
        self.card1.append(PokerCard("AC"))
        self.card1.append(PokerCard("2S"))
        self.card1.append(PokerCard("3H"))
        self.card1.append(PokerCard("4D"))
        self.card1.append(PokerCard("5S"))

        self.card2.append(PokerCard("9D"))
        self.card2.append(PokerCard("KC"))
        self.card2.append(PokerCard("QS"))
        self.card2.append(PokerCard("JD"))
        self.card2.append(PokerCard("TH"))

    def makePatternTieFlush(self):
        self.card1.append(PokerCard("AC"))
        self.card1.append(PokerCard("2C"))
        self.card1.append(PokerCard("3C"))
        self.card1.append(PokerCard("4C"))
        self.card1.append(PokerCard("6C"))

        self.card2.append(PokerCard("AD"))
        self.card2.append(PokerCard("KD"))
        self.card2.append(PokerCard("QD"))
        self.card2.append(PokerCard("JD"))
        self.card2.append(PokerCard("9D"))

    def makePatternTieFullHouse(self):
        self.card1.append(PokerCard("AC"))
        self.card1.append(PokerCard("AH"))
        self.card1.append(PokerCard("AS"))
        self.card1.append(PokerCard("3D"))
        self.card1.append(PokerCard("3C"))

        self.card2.append(PokerCard("KD"))
        self.card2.append(PokerCard("KS"))
        self.card2.append(PokerCard("KH"))
        self.card2.append(PokerCard("QC"))
        self.card2.append(PokerCard("QD"))

    def makePatternTieFourCard(self):
        self.card1.append(PokerCard("AC"))
        self.card1.append(PokerCard("AH"))
        self.card1.append(PokerCard("AS"))
        self.card1.append(PokerCard("AD"))
        self.card1.append(PokerCard("6C"))

        self.card2.append(PokerCard("KD"))
        self.card2.append(PokerCard("KS"))
        self.card2.append(PokerCard("KH"))
        self.card2.append(PokerCard("KC"))
        self.card2.append(PokerCard("9D"))

if __name__ == '__main__':
    obj = PokerHands()

    obj.input()
    #obj.makePattern1()
    #obj.makePattern2()
    #obj.makePattern3()
    #obj.makePatternTieHighcard()
    #obj.makePatternTieOnePair()
    #obj.makePatternTieTwoPair()
    #obj.makePatternTieThreeCard()
    #obj.makePatternTieStraight()
    #obj.makePatternTieFlush()
    #obj.makePatternTieFullHouse()
    #obj.makePatternTieFourCard()

    obj.run()