# Solving Leetcode Interviews in Seconds with AI: Determine the Winner of a Bowling Game


	# Introduction
	In this blog post, we will explore how to solve the LeetCode problem "2660" using AI. LeetCode is a popular platform for preparing for coding interviews, and with the help of AI tools like [Chatmagic](https://www.chatmagic.app), we can generate solutions quickly and efficiently - helping you pass the interviews and get the job offer without having to study for months.

	# Problem Statement
	> You are given two 0-indexed integer arrays player1 and player2, representing the number of pins that player 1 and player 2 hit in a bowling game, respectively. The bowling game consists of n turns, and the number of pins in each turn is exactly 10. Assume a player hits xi pins in the ith turn. The value of the ith turn for the player is:  2xi if the player hits 10 pins in either (i - 1)th or (i - 2)th turn. Otherwise, it is xi.  The score of the player is the sum of the values of their n turns. Return  1 if the score of player 1 is more than the score of player 2, 2 if the score of player 2 is more than the score of player 1, and 0 in case of a draw.    Example 1:  Input: player1 = [5,10,3,2], player2 = [6,5,7,3] Output: 1 Explanation: The score of player 1 is 5 + 10 + 2*3 + 2*2 = 25. The score of player 2 is 6 + 5 + 7 + 3 = 21.  Example 2:  Input: player1 = [3,5,7,6], player2 = [8,10,10,2] Output: 2 Explanation: The score of player 1 is 3 + 5 + 7 + 6 = 21. The score of player 2 is 8 + 10 + 2*10 + 2*2 = 42.  Example 3:  Input: player1 = [2,3], player2 = [4,1] Output: 0 Explanation: The score of player1 is 2 + 3 = 5. The score of player2 is 4 + 1 = 5.  Example 4:  Input: player1 = [1,1,1,10,10,10,10], player2 = [10,10,10,10,1,1,1] Output: 2 Explanation: The score of player1 is 1 + 1 + 1 + 10 + 2*10 + 2*10 + 2*10 = 73. The score of player2 is 10 + 2*10 + 2*10 + 2*10 + 2*1 + 2*1 + 1 = 75.    Constraints:  n == player1.length == player2.length 1 <= n <= 1000 0 <= player1[i], player2[i] <= 10  

	# Explanation
	Here's the breakdown of the solution:

*   **Calculate Player Scores:** Iterate through each player's array, calculating their score based on the given rules (doubling the score if the previous one or two turns were strikes).
*   **Compare Scores:** After calculating the scores for both players, compare them and return 1 if player 1's score is higher, 2 if player 2's score is higher, and 0 if they are equal.
*   **Optimize Calculations:** Improve efficiency by performing the doubling calculation directly within the score accumulation loop.

*   **Runtime Complexity:** O(n), where n is the length of the input arrays. **Storage Complexity:** O(1).

	
	# Code
	```python
	def is_strike(score):
    return score == 10

def bowling_game(player1, player2):
    """
    Calculates the scores of two players in a bowling game and determines the winner.

    Args:
        player1 (list[int]): An array representing the number of pins hit by player 1 in each turn.
        player2 (list[int]): An array representing the number of pins hit by player 2 in each turn.

    Returns:
        int: 1 if player 1 wins, 2 if player 2 wins, and 0 if it's a draw.
    """

    def calculate_score(player):
        score = 0
        n = len(player)
        for i in range(n):
            multiplier = 1
            if i > 0 and is_strike(player[i - 1]):
                multiplier = 2
            if i > 1 and is_strike(player[i - 2]):
                multiplier = 2
            score += player[i] * multiplier
        return score

    score1 = calculate_score(player1)
    score2 = calculate_score(player2)

    if score1 > score2:
        return 1
    elif score2 > score1:
        return 2
    else:
        return 0
	```