Determine the Winner of a Bowling Game - Problem

Array Simulation Easy

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.

Input & Output

Example 1 — Basic Strike Bonus

$ Input: player1 = [4,10,7,9], player2 = [3,5,7,6]

› Output: 1

💡 Note: Player1: 4 + 10 + 14 (7*2 due to strike) + 18 (9*2 due to strike) = 46. Player2: 3 + 5 + 7 + 6 = 21. Player1 wins, return 1.

Example 2 — Tie Game

$ Input: player1 = [3,5,7,6], player2 = [8,10,10,2]

› Output: 2

💡 Note: Player1: 3 + 5 + 7 + 6 = 21. Player2: 8 + 10 + 20 (10*2 due to strike) + 4 (2*2 due to strike) = 42. Player2 wins, return 2.

Example 3 — Multiple Strikes

$ Input: player1 = [2,3], player2 = [4,1]

› Output: 0

💡 Note: Player1: 2 + 3 = 5. Player2: 4 + 1 = 5. It's a tie, return 0.

Constraints

1 ≤ player1.length, player2.length ≤ 1000
0 ≤ player1[i], player2[i] ≤ 10

Visualization

Tap to expand

Asked in

a Amazon 15 M Microsoft 8

The key insight is recognizing that a strike (10 pins) gives a bonus to the next 1-2 turns by doubling their value. Best approach is direct simulation in O(n) time by checking each turn for strike bonuses. Time: O(n), Space: O(1)

Common Approaches

✓ Direct Simulation

⏱️ Time: O(n) Space: O(1)

For each turn, check if the player had a strike in the previous 1 or 2 turns. If so, double the current turn's value. Sum all turn values to get the final score.

Single Pass Calculation

⏱️ Time: O(n) Space: O(1)

Instead of separate helper functions, calculate both players' scores simultaneously in one loop, reducing function call overhead and improving cache efficiency.

Direct Simulation — Algorithm Steps

Step 1: For each player, iterate through all turns
Step 2: For each turn, check if previous 1 or 2 turns had strikes (10 pins)
Step 3: If strike bonus applies, multiply current pins by 2, otherwise use original value
Step 4: Sum all turn values to get player's total score
Step 5: Compare scores and return winner (1, 2, or 0 for tie)

Visualization

Tap to expand

Step-by-Step Walkthrough

Check Previous Turns

For each turn, check if previous 1-2 turns had strikes

Apply Bonus

If strike bonus applies, double the current turn value

Sum and Compare

Sum all turn values and compare final scores

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int calculateScore(int* player, int n) {
    int score = 0;
    for (int i = 0; i < n; i++) {
        int pins = player[i];
        int hasBonus = 0;
        if (i >= 1 && player[i-1] == 10) {
            hasBonus = 1;
        }
        if (i >= 2 && player[i-2] == 10) {
            hasBonus = 1;
        }
        
        if (hasBonus) {
            score += 2 * pins;
        } else {
            score += pins;
        }
    }
    return score;
}

int solution(int* player1, int n1, int* player2, int n2) {
    int score1 = calculateScore(player1, n1);
    int score2 = calculateScore(player2, n2);
    
    if (score1 > score2) {
        return 1;
    } else if (score2 > score1) {
        return 2;
    } else {
        return 0;
    }
}

int main() {
    char line[1000];
    int player1[100], player2[100];
    int n1 = 0, n2 = 0;
    
    // Read first array
    fgets(line, sizeof(line), stdin);
    char* token = strtok(line, "[,]");
    while (token != NULL) {
        if (token[0] >= '0' && token[0] <= '9') {
            player1[n1++] = atoi(token);
        }
        token = strtok(NULL, "[,]");
    }
    
    // Read second array
    fgets(line, sizeof(line), stdin);
    token = strtok(line, "[,]");
    while (token != NULL) {
        if (token[0] >= '0' && token[0] <= '9') {
            player2[n2++] = atoi(token);
        }
        token = strtok(NULL, "[,]");
    }
    
    int result = solution(player1, n1, player2, n2);
    printf("%d\n", result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through each array of n turns

✓ Linear Growth

Space Complexity

O(1)

Only using variables to track scores

✓ Linear Space

12.4K Views

Medium Frequency

~15 min Avg. Time

342 Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Determine the Winner of a Bowling Game - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Direct Simulation — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler