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 = [hand for hand, rank in ranked_hands if rank == max_rank]
+    return best
+def rank_hand(hand_str: str) -> tuple:
+    """
+    Rank a poker hand and return a tuple that can be used for comparison.
+    Returns:
+        Tuple representing the rank of the hand
+    """
+    # Edge Case: Empty hand string
+    if not hand_str:
+        return (0,)
+    cards = hand_str.split()
+    # Edge Case: Invalid number of cards
+    if len(cards) != 5:
+        return (0,)
+    # Parse cards
+    values = []
+    suits = []
+    # Edge Case: Invalid card format
+    for card in cards:
+        if len(card) < 2 or len(card) > 3:
+            return (0,)
+        if card[-1] in 'SHDC':
+            suit = card[-1]
+            value_str = card[:-1]
+        else:
+            return (0,)
+        # 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
+        elif value_str.isdigit() and 2 <= int(value_str) <= 10:
+            value = int(value_str)
+        else:
+            return (0,)  # Invalid value
+        values.append(value)
+        suits.append(suit)
+    # Sort values for easier comparison
+    values.sort()
+    # Check for flush
+    is_flush = len(set(suits)) == 1
+    # Check for straight
+    is_straight = False
+    # Normal straight
+    if all(values[i] + 1 == values[i+1] for i in range(4)):
+        is_straight = True
+    # Wheel straight (A-2-3-4-5)
+    elif values == [2, 3, 4, 5, 14]:
+        is_straight = True
+        values = [1, 2, 3, 4, 5]  # Treat Ace as 1 for ranking
+        values.sort()
+    # 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)
+    unique_values = sorted(value_counts.keys(), reverse=True)
+    # Determine hand rank
+    if is_straight and is_flush:
+        # Straight flush
+        return (8, values[-1])  # Rank 8, high card of straight
+    elif 4 in counts:
+        # Four of a kind
+        four_kind_value = [v for v, c in value_counts.items() if c == 4][0]
+        kicker = [v for v, c in value_counts.items() if c == 1][0]
+        return (7, four_kind_value, kicker)
+    elif 3 in counts and 2 in counts:
+        # Full house
+        three_kind_value = [v for v, c in value_counts.items() if c == 3][0]
+        pair_value = [v for v, c in value_counts.items() if c == 2][0]
+        return (6, three_kind_value, pair_value)
+    elif is_flush:
+        # Flush
+        return (5,) + tuple(reversed(values))
+    elif is_straight:
+        # Straight
+        return (4, values[-1])
+    elif 3 in counts:
+        # Three of a kind
+        three_kind_value = [v for v, c in value_counts.items() if c == 3][0]
+        kickers = sorted([v for v, c in value_counts.items() if c == 1], reverse=True)
+        return (3, three_kind_value) + tuple(kickers)
+    elif counts.count(2) == 2:
+        # Two pair
+        pairs = sorted([v for v, c in value_counts.items() if c == 2], reverse=True)
+        kicker = [v for v, c in value_counts.items() if c == 1][0]
+        return (2, pairs[0], pairs[1], kicker)
+    elif 2 in counts:
+        # One pair
+        pair_value = [v for v, c in value_counts.items() if c == 2][0]
+        kickers = sorted([v for v, c in value_counts.items() if c == 1], reverse=True)
+        return (1, pair_value) + tuple(kickers)
+    else:
+        # High card
+        return (0,) + tuple(reversed(values))
+# Handled Edge Cases: empty hands list, single hand, empty hand string, invalid number of cards, invalid card format, invalid card values

trust

Pending

Initializing Agent

Running Agent

Initializing Evaluation

Running Evaluation

Passed