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]:
+    """
+    Determine the best poker hand(s) from a list of poker hands.
+    Args:
+        hands: List of strings, each representing a poker hand with 5 cards
+    Returns:
+        List of strings representing the best hand(s)
+    """
+    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(hand)))
+    # Find the maximum rank
+    max_rank = max(rank for _, rank in ranked_hands)
+    # Filter hands with maximum rank
+    best_hands_list = [hand for hand, rank in ranked_hands if rank == max_rank]
+    return best_hands_list
+def rank_hand(hand: str) -> tuple:
+    """
+    Rank a poker hand according to its strength.
+    Returns a tuple where the first element is the hand rank (higher is better)
+    and subsequent elements are tie-breakers.
+    """
+    cards = hand.split()
+    # Edge Case: Invalid hand format
+    if len(cards) != 5:
+        raise ValueError("Each hand must contain exactly 5 cards")
+    values = []
+    suits = []
+    for card in cards:
+        # Edge Case: Invalid card format
+        if len(card) < 2 or len(card) > 3:
+            raise ValueError(f"Invalid card format: {card}")
+        value = card[:-1]
+        suit = card[-1]
+        # Edge Case: Invalid suit
+        if suit not in 'SHDC':
+            raise ValueError(f"Invalid suit: {suit}")
+        # Convert face cards to numbers
+        if value == 'A':
+            numeric_value = 14
+        elif value == 'K':
+            numeric_value = 13
+        elif value == 'Q':
+            numeric_value = 12
+        elif value == 'J':
+            numeric_value = 11
+        else:
+            try:
+                numeric_value = int(value)
+                # Edge Case: Invalid card value
+                if numeric_value < 2 or numeric_value > 10:
+                    raise ValueError(f"Invalid card value: {value}")
+            except ValueError:
+                raise ValueError(f"Invalid card value: {value}")
+        values.append(numeric_value)
+        suits.append(suit)
+    # Sort values for easier comparison
+    values.sort()
+    # Check for flush (all cards same suit)
+    is_flush = len(set(suits)) == 1
+    # Check for straight
+    is_straight = False
+    # Special case: Ace-low straight (A,2,3,4,5)
+    if values == [2, 3, 4, 5, 14]:
+        is_straight = True
+        # For tie-breaking, treat Ace as 1 in this case
+        values = [1, 2, 3, 4, 5]
+    # Normal straight
+    elif all(values[i] + 1 == values[i+1] for i in range(4)):
+        is_straight = True
+    # Count occurrences of each value
+    value_counts = {}
+    for value in values:
+        value_counts[value] = value_counts.get(value, 0) + 1
+    counts = sorted(value_counts.values(), reverse=True)
+    # Determine hand rank
+    if is_straight and is_flush:
+        # Straight flush
+        return (8, values[-1])  # Rank 8, high card for tie-break
+    elif 4 in counts:
+        # Four of a kind
+        four_kind_value = [v for v, count in value_counts.items() if count == 4][0]
+        other_value = [v for v, count in value_counts.items() if count == 1][0]
+        return (7, four_kind_value, other_value)  # Rank 7, four of a kind value, kicker
+    elif 3 in counts and 2 in counts:
+        # Full house
+        three_kind_value = [v for v, count in value_counts.items() if count == 3][0]
+        pair_value = [v for v, count in value_counts.items() if count == 2][0]
+        return (6, three_kind_value, pair_value)  # Rank 6, three of a kind value, pair value
+    elif is_flush:
+        # Flush
+        return (5, values[4], values[3], values[2], values[1], values[0])  # Rank 5, sorted values for tie-break
+    elif is_straight:
+        # Straight
+        return (4, values[-1])  # Rank 4, high card for tie-break
+    elif 3 in counts:
+        # Three of a kind
+        three_kind_value = [v for v, count in value_counts.items() if count == 3][0]
+        other_values = sorted([v for v, count in value_counts.items() if count == 1], reverse=True)
+        return (3, three_kind_value, other_values[0], other_values[1])  # Rank 3, three of a kind value, kickers
+    elif counts.count(2) == 2:
+        # Two pair
+        pair_values = sorted([v for v, count in value_counts.items() if count == 2], reverse=True)
+        other_value = [v for v, count in value_counts.items() if count == 1][0]
+        return (2, pair_values[0], pair_values[1], other_value)  # Rank 2, pair values, kicker
+    elif 2 in counts:
+        # One pair
+        pair_value = [v for v, count in value_counts.items() if count == 2][0]
+        other_values = sorted([v for v, count in value_counts.items() if count == 1], reverse=True)
+        return (1, pair_value, other_values[0], other_values[1], other_values[2])  # Rank 1, pair value, kickers
+    else:
+        # High card
+        return (0, values[4], values[3], values[2], values[1], values[0])  # Rank 0, sorted values for tie-break
+# Handled Edge Cases: Empty hands list, single hand, invalid hand format (not 5 cards), invalid card format, invalid suit, invalid card value, ace-low straight

0xtao

Pending

Initializing Agent

Running Agent

Initializing Evaluation

Running Evaluation

Passed