Day 7

day07-1.py

+from collections import Counter
+
+from helpers import Helper
+
+helper = Helper(debug=True)
+debug = helper.debug
+load_input = helper.load_input
+
+CARD_VALUES = []
+for i in range(2,10):
+    CARD_VALUES.append(str(i))
+CARD_VALUES.extend(["T", "J", "Q", "K", "A"])
+
+HAND_VALUES = [
+    "High card",
+    "One pair",
+    "Two pair",
+    "Three of a kind",
+    "Full House",
+    "Four of a kind",
+    "Five of a kind"
+]
+
+class Hand:
+    def __init__(self, cards, bid):
+        self.cards = cards
+        self.bid = bid
+
+    @property
+    def value(self):
+        card_counter = Counter(self.cards)
+        card_counts = card_counter  .most_common()
+        if card_counts[0][1] == 5:
+            return "Five of a kind"
+        if card_counts[0][1] == 4:
+            return "Four of a kind"
+        if card_counts[0][1] == 3:
+            if card_counts[1][1] == 2:
+                return "Full House"
+            return "Three of a kind"
+        if card_counts[0][1] == 2:
+            if card_counts[1][1] == 2:
+                return "Two pair"
+            return "One pair"
+        return "High card"
+
+    def __lt__(self, other):
+        # They have different hand values
+        if self.value != other.value:
+            return HAND_VALUES.index(self.value) < HAND_VALUES.index(other.value)
+        # They have the same hand value
+        # So check each card in sequence
+        for i in range(len(self.cards)):
+            if self.cards[i] != other.cards[i]:
+                # They have different nth cards
+                return CARD_VALUES.index(self.cards[i]) < CARD_VALUES.index(other.cards[i])
+        # They're the same
+        return False
+    
+    def __str__(self):
+        return f"Camel Cards hand: {self.cards} (value {self.value}, bid {self.bid})"
+    
+    def __repr__(self):
+        return self.__str__()
+        
+
+def main():
+    lines = load_input(7)
+    hands = []
+    for line in lines:
+        cards, bid = line.split()
+        hands.append(Hand(
+            cards = cards,
+            bid = bid
+        ))
+    hands.sort()
+    print(hands[:10])
+
+    total_winnings = 0
+    for i, hand in enumerate(hands):
+        total_winnings += ((i+1) * int(hand.bid))
+
+    print(f"Total winnings: {total_winnings}")
+
+if __name__ == "__main__":
+    main()

day07-2.py

+from collections import Counter
+
+from helpers import Helper
+
+helper = Helper(debug=True)
+debug = helper.debug
+load_input = helper.load_input
+
+CARD_VALUES = ["J"]
+for i in range(2,10):
+    CARD_VALUES.append(str(i))
+CARD_VALUES.extend(["T", "Q", "K", "A"])
+
+HAND_VALUES = [
+    "High card",
+    "One pair",
+    "Two pair",
+    "Three of a kind",
+    "Full House",
+    "Four of a kind",
+    "Five of a kind"
+]
+
+class Hand:
+    def __init__(self, cards, bid):
+        self.cards = cards
+        self.bid = bid
+
+    @property
+    def value(self):
+        card_counter = Counter(self.cards)
+        card_counts = card_counter.most_common()
+        # We have to separate J being the most common card out,
+        # or else it might get counted twice.
+        if card_counts[0][0] == "J":
+            # Five jacks is five of a kind.
+            # Four jacks is five of a kind too, because the other card counts.
+            # Three jacks plus two of another card is five of a kind.
+            if (card_counts[0][1] == 5 
+                or card_counts[0][1] == 4
+                or (card_counts[0][1] == 3 and card_counts[1][1] == 2)
+            ):
+                return "Five of a kind"
+            # Three jacks is four of a kind, because the next most common card counts.
+            # Two jacks plus two of another card is four of a kind.
+            if (card_counts[0][1] == 3
+                or (card_counts[0][1] == 2 and card_counts[1][1] == 2)
+            ):
+                return "Four of a kind"
+            # Weirdly, you can only get a full house if there's only one jack...
+            # and if that's the case, it won't be at the front of most_common().
+            if card_counts[0][1] == 2:
+                return "Three of a kind"
+            # If J is at the front of most_common(), and there's only one of it,
+            # then there's no more than 1 of any other card. So we have a pair.
+            return "One pair"
+            
+        # Okay, done with J being at the front.
+        # There are five cards of a kind, or (three/four) cards of a kind and 
+        # (one/two) J.
+        # If there are only two of a kind at the front, then there aren't more
+        # than two of any other kind, so we can't get to 5.
+        if card_counts[0][1] == 5 or card_counts[0][1] + card_counter["J"] == 5:
+            return "Five of a kind"
+        # There are four cards of a kind without a J, or (two/three) cards of 
+        # a kind and (one/two) J.
+        if card_counts[0][1] == 4 or card_counts[0][1] + card_counter["J"] == 4:
+            return "Four of a kind"
+        # There are three cards of a kind without a J, or two cards of a kind and
+        # exactly one J.
+        if card_counts[0][1] == 3 or card_counts[0][1] + card_counter["J"] == 3:
+            # We know the most common card isn't a J; we already covered that
+            # in a separate branch. 
+            # If the most common count is 3 and there's a J, we already covered
+            # that too, with four and five of a kind.
+            # If the most common count is 2 and there are 2 Js, we already covered
+            # that with four of a kind.
+            # So if the most common count is 2 and there's a J, it can't be in second
+            # position, and if the most common count is 3 then there can't be a J.
+            # So we can discard the possibility that J is in second position.
+            if card_counts[1][1] == 2:
+                return "Full House"
+            return "Three of a kind"
+        # There are two of the most common card without any Js, or one and a single J.
+        if card_counts[0][1] == 2 or card_counts[0][1] + card_counter["J"] == 2:
+            # Same logic as above. If J were the second-most-common card we'd have
+            # already encountered it. 
+            if card_counts[1][1] == 2:
+                return "Two pair"
+            return "One pair"
+        return "High card"
+
+    def __lt__(self, other):
+        # They have different hand values
+        if self.value != other.value:
+            return HAND_VALUES.index(self.value) < HAND_VALUES.index(other.value)
+        # They have the same hand value
+        # So check each card in sequence
+        for i in range(len(self.cards)):
+            if self.cards[i] != other.cards[i]:
+                # They have different nth cards
+                return CARD_VALUES.index(self.cards[i]) < CARD_VALUES.index(other.cards[i])
+        # They're the same
+        return False
+    
+    def __str__(self):
+        return f"Camel Cards hand: {self.cards} (value {self.value}, bid {self.bid})"
+    
+    def __repr__(self):
+        return self.__str__()
+        
+
+def main():
+    lines = load_input(7)
+    hands = []
+    for line in lines:
+        cards, bid = line.split()
+        hands.append(Hand(
+            cards = cards,
+            bid = bid
+        ))
+    hands.sort()
+    print(hands[:10])
+
+    total_winnings = 0
+    for i, hand in enumerate(hands):
+        total_winnings += ((i+1) * int(hand.bid))
+
+    print(f"Total winnings: {total_winnings}")
+
+if __name__ == "__main__":
+    main()