Determine the Winner of a Bowling Game - Practice Coding Problems

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) + 9 = 37. 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

Understanding the Visualization

Input Arrays

Two players with their pin counts per turn

Apply Strike Rules

Double the value if previous 1-2 turns had strikes (10 pins)

Compare Scores

Return 1 if player1 wins, 2 if player2 wins, 0 for tie

Key Takeaway

🎯 Key Insight: A strike (10 pins) doubles the value of the next 1-2 turns, significantly impacting the final score

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

Approach	Time	Space	Notes
✓ Single Pass Calculation	O(n)	O(1)	Calculate both players' scores in a single optimized pass
Direct Simulation	O(n)	O(1)	Calculate each player's score by iterating through turns and applying strike bonuses

Single Pass Calculation — Algorithm Steps

Step 1: Initialize score variables for both players
Step 2: Loop through both arrays simultaneously
Step 3: For each turn, check strike bonuses and calculate scores
Step 4: Compare final scores and return result

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Set score1=0, score2=0

Single Loop

Process both players' turns simultaneously

Compare

Return winner based on final scores

Code -

solution.c — C

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

int solution(int* player1, int n1, int* player2, int n2) {
    int score1 = 0, score2 = 0;
    int n = n1; // Both arrays same length
    
    for (int i = 0; i < n; i++) {
        // Calculate player 1 score
        int pins1 = player1[i];
        int hasBonus1 = 0;
        if (i >= 1 && player1[i-1] == 10) hasBonus1 = 1;
        if (i >= 2 && player1[i-2] == 10) hasBonus1 = 1;
        
        score1 += hasBonus1 ? (2 * pins1) : pins1;
        
        // Calculate player 2 score
        int pins2 = player2[i];
        int hasBonus2 = 0;
        if (i >= 1 && player2[i-1] == 10) hasBonus2 = 1;
        if (i >= 2 && player2[i-2] == 10) hasBonus2 = 1;
        
        score2 += hasBonus2 ? (2 * pins2) : pins2;
    }
    
    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 both arrays of n turns

✓ Linear Growth

Space Complexity

O(1)

Only using score variables, no extra data structures

✓ 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

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Single Pass Calculation — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler