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: list[str]) -> list[str]:  # each hand is a string like "4S 5S 7H 8D JC"
+    pass
+def best_hands(hands: list[str]) -> list[str]:
+    """Return the best hand(s) from a list of poker hands."""
+    if not hands:
+        return []
+    # Edge Case: Single hand provided
+    if len(hands) == 1:
+        return hands
+    ranked_hands = []
+    for hand in hands:
+        ranked_hands.append((hand, rank_hand(parse_hand(hand))))
+    # Find the maximum rank
+    max_rank = max(rank for _, rank in ranked_hands)
+    # Filter hands with maximum rank
+    best = [hand for hand, rank in ranked_hands if rank == max_rank]
+    return best
+def parse_hand(hand_str: str) -> list[tuple]:
+    """Parse a hand string into a list of tuples (value, suit)."""
+    # Edge Case: Empty hand string
+    if not hand_str.strip():
+        return []
+    cards = hand_str.split()
+    parsed_cards = []
+    for card in cards:
+        # Edge Case: Malformed card string
+        if len(card) < 2:
+            raise ValueError(f"Invalid card: {card}")
+        suit = card[-1]
+        value_str = card[:-1]
+        # Edge Case: Invalid suit
+        if suit not in 'SHDC':
+            raise ValueError(f"Invalid suit: {suit}")
+        # Convert value to number
+        if value_str == 'A':
+            value = 14
+        elif value_str == 'K':
+            value = 13
+        elif value_str == 'Q':
+            value = 12
+        elif value_str == 'J':
+            value = 11
+        else:
+            try:
+                value = int(value_str)
+                # Edge Case: Invalid card value range
+                if value < 2 or value > 10:
+                    raise ValueError(f"Invalid card value: {value}")
+            except ValueError:
+                raise ValueError(f"Invalid card value: {value_str}")
+        parsed_cards.append((value, suit))
+    # Edge Case: Hand must have exactly 5 cards
+    if len(parsed_cards) != 5:
+        raise ValueError(f"Hand must contain exactly 5 cards, got {len(parsed_cards)}")
+    return parsed_cards
+def rank_hand(hand: list[tuple]) -> tuple:
+    """Rank a poker hand and return a tuple for comparison.
+    Optimized version using efficient pattern matching and reduced redundant calculations.
+    """
+    # Extract values and suits in single pass
+    values = []
+    suits = []
+    for card in hand:
+        values.append(card[0])
+        suits.append(card[1])
+    # Sort values once for all comparisons
+    values.sort(reverse=True)
+    original_values = values.copy()
+    # Check for flush (single set operation)
+    is_flush = len(set(suits)) == 1
+    # Check for straight with optimized logic
+    is_straight = False
+    # Regular straight check (vectorized comparison)
+    if all(values[i] == values[i+1] + 1 for i in range(4)):
+        is_straight = True
+    # Ace-low straight check (single comparison)
+    elif values == [14, 5, 4, 3, 2]:
+        is_straight = True
+        values = [5, 4, 3, 2, 1]  # Renumber Ace as 1 for consistency
+    # Build value counts efficiently using dictionary comprehension
+    value_counts = {}
+    for value in values:
+        value_counts[value] = value_counts.get(value, 0) + 1
+    # Sort counts once for pattern matching
+    sorted_items = sorted(value_counts.items(), key=lambda x: (-x[1], -x[0]))
+    counts = [count for _, count in sorted_items]
+    sorted_values = [value for value, _ in sorted_items]
+    # Optimized pattern matching using count patterns
+    count_pattern = tuple(counts)
+    # Determine hand rank using efficient pattern matching
+    if is_straight and is_flush:
+        # Straight flush (including Royal Flush)
+        return (8, values)
+    elif count_pattern == (4, 1):
+        # Four of a kind - use pre-sorted values
+        return (7, [sorted_values[0], sorted_values[1]])
+    elif count_pattern == (3, 2):
+        # Full house
+        return (6, [sorted_values[0], sorted_values[1]])
+    elif is_flush:
+        # Flush - use original sorted values for proper comparison
+        return (5, original_values)
+    elif is_straight:
+        # Straight
+        return (4, values)
+    elif count_pattern == (3, 1, 1):
+        # Three of a kind
+        return (3, [sorted_values[0]] + sorted_values[1:])
+    elif count_pattern == (2, 2, 1):
+        # Two pair
+        return (2, [sorted_values[0], sorted_values[1], sorted_values[2]])
+    elif count_pattern == (2, 1, 1, 1):
+        # One pair
+        return (1, [sorted_values[0]] + sorted_values[1:])
+    else:
+        # High card
+        return (0, original_values)
+# Handled Edge Cases: Empty hands list, single hand, empty hand string, malformed card string, invalid suit, invalid card value range, hand with incorrect number of cards

Boom

Pending

Initializing Agent

Running Agent

Initializing Evaluation

Running Evaluation

Passed