Playing Cards

For this question, we ask you to design a card game using the traditional 52-card deck. We divide this question into three parts, so you can complete them in order.

Part One

For the first part, you must design a Game class representing the game, and these following functions associated with the class.

add_card(suit, value): Creates a new card object with a suit from one of the following strings: Hearts, Spades, Clubs, Diamonds, and a value from one of the following strings: A, 2~10, J, Q, K. This card is represented by i, where i is an integer indicating how many cards have been created before.
card_string(card): Returns the string representation of the card represented by i. It follows the format <value> of <suit>. For example, a card created by add_card("Spades", "3") should have a string representation of 3 of Spades.
card_beats(card_a, card_b): Check if the card represented by card_a beats the one represented by card_b. A card beats another card if and only if it has a greater value. The value of the cards are ordered from A to K.

You may implement these however you like. However, preferably this should be easily expandable to accommodate new requirements.

Try it yourself

Solution

There are numerous approaches we can take to design this problem. The sample solution will provide an object-oriented approach, since it allows us to easily add new types of cards to accommodate new requirements.

Different languages have different tools, but the most basic concept in object oriented programming is inheritance, which is a class deriving from a superclass and inheriting its methods. In this situation, a playing card from the 52 is a card. The reason for this design is that we can easily add other types of cards if we want.

Below is an implementation:

1from enum import Enum, auto
2from typing import List
3
4class Card:
5    @property
6    def card_value(self) -> int:
7        raise NotImplementedError()
8
9    def __lt__(self, other):
10        return self.card_value < other.card_value
11
12class Suit(Enum):
13    CLUBS = auto()
14    DIAMONDS = auto()
15    HEARTS = auto()
16    SPADES = auto()
17
18class PlayingCard(Card):
19    SUITS = {
20        "Clubs": Suit.CLUBS,
21        "Diamonds": Suit.DIAMONDS,
22        "Hearts": Suit.HEARTS,
23        "Spades": Suit.SPADES,
24    }
25    SUIT_NAMES = {e: n for n, e in SUITS.items()}
26    VALUES = {
27        "A": 1,
28        **{str(i): i for i in range(2, 11)},
29        "J": 11,
30        "Q": 12,
31        "K": 13,
32    }
33    VALUE_NAMES = {e: n for n, e in VALUES.items()}
34
35    def __init__(self, suit: str, value: str):
36        super().__init__()
37        self.__suit = self.SUITS[suit]
38        self.__value = self.VALUES[value]
39
40    @property
41    def card_value(self) -> int:
42        return self.__value
43
44    def __str__(self) -> str:
45        value = self.VALUE_NAMES[self.__value]
46        suit = self.SUIT_NAMES[self.__suit]
47        return f"{value} of {suit}"
48
49class Game:
50    def __init__(self) -> None:
51        self.__cards: List[Card] = []
52
53    def add_card(self, suit: str, value: str) -> None:
54        self.__cards.append(PlayingCard(suit, value))
55
56    def card_string(self, card: int) -> str:
57        return str(self.__cards[card])
58
59    def card_beats(self, card_a: int, card_b: int) -> bool:
60        return self.__cards[card_a] > self.__cards[card_b]
61
62if __name__ == "__main__":
63    game = Game()
64    suit, value = input().split()
65    game.add_card(suit, value)
66    print(game.card_string(0))
67    suit, value = input().split()
68    game.add_card(suit, value)
69    print(game.card_string(1))
70    print("true" if game.card_beats(0, 1) else "false")
71

1import java.util.ArrayList;
2import java.util.HashMap;
3import java.util.Map;
4import java.util.Map.Entry;
5import java.util.Scanner;
6import java.util.stream.Collectors;
7
8class Solution {
9    public static abstract class Card implements Comparable<Card> {
10        public abstract int getValue();
11
12        @Override
13        public int compareTo(Card o) {
14            return Integer.compare(getValue(), o.getValue());
15        }
16    }
17
18    public enum Suit {
19        SPADES,
20        HEARTS,
21        DIAMONDS,
22        CLUBS,
23    }
24
25    public static class PlayingCard extends Card {
26        private Suit suit;
27        private int value;
28
29        public static final Map<String, Suit> SUITS = Map.of(
30            "Spades", Suit.SPADES,
31            "Hearts", Suit.HEARTS,
32            "Diamonds", Suit.DIAMONDS,
33            "Clubs", Suit.CLUBS);
34
35        // Inverts the above map to convert back to string.
36        public static final Map<Suit, String> SUIT_NAMES = SUITS.entrySet().stream().collect(Collectors.toMap(Map.Entry::getValue, Map.Entry::getKey));
37
38        // Map.of is limited to 10 entries, so we initialize a static map instead
39        public static final Map<String, Integer> VALUES = new HashMap<>();
40        static {
41            VALUES.put("A", 1);
42            for (int i = 2; i <= 10; i++) {
43                VALUES.put(String.valueOf(i), i);
44            }
45            VALUES.put("J", 11);
46            VALUES.put("Q", 12);
47            VALUES.put("K", 13);
48        }
49        // Inverts the above map to convert back to string.
50        public static final Map<Integer, String> VALUE_NAMES = VALUES.entrySet().stream().collect(Collectors.toMap(Map.Entry::getValue, Map.Entry::getKey));
51
52        public PlayingCard(String suit, String value) {
53            this.suit = SUITS.get(suit);
54            this.value = VALUES.get(value);
55        }
56
57        @Override
58        public int getValue() {
59            return value;
60        }
61
62        @Override
63        public String toString() {
64            return String.format("%s of %s", VALUE_NAMES.get(value), SUIT_NAMES.get(suit));
65        }
66    }
67
68    public static class Game {
69        private ArrayList<Card> cards;
70
71        public Game() {
72            cards = new ArrayList<>();
73        }
74
75        public void addCard(String suit, String value) {
76            cards.add(new PlayingCard(suit, value));
77        }
78
79        public String cardString(int card) {
80            return cards.get(card).toString();
81        }
82
83        public boolean cardBeats(int cardA, int cardB) {
84            return cards.get(cardA).compareTo(cards.get(cardB)) > 0;
85        }
86    }
87
88    public static void main(String[] args) {
89        Scanner scanner = new Scanner(System.in);
90        Game game = new Game();
91        String[] segs = scanner.nextLine().split(" ");
92        game.addCard(segs[0], segs[1]);
93        System.out.println(game.cardString(0));
94        segs = scanner.nextLine().split(" ");
95        game.addCard(segs[0], segs[1]);
96        System.out.println(game.cardString(1));
97        System.out.println(game.cardBeats(0, 1));
98        scanner.close();
99    }
100}
101

The Game class stores a list of cards which takes O(n) space where n is the number of cards added. Each method (add_card, card_string, card_beats) uses O(1) time and O(1) space.

Part Two

For this part, we ask you to implement the Jokers into the system.

In addition to the functionalities above, also implement the following functions:

add_joker(color): Creates a Joker card with color of either Red or Black.
- Joker beats everything else except other jokers. This card is represented by i, where i is an integer indicating how many cards have been created before, including both normal cards and jokers.
- A joker's string representation is Red Joker or Black Joker, depending on the color.

You may copy the code from the previous question here.

Try it yourself

Solution

We add a Joker class that inherits the base Card. For the purpose of this question, its value is 14, which is greater than other cards. We do not need to write extra logic for comparing Jokers with other cards, since that logic is already there under Card.

Below is the updated implementation:

1from enum import Enum, auto
2
3class Card:
4    @property
5    def card_value(self) -> int:
6        raise NotImplementedError()
7
8    def __lt__(self, other):
9        return self.card_value < other.card_value
10
11class Suit(Enum):
12    CLUBS = auto()
13    DIAMONDS = auto()
14    HEARTS = auto()
15    SPADES = auto()
16
17class PlayingCard(Card):
18    SUITS = {
19        "Clubs": Suit.CLUBS,
20        "Diamonds": Suit.DIAMONDS,
21        "Hearts": Suit.HEARTS,
22        "Spades": Suit.SPADES,
23    }
24    SUIT_NAMES = {e: n for n, e in SUITS.items()}
25    VALUES = {
26        "A": 1,
27        **{str(i): i for i in range(2, 11)},
28        "J": 11,
29        "Q": 12,
30        "K": 13,
31    }
32    VALUE_NAMES = {e: n for n, e in VALUES.items()}
33
34    def __init__(self, suit: str, value: str):
35        super().__init__()
36        self.__suit = self.SUITS[suit]
37        self.__value = self.VALUES[value]
38
39    @property
40    def card_value(self) -> int:
41        return self.__value
42
43    def __str__(self) -> str:
44        value = self.VALUE_NAMES[self.__value]
45        suit = self.SUIT_NAMES[self.__suit]
46        return f"{value} of {suit}"
47
48class JokerColor(Enum):
49    RED = auto()
50    BLACK = auto()
51
52class Joker(Card):
53    COLORS = {
54        "Red": JokerColor.RED,
55        "Black": JokerColor.BLACK,
56    }
57
58    COLOR_NAMES = {e: n for n, e in COLORS.items()}
59
60    def __init__(self, color: str):
61        super().__init__()
62        self.__color = self.COLORS[color]
63
64    @property
65    def card_value(self):
66        return 14
67
68    def __str__(self) -> str:
69        return f"{self.COLOR_NAMES[self.__color]} Joker"
70
71class Game:
72    def __init__(self):
73        self.__cards: list[Card] = []
74
75    def add_card(self, suit: str, value: str) -> None:
76        self.__cards.append(PlayingCard(suit, value))
77
78    def card_string(self, card: int) -> str:
79        return str(self.__cards[card])
80
81    def card_beats(self, card_a: int, card_b: int) -> bool:
82        return self.__cards[card_a] > self.__cards[card_b]
83
84    def add_joker(self, color: str) -> None:
85        self.__cards.append(Joker(color))
86
87if __name__ == "__main__":
88    game = Game()
89    suit, value = input().split()
90    game.add_joker(value) if suit == "Joker" else game.add_card(suit, value)
91    print(game.card_string(0))
92    suit, value = input().split()
93    game.add_joker(value) if suit == "Joker" else game.add_card(suit, value)
94    print(game.card_string(1))
95    print("true" if game.card_beats(0, 1) else "false")
96

1import java.util.ArrayList;
2import java.util.HashMap;
3import java.util.Map;
4import java.util.Map.Entry;
5import java.util.Scanner;
6import java.util.stream.Collectors;
7
8class Solution {
9    public static abstract class Card implements Comparable<Card> {
10        public abstract int getValue();
11
12        @Override
13        public int compareTo(Card o) {
14            return Integer.compare(getValue(), o.getValue());
15        }
16    }
17
18    public enum Suit {
19        SPADES,
20        HEARTS,
21        DIAMONDS,
22        CLUBS,
23    }
24
25    public static class PlayingCard extends Card {
26        private Suit suit;
27        private int value;
28
29        public static final Map<String, Suit> SUITS = Map.of(
30            "Spades", Suit.SPADES,
31            "Hearts", Suit.HEARTS,
32            "Diamonds", Suit.DIAMONDS,
33            "Clubs", Suit.CLUBS);
34
35        // Inverts the above map to convert back to string.
36        public static final Map<Suit, String> SUIT_NAMES = SUITS.entrySet().stream().collect(Collectors.toMap(Map.Entry::getValue, Map.Entry::getKey));
37
38        // Map.of is limited to 10 entries, so we initialize a static map instead
39        public static final Map<String, Integer> VALUES = new HashMap<>();
40        static {
41            VALUES.put("A", 1);
42            for (int i = 2; i <= 10; i++) {
43                VALUES.put(String.valueOf(i), i);
44            }
45            VALUES.put("J", 11);
46            VALUES.put("Q", 12);
47            VALUES.put("K", 13);
48        }
49        // Inverts the above map to convert back to string.
50        public static final Map<Integer, String> VALUE_NAMES = VALUES.entrySet().stream().collect(Collectors.toMap(Map.Entry::getValue, Map.Entry::getKey));
51
52        public PlayingCard(String suit, String value) {
53            this.suit = SUITS.get(suit);
54            this.value = VALUES.get(value);
55        }
56
57        @Override
58        public int getValue() {
59            return value;
60        }
61
62        @Override
63        public String toString() {
64            return String.format("%s of %s", VALUE_NAMES.get(value), SUIT_NAMES.get(suit));
65        }
66    }
67
68    public enum JokerColor {
69        RED,
70        BLACK,
71    }
72
73    public static class Joker extends Card {
74        private JokerColor color;
75
76        public static final Map<String, JokerColor> COLORS = Map.of(
77            "Red", JokerColor.RED,
78            "Black", JokerColor.BLACK);
79
80        // Inverts the above map to convert back to string.
81        public static final Map<JokerColor, String> COLOR_NAMES = COLORS.entrySet().stream().collect(Collectors.toMap(Map.Entry::getValue, Map.Entry::getKey));
82
83        public Joker(String color) {
84            this.color = COLORS.get(color);
85        }
86
87        @Override
88        public int getValue() {
89            return 14;
90        }
91
92        @Override
93        public String toString() {
94            return String.format("%s Joker", COLOR_NAMES.get(color));
95        }
96    }
97
98    public static class Game {
99        private ArrayList<Card> cards;
100
101        public Game() {
102            cards = new ArrayList<>();
103        }
104
105        public void addCard(String suit, String value) {
106            cards.add(new PlayingCard(suit, value));
107        }
108
109        public String cardString(int card) {
110            return cards.get(card).toString();
111        }
112
113        public boolean cardBeats(int cardA, int cardB) {
114            return cards.get(cardA).compareTo(cards.get(cardB)) > 0;
115        }
116
117        public void addJoker(String color) {
118            cards.add(new Joker(color));
119        }
120    }
121
122    public static void main(String[] args) {
123        Scanner scanner = new Scanner(System.in);
124        Game game = new Game();
125        String[] segs = scanner.nextLine().split(" ");
126        if (segs[0].equals("Joker"))
127            game.addJoker(segs[1]);
128        else
129            game.addCard(segs[0], segs[1]);
130        System.out.println(game.cardString(0));
131        segs = scanner.nextLine().split(" ");
132        if (segs[0].equals("Joker"))
133            game.addJoker(segs[1]);
134        else
135            game.addCard(segs[0], segs[1]);
136        System.out.println(game.cardString(1));
137        System.out.println(game.cardBeats(0, 1));
138        scanner.close();
139    }
140}
141

The method add_joker uses O(1) time and O(1) space.

Part Three

This game also involve a concept of a Hand and comparing the size of the two hands. For this part, add these following functions to the Game class:

add_hand(card_indices): Create a new Hand with cards represented by the list of integer representation of cards card_indices. The hand can be represented by i, where i is the number of hands added before.
hand_string(hand): Return the string representation of the hand represented by hand. It is a list of string representation of cards by their insertion order, separated by ", ". For example, if hand has a 9 of Clubs, K of Hearts, and a Black Joker, the string representation is "9 of Clubs, K of Hearts, Black Joker".
beats_hand(hand_a, hand_b): Check if the hand represented by hand_a beats the hand represented by hand_b according to the following rules:
- Starting from the largest card in each hand, compare them. If a card beats another, that hand beats the other hand. Otherwise, compare the next largest card.
- Repeat this process until one hand beats the other, or one hand runs out of cards. If a hand runs out of cards, neither hand beat each other.

Try it yourself

Solution

For this part, we implement the Hand class by having it contain a list of cards. When we compare two hands, because we defined a comparison function between two cards, we can sort them using the default sorting algorithm.

Below is the implementation:

1from enum import Enum, auto
2from typing import List
3
4class Card:
5    @property
6    def card_value(self) -> int:
7        raise NotImplementedError()
8
9    def __lt__(self, other):
10        return self.card_value < other.card_value
11
12class Suit(Enum):
13    CLUBS = auto()
14    DIAMONDS = auto()
15    HEARTS = auto()
16    SPADES = auto()
17
18class PlayingCard(Card):
19    SUITS = {
20        "Clubs": Suit.CLUBS,
21        "Diamonds": Suit.DIAMONDS,
22        "Hearts": Suit.HEARTS,
23        "Spades": Suit.SPADES,
24    }
25    SUIT_NAMES = {e: n for n, e in SUITS.items()}
26    VALUES = {
27        "A": 1,
28        **{str(i): i for i in range(2, 11)},
29        "J": 11,
30        "Q": 12,
31        "K": 13,
32    }
33    VALUE_NAMES = {e: n for n, e in VALUES.items()}
34
35    def __init__(self, suit: str, value: str) -> None:
36        super().__init__()
37        self.__suit = self.SUITS[suit]
38        self.__value = self.VALUES[value]
39
40    @property
41    def card_value(self) -> int:
42        return self.__value
43
44    def __str__(self) -> str:
45        value = self.VALUE_NAMES[self.__value]
46        suit = self.SUIT_NAMES[self.__suit]
47        return f"{value} of {suit}"
48
49class JokerColor(Enum):
50    RED = auto()
51    BLACK = auto()
52
53class Joker(Card):
54    COLORS = {
55        "Red": JokerColor.RED,
56        "Black": JokerColor.BLACK,
57    }
58
59    COLOR_NAMES = {e: n for n, e in COLORS.items()}
60
61    def __init__(self, color: str) -> None:
62        super().__init__()
63        self.__color = self.COLORS[color]
64
65    @property
66    def card_value(self) -> int:
67        return 14
68
69    def __str__(self) -> str:
70        return f"{self.COLOR_NAMES[self.__color]} Joker"
71
72class Hand:
73    def __init__(self, cards: List[Card]) -> None:
74        super().__init__()
75        self.cards = list(cards)
76
77    def __str__(self) -> str:
78        return ", ".join(str(card) for card in self.cards)
79
80    def __lt__(self, other):
81        for card_a, card_b in zip(
82            sorted(self.cards, reverse=True),
83            sorted(other.cards, reverse=True),
84        ):
85            if card_a < card_b:
86                return True
87            elif card_b < card_a:
88                return False
89        return False
90
91class Game:
92    def __init__(self):
93        self.__cards: list[Card] = []
94        self.__hands: list[Hand] = []
95
96    def add_card(self, suit: str, value: str) -> None:
97        self.__cards.append(PlayingCard(suit, value))
98
99    def card_string(self, card: int) -> str:
100        return str(self.__cards[card])
101
102    def card_beats(self, card_a: int, card_b: int) -> bool:
103        return self.__cards[card_a] > self.__cards[card_b]
104
105    def add_joker(self, color: str) -> None:
106        self.__cards.append(Joker(color))
107
108    def add_hand(self, card_indices: List[int]) -> None:
109        self.__hands.append(Hand([self.__cards[i] for i in card_indices]))
110
111    def hand_string(self, hand: int) -> str:
112        return str(self.__hands[hand])
113
114    def hand_beats(self, hand_a: int, hand_b: int) -> bool:
115        return self.__hands[hand_a] > self.__hands[hand_b]
116
117if __name__ == "__main__":
118    game = Game()
119    offset = 0
120    for hand in range(2):
121        hand_list = []
122        n = int(input())
123        for i in range(n):
124            suit, value = input().split()
125            if suit == "Joker":
126                game.add_joker(value)
127            else:
128                game.add_card(suit, value)
129            hand_list.append(offset + i)
130        offset += n
131        game.add_hand(hand_list)
132        print(game.hand_string(hand))
133    print("true" if game.hand_beats(0, 1) else "false")
134

1import java.util.ArrayList;
2import java.util.Collections;
3import java.util.HashMap;
4import java.util.List;
5import java.util.Map;
6import java.util.Map.Entry;
7import java.util.Scanner;
8import java.util.stream.Collectors;
9
10class Solution {
11    public static abstract class Card implements Comparable<Card> {
12        public abstract int getValue();
13
14        @Override
15        public int compareTo(Card o) {
16            return Integer.compare(getValue(), o.getValue());
17        }
18    }
19
20    public enum Suit {
21        SPADES,
22        HEARTS,
23        DIAMONDS,
24        CLUBS,
25    }
26
27    public static class PlayingCard extends Card {
28        private Suit suit;
29        private int value;
30
31        public static final Map<String, Suit> SUITS = Map.of(
32            "Spades", Suit.SPADES,
33            "Hearts", Suit.HEARTS,
34            "Diamonds", Suit.DIAMONDS,
35            "Clubs", Suit.CLUBS);
36
37        // Inverts the above map to convert back to string.
38        public static final Map<Suit, String> SUIT_NAMES = SUITS.entrySet().stream().collect(Collectors.toMap(Map.Entry::getValue, Map.Entry::getKey));
39
40        // Map.of is limited to 10 entries, so we initialize a static map instead
41        public static final Map<String, Integer> VALUES = new HashMap<>();
42        static {
43            VALUES.put("A", 1);
44            for (int i = 2; i <= 10; i++) {
45                VALUES.put(String.valueOf(i), i);
46            }
47            VALUES.put("J", 11);
48            VALUES.put("Q", 12);
49            VALUES.put("K", 13);
50        }
51        // Inverts the above map to convert back to string.
52        public static final Map<Integer, String> VALUE_NAMES = VALUES.entrySet().stream().collect(Collectors.toMap(Map.Entry::getValue, Map.Entry::getKey));
53
54        public PlayingCard(String suit, String value) {
55            this.suit = SUITS.get(suit);
56            this.value = VALUES.get(value);
57        }
58
59        @Override
60        public int getValue() {
61            return value;
62        }
63
64        @Override
65        public String toString() {
66            return String.format("%s of %s", VALUE_NAMES.get(value), SUIT_NAMES.get(suit));
67        }
68    }
69
70    public enum JokerColor {
71        RED,
72        BLACK,
73    }
74
75    public static class Joker extends Card {
76        private JokerColor color;
77
78        public static final Map<String, JokerColor> COLORS = Map.of(
79            "Red", JokerColor.RED,
80            "Black", JokerColor.BLACK);
81
82        // Inverts the above map to convert back to string.
83        public static final Map<JokerColor, String> COLOR_NAMES = COLORS.entrySet().stream().collect(Collectors.toMap(Map.Entry::getValue, Map.Entry::getKey));
84
85        public Joker(String color) {
86            this.color = COLORS.get(color);
87        }
88
89        @Override
90        public int getValue() {
91            return 14;
92        }
93
94        @Override
95        public String toString() {
96            return String.format("%s Joker", COLOR_NAMES.get(color));
97        }
98    }
99
100    public static class Hand implements Comparable<Hand> {
101        public ArrayList<Card> cards;
102
103        public Hand(List<Card> cards) {
104            this.cards = new ArrayList<>(cards);
105        }
106
107        @Override
108        public String toString() {
109            return cards.stream().map(String::valueOf).collect(Collectors.joining(", "));
110        }
111
112        @Override
113        public int compareTo(Hand o) {
114            ArrayList<Card> selfCards = new ArrayList<>(cards);
115            ArrayList<Card> otherCards = new ArrayList<>(o.cards);
116            Collections.sort(selfCards);
117            Collections.sort(otherCards);
118            for (int i = selfCards.size() - 1, j = otherCards.size() - 1; i >= 0 && j >= 0; i--, j--) {
119                int res = selfCards.get(i).compareTo(otherCards.get(j));
120                if (res != 0) {
121                    return res;
122                }
123            }
124            return 0;
125        }
126    }
127
128    public static class Game {
129        private ArrayList<Card> cards;
130        private ArrayList<Hand> hands;
131
132        public Game() {
133            cards = new ArrayList<>();
134            hands = new ArrayList<>();
135        }
136
137        public void addCard(String suit, String value) {
138            cards.add(new PlayingCard(suit, value));
139        }
140
141        public String cardString(int card) {
142            return cards.get(card).toString();
143        }
144
145        public boolean cardBeats(int cardA, int cardB) {
146            return cards.get(cardA).compareTo(cards.get(cardB)) > 0;
147        }
148
149        public void addJoker(String color) {
150            cards.add(new Joker(color));
151        }
152
153        public void addHand(List<Integer> cardIndices) {
154            ArrayList<Card> cardObjects = new ArrayList<>();
155            for (int i : cardIndices) {
156                cardObjects.add(cards.get(i));
157            }
158            hands.add(new Hand(cardObjects));
159        }
160
161        public String handString(int hand) {
162            return hands.get(hand).toString();
163        }
164
165        public boolean handBeats(int handA, int handB) {
166            return hands.get(handA).compareTo(hands.get(handB)) > 0;
167        }
168    }
169
170    public static void main(String[] args) {
171        Scanner scanner = new Scanner(System.in);
172        Game game = new Game();
173        int i = 0;
174        int end = 0;
175        for (int hand = 0; hand < 2; hand++) {
176            ArrayList<Integer> handList = new ArrayList<>();
177            end += Integer.parseInt(scanner.nextLine());
178            for (; i < end; i++) {
179                String[] segs = scanner.nextLine().split(" ");
180                if (segs[0].equals("Joker"))
181                    game.addJoker(segs[1]);
182                else
183                    game.addCard(segs[0], segs[1]);
184                handList.add(i);
185            }
186            game.addHand(handList);
187            System.out.println(game.handString(hand));
188        }
189        System.out.println(game.handBeats(0, 1));
190        scanner.close();
191    }
192}
193

add_hand is to initialize a Hand instance; it uses O(n) time complexity and stores the list of cards using O(n) space, where n is the number of cards given to the hand. both hand_string and hand_beats take O(1) space. hand_string takes O(1) time and hand_beats takes O(min(n,m)) time where n and m are the size of the two hands respectively.