def zuma_game_brute_force(board, hand):
    minimum_balls_needed = float('inf')

    def clear_board(current_board, current_hand, balls_used):
        nonlocal minimum_balls_needed

        # If the board is empty, update the minimum
        if not current_board:
            minimum_balls_needed = min(minimum_balls_needed, balls_used)
            return

        if not current_hand:
            return

        for ball_index, ball_color in enumerate(current_hand):
            for insert_index in range(len(current_board) + 1):
                # Simulate inserting a ball and reacting
                new_board = current_board[:insert_index] + ball_color + current_board[insert_index:]

                new_board = react(new_board)

                remaining_hand = current_hand[:ball_index] + current_hand[ball_index+1:]

                clear_board(new_board, remaining_hand, balls_used + 1)

    def react(board):
        while True:
            reduced = False
            start = 0
            while start < len(board):
                end = start
                while end < len(board) and board[start] == board[end]:
                    end += 1

                if end - start >= 3:
                    board = board[:start] + board[end:]
                    reduced = True
                    break
                start = end
            if not reduced:
                break
        return board

    clear_board(board, hand, 0)

    # Impossible to clear the board
    if minimum_balls_needed == float('inf'):
        return -1
    return minimum_balls_needed

def zuma_game(board_string, hand_string):
    # This function simulates inserting the hand ball at index. 
    def insert_and_eliminate(current_board, index, hand_ball):
        new_board = list(current_board)
        new_board.insert(index, hand_ball)
        new_board = "".join(new_board)

        while True:
            original_length = len(new_board)
            new_board = remove_adjacent(new_board)
            if len(new_board) == original_length:
                break
        return new_board

    def remove_adjacent(board):
        i = 0
        while i < len(board):
            j = i
            while j < len(board) and board[i] == board[j]:
                j += 1
            if j - i >= 3:
                board = board[:i] + board[j:]
                i = 0 # restart search from the beginning
                continue
            else:
                i += 1
        return board

    shortest_board = float('inf')
    best_move = -1

    for i in range(len(board_string) + 1):
        # Trying all possible insertion points for the ball.
        resulting_board = insert_and_eliminate(board_string, i, hand_string)
        board_length = len(resulting_board)

        if board_length < shortest_board:
            shortest_board = board_length
            best_move = i

    if shortest_board == float('inf'):
        return -1

    resulting_board = insert_and_eliminate(board_string, best_move, hand_string)

    if len(resulting_board) == 0:
      return 0
    else:
      return len(resulting_board)