Determine the Winner of a Bowling Game - Practice Coding Problems

Determine the Winner of a Bowling Game - Problem

Array Simulation Easy

Bowling Championship Simulator

Welcome to the digital bowling alley! 🎳 You're tasked with determining the winner of a special bowling game between two players.

In this unique bowling variant:
• Each game consists of n turns
• Each turn has exactly 10 pins available
• Players can hit anywhere from 0 to 10 pins per turn

The Scoring Twist: If a player hits 10 pins (a strike) in either the previous turn (i-1) or two turns ago (i-2), their current turn's score gets doubled!

Your Mission: Calculate both players' total scores and determine:
• Return 1 if Player 1 wins
• Return 2 if Player 2 wins
• Return 0 if it's a tie

Can you build the perfect scoring system? 🏆

Input & Output

example_1.py — Basic Strike Bonus

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

› Output: 1

💡 Note: Player 1 scores: 4 + 10 + (7×2) + (9×2) = 46. Player 2 scores: 6 + 5 + 10 + (4×2) = 29. Player 1 wins!

example_2.py — Equal Scores

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

› Output: 2

💡 Note: Player 1 scores: 3 + 5 + 7 + 6 = 21. Player 2 scores: 8 + 10 + 10 + (2×2) = 32. Player 2 wins!

example_3.py — Two Turns Back Strike

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

› Output: 0

💡 Note: Player 1 scores: 2 + 3 = 5. Player 2 scores: 4 + 1 = 5. It's a tie!

Visualization

Tap to expand

Understanding the Visualization

Track Each Turn

Process each player's turns sequentially

Check Strike History

Look back 1-2 turns for strikes (10 pins)

Apply Bonus

Double current score if recent strikes found

Determine Winner

Compare final totals

Key Takeaway

🎯 Key Insight: Track the last two turns to efficiently apply strike bonuses in O(n) time - no complex data structures needed!

Time & Space Complexity

Time Complexity

⏱️

O(n)

We iterate through each turn once, checking previous turns takes constant time

✓ Linear Growth

Space Complexity

O(1)

Only using variables to track scores, no additional data structures

✓ Linear Space

Constraints

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

Asked in

a Amazon 15 G Google 12 ⊞ Microsoft 8 f Meta 6

This problem is solved with a single pass simulation approach. For each turn, we check if the previous 1-2 turns had strikes (10 pins) and apply the doubling bonus accordingly. The key insight is that we only need to look back at most 2 positions to determine bonuses, making this an O(n) time and O(1) space solution.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Check Previous Turns)	O(n)	O(1)	For each turn, check if previous 1-2 turns had strikes

Brute Force (Check Previous Turns) — Algorithm Steps

For each player, iterate through all their turns
For each turn i, check if turn i-1 had 10 pins
Also check if turn i-2 had 10 pins (if it exists)
If either condition is true, double the current score
Sum up all turn scores for both players
Compare totals and return the winner

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Start with both players' turn arrays

Check Previous

For each turn, look back 1-2 positions for strikes

Apply Bonus

Double the score if previous strikes found

Compare

Sum totals and determine winner

Code -

solution.c — C

#include <stdio.h>
#include <stdbool.h>

int calculateScore(int* player, int n) {
    int total = 0;
    
    for (int i = 0; i < n; i++) {
        int currentScore = player[i];
        
        // Check if previous turn (i-1) or turn before that (i-2) had strike
        bool hasBonus = false;
        if (i >= 1 && player[i-1] == 10) {
            hasBonus = true;
        }
        if (i >= 2 && player[i-2] == 10) {
            hasBonus = true;
        }
        
        if (hasBonus) {
            total += 2 * currentScore;
        } else {
            total += currentScore;
        }
    }
    
    return total;
}

int isWinner(int* player1, int player1Size, int* player2, int player2Size) {
    int score1 = calculateScore(player1, player1Size);
    int score2 = calculateScore(player2, player2Size);
    
    if (score1 > score2) {
        return 1;
    } else if (score2 > score1) {
        return 2;
    } else {
        return 0;
    }
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

We iterate through each turn once, checking previous turns takes constant time

✓ Linear Growth

Space Complexity

O(1)

Only using variables to track scores, no additional data structures

✓ Linear Space

Constraints

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

24.4K Views

Medium Frequency

~12 min Avg. Time

847 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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Brute Force (Check Previous Turns) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler