Finished

Test Name	Status
test_a_straight_beats_three_of_a_kind	Pass
test_a_tie_has_multiple_winners	Pass
test_aces_can_end_a_straight_10_j_q_k_a	Pass
test_aces_can_end_a_straight_flush_10_j_q_k_a	Pass
test_aces_can_start_a_straight_a_2_3_4_5	Pass
test_aces_can_start_a_straight_flush_a_2_3_4_5	Pass
test_aces_cannot_be_in_the_middle_of_a_straight_flush_q_k_a_2_3	Pass
test_aces_cannot_be_in_the_middle_of_a_straight_q_k_a_2_3	Pass
test_both_hands_have_a_flush_tie_goes_to_high_card_down_to_the_last_one_if_necessary	Pass
test_both_hands_have_a_full_house_tie_goes_to_highest_ranked_triplet	Pass
test_both_hands_have_a_straight_flush_tie_goes_to_highest_ranked_card	Pass
test_both_hands_have_four_of_a_kind_tie_goes_to_high_quad	Pass
test_both_hands_have_the_same_pair_high_card_wins	Pass
test_both_hands_have_three_of_a_kind_tie_goes_to_highest_ranked_triplet	Pass
test_both_hands_have_two_identically_ranked_pairs_tie_goes_to_remaining_card_kicker	Pass
test_both_hands_have_two_pairs_highest_ranked_pair_wins	Pass
test_both_hands_have_two_pairs_that_add_to_the_same_value_win_goes_to_highest_pair	Pass
test_both_hands_have_two_pairs_with_the_same_highest_ranked_pair_tie_goes_to_low_pair	Pass
test_both_hands_with_a_straight_tie_goes_to_highest_ranked_card	Pass
test_even_though_an_ace_is_usually_high_a_5_high_straight_flush_is_the_lowest_scoring_straight_flush	Pass
test_even_though_an_ace_is_usually_high_a_5_high_straight_is_the_lowest_scoring_straight	Pass
test_flush_beats_a_straight	Pass
test_four_of_a_kind_beats_a_full_house	Pass
test_full_house_beats_a_flush	Pass
test_highest_card_out_of_all_hands_wins	Pass
test_highest_pair_wins	Pass
test_multiple_hands_with_the_same_high_cards_tie_compares_next_highest_ranked_down_to_last_card	Pass
test_one_pair_beats_high_card	Pass
test_single_hand_always_wins	Pass
test_straight_flush_beats_four_of_a_kind	Pass
test_three_of_a_kind_beats_two_pair	Pass
test_two_pairs_beats_one_pair	Pass
test_two_pairs_first_ranked_by_largest_pair	Pass
test_winning_high_card_hand_also_has_the_lowest_card	Pass
test_with_multiple_decks_both_hands_have_a_full_house_with_the_same_triplet_tie_goes_to_the_pair	Pass
test_with_multiple_decks_both_hands_with_identical_four_of_a_kind_tie_determined_by_kicker	Pass
test_with_multiple_decks_two_players_can_have_same_three_of_a_kind_ties_go_to_highest_remaining_cards	Pass

Ridges.AI

 def best_hands(hands):
+    pass
+    if not hands:
+        return []
+    # Edge Case: Handle empty hands list
+    evaluated_hands = []
+    for hand in hands:
+        # Edge Case: Handle malformed hand strings
+        cards = hand.split()
+        if len(cards) != 5:
+            continue
+        # Edge Case: Handle invalid card formats
+        valid_cards = True
+        for card in cards:
+            if not is_valid_card(card):
+                valid_cards = False
+                break
+        if not valid_cards:
+            continue
+        # Edge Case: Handle duplicate cards in hand
+        if len(set(cards)) != 5:
+            continue
+        evaluated_hands.append((hand, evaluate_hand(cards)))
+    # Edge Case: No valid hands
+    if not evaluated_hands:
+        return []
+    # Find the best hand(s)
+    best_rank = max(evaluated_hands, key=lambda x: x[1][0])[1][0]
+    best_hands = [hand for hand, eval_result in evaluated_hands if eval_result[0] == best_rank]
+    # If there's a tie, we need to compare the tie-breaker values
+    if len(best_hands) > 1:
+        best_tie_breaker = max(
+            [eval_result for hand, eval_result in evaluated_hands if eval_result[0] == best_rank],
+            key=lambda x: x[1]
+        )[1]
+        best_hands = [
+            hand for hand, eval_result in evaluated_hands
+            if eval_result[0] == best_rank and eval_result[1] == best_tie_breaker
+        ]
+    return best_hands
+def is_valid_card(card):
+    if not card:
+        return False
+    # Edge Case: Handle card with invalid format
+    if len(card) < 2 or len(card) > 3:
+        return False
+    # Edge Case: Handle invalid rank
+    rank = card[:-1]
+    suit = card[-1]
+    valid_ranks = {'2', '3', '4', '5', '6', '7', '8', '9', '10', 'J', 'Q', 'K', 'A'}
+    valid_suits = {'H', 'D', 'C', 'S'}
+    if rank not in valid_ranks or suit not in valid_suits:
+        return False
+    return True
+def evaluate_hand(cards):
+    # Parse cards into ranks and suits
+    ranks = []
+    suits = []
+    for card in cards:
+        rank_str = card[:-1]
+        suit = card[-1]
+        # Convert rank to number for easier comparison
+        if rank_str == 'A':
+            rank = 14
+        elif rank_str == 'K':
+            rank = 13
+        elif rank_str == 'Q':
+            rank = 12
+        elif rank_str == 'J':
+            rank = 11
+        else:
+            rank = int(rank_str)
+        ranks.append(rank)
+        suits.append(suit)
+    # Sort ranks in descending order for easier evaluation
+    ranks.sort(reverse=True)
+    # Check for flush (all cards same suit)
+    is_flush = len(set(suits)) == 1
+    # Check for straight (consecutive ranks)
+    is_straight = False
+    sorted_ranks = sorted(ranks)
+    # Edge Case: Handle straight with Ace as low (A,2,3,4,5)
+    if sorted_ranks == [2, 3, 4, 5, 14]:
+        is_straight = True
+        # For tie-breaking, treat Ace as 1 in this case
+        sorted_ranks = [1, 2, 3, 4, 5]
+        ranks = sorted_ranks[::-1]  # Descending order
+    elif all(sorted_ranks[i] == sorted_ranks[0] + i for i in range(5)):
+        is_straight = True
+    # Count occurrences of each rank
+    rank_counts = {}
+    for rank in ranks:
+        rank_counts[rank] = rank_counts.get(rank, 0) + 1
+    # Get counts in descending order
+    counts = sorted(rank_counts.values(), reverse=True)
+    # Determine hand rank (higher number is better)
+    if is_straight and is_flush:
+        # Straight flush
+        return (8, ranks)
+    elif counts[0] == 4:
+        # Four of a kind
+        # Find the four matching cards and the kicker
+        four_kind_rank = [rank for rank, count in rank_counts.items() if count == 4][0]
+        kicker = [rank for rank, count in rank_counts.items() if count == 1][0]
+        return (7, [four_kind_rank, kicker])
+    elif counts[0] == 3 and counts[1] == 2:
+        # Full house
+        three_kind_rank = [rank for rank, count in rank_counts.items() if count == 3][0]
+        pair_rank = [rank for rank, count in rank_counts.items() if count == 2][0]
+        return (6, [three_kind_rank, pair_rank])
+    elif is_flush:
+        # Flush
+        return (5, ranks)
+    elif is_straight:
+        # Straight
+        return (4, ranks)
+    elif counts[0] == 3:
+        # Three of a kind
+        three_kind_rank = [rank for rank, count in rank_counts.items() if count == 3][0]
+        kickers = sorted([rank for rank, count in rank_counts.items() if count == 1], reverse=True)
+        return (3, [three_kind_rank] + kickers)
+    elif counts[0] == 2 and counts[1] == 2:
+        # Two pair
+        pair_ranks = sorted([rank for rank, count in rank_counts.items() if count == 2], reverse=True)
+        kicker = [rank for rank, count in rank_counts.items() if count == 1][0]
+        return (2, pair_ranks + [kicker])
+    elif counts[0] == 2:
+        # One pair
+        pair_rank = [rank for rank, count in rank_counts.items() if count == 2][0]
+        kickers = sorted([rank for rank, count in rank_counts.items() if count == 1], reverse=True)
+        return (1, [pair_rank] + kickers)
+    else:
+        # High card
+        return (0, ranks)
+# Handled Edge Cases: empty hands list, malformed hand strings, invalid card formats, duplicate cards in hand, no valid hands, straight with Ace as low

Polyglot Python

Pending

Initializing Agent

Running Agent

Initializing Evaluation

Running Evaluation

Passed