Five dice

# Given an array of five dice with values 1-6, return the best possible hand.

# Here are the hands ranked lowest to highest:
# HandDescription
#"no pair"No pair or better
#"pair"Two dice with the same value
#"two pair"Two different pairs
#"three of a kind"Three dice with the same value
#"small straight"Four consecutive values
#"large straight"Five consecutive values
#"full house"Three of a kind and a pair
#"four of a kind"Four dice with the same value
#"five of a kind"All five dice with the same value

def five_dice(dice):
    # 1. Sort array
    # 2. Create a dictionary to store counting of numbers
    # 3. Iterate the dice array with two pointers 
    # moving the pointer at the left whenever the straight is interrupted 
    # we need to store the max straight counter and the current straight counter
    # when the straight is interrupted, we need to move the left pointer to the right counter
    # and moving the right pointer to the next position from it's current position.
    # 4. we need to update the dictionary with the counter of numbers after we move the right pointer 
    # 5. We must check if there is no straight counter greater than 2 to return small or large straight. 
    # if the straight counter is not equals to 5, then return small straight. 
    # Otherwise, return small straight.
    # 6. If the dictionary has a single element, return five of a kind
    # 7. If the dictionary has two elements, run the following checks:
    # 7.a. If any key of the dictionary has four as value, return four of a kind
    # 7.b. Otherwise, return full house
    # 8. If the dictionary has four elements, return pair
    # 9. If the dictionary has three elements, we need to run the following checks:
    # 9.a. If one of the keys of the dictionary has three as value, return three of a kind
    # 9.b. Otherwise, return two pair
    # 10. return no pair as default return

    dice.sort()

    left_pointer = 0
    right_pointer = 1
    current_straight = max_straight = 0
    dice_length = len(dice)
    large_straight_length = 5
    minimum_straight_length = 3
    numbers_counting = { dice[0]: 1 }

    while right_pointer < dice_length:
        left_number = dice[left_pointer]
        right_number = dice[right_pointer]
        counting_duplicates = numbers_counting.setdefault(right_number, 0)
        counting_duplicates += 1
        numbers_counting[right_number] = counting_duplicates

        if left_number + 1 == right_number:
            current_straight += 1
            
        else:
            if current_straight > max_straight:
                max_straight = current_straight
            current_straight = 0
            
        left_pointer =+ 1
        right_pointer += 1
        
    print(f"max_straight is {max_straight} with dice {dice}")

    if max_straight >= minimum_straight_length:
        if max_straight == large_straight_length:
            return "large straight"
        else:
            return "small straight"
    else:
        if len(numbers_counting) == 1:
            return "five of a kind"
        if len(numbers_counting) == 2:
            if next((True for value in numbers_counting.values() if value == 4), False):
                return "four of a kind"
            else:
                return "full house"
        if len(numbers_counting) == 4:
            return "pair"
        
        if len(numbers_counting) == 3:
            if next((True for value in numbers_counting.values() if value == 3), False):
                return "three of a kind"
            else:
                return "two pair"

    return "no pair"
    
result = five_dice([1, 1, 1, 1, 1]) 
print(f"Is result {result} five of a kind?")

result = five_dice([5, 5, 5, 6, 5])
print(f"Is result {result} four of a kind?")

result = five_dice([1, 3, 4, 6, 2])
print(f"Is result {result} small straight?")