Find The First Player to win K Games in a Row

Find The First Player to win K Games in a Row - Problem

Array Simulation Medium

Imagine a competitive gaming tournament where players are lined up in a queue, each with a unique skill level. The tournament follows a simple but exciting format:

The first two players in the queue compete
The player with the higher skill level wins
The winner stays at the front of the queue
The loser goes to the back of the queue

The ultimate champion is determined by being the first player to win k consecutive games. Your task is to simulate this tournament and find which player (by their original index) will be crowned the champion.

Input: An array skills representing each player's skill level and an integer k representing the number of consecutive wins needed.

Output: The original index of the player who wins k games in a row first.

Note: All skill levels are unique, so there are no ties!

Input & Output

example_1.py — Basic Tournament

$ Input: skills = [4,2,6,3,9], k = 2

› Output: 2

💡 Note: Player 0 (skill 4) beats Player 1 (skill 2). Then Player 2 (skill 6) beats Player 0. Player 2 then beats Player 3 (skill 3), winning 2 games in a row. Player 2 is at index 2.

example_2.py — High K Value

$ Input: skills = [2,5,4], k = 3

› Output: 1

💡 Note: Since k=3 ≥ n-1=2, the player with maximum skill will win. Player 1 has skill 5, which is the highest, so they win.

example_3.py — Single Win Required

$ Input: skills = [1,9,8,2,3], k = 1

› Output: 1

💡 Note: Player 1 (skill 9) beats Player 0 (skill 1) in the first game and immediately wins since k=1.

Constraints

n == skills.length
2 ≤ n ≤ 10⁵
1 ≤ k ≤ 10⁹
1 ≤ skills[i] ≤ 10⁶
All integers in skills are unique

Visualization

Tap to expand

Understanding the Visualization

Setup

Players line up to challenge the current champion

Challenge

Each player challenges the current champion based on skill level

Victory

Winner becomes/remains champion, increment win streak

Champion

First player to win k consecutive games is declared winner

Key Takeaway

🎯 Key Insight: We don't need to simulate the entire queue - just track the current winner and count consecutive wins. The optimization k ≥ n-1 → strongest player wins makes large k values trivial.

Asked in

a Amazon 45 G Google 38 f Meta 25 ⊞ Microsoft 20

The optimal solution uses a single-pass simulation approach with O(n) time complexity. Key insight: track only the current winner and their consecutive wins, with special optimization for k ≥ n-1 where the strongest player always wins. This avoids expensive queue operations while maintaining correctness.

Common Approaches

Approach	Time	Space	Notes
✓ Optimized Simulation (Single Pass)	O(n)	O(1)	Track current leader and win streak without moving the entire queue
Queue Simulation (Brute Force)	O(n + k)	O(n)	Simulate the actual queue by moving players around after each game

Optimized Simulation (Single Pass) — Algorithm Steps

Start with the first player as the initial leader
For each subsequent player, simulate them challenging the current leader
If challenger wins, they become the new leader (reset win count)
If leader wins, increment their consecutive win count
Handle the special case where k >= n-1 (strongest player always wins)

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Start with player 0 as current winner

Challenge

Each player challenges the current winner

Update

Winner keeps title, challenger becomes new winner if they win

Count

Track consecutive wins, return when k is reached

Code -

solution.c — C

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

int findTheWinner(int* skills, int skillsSize, int k) {
    if (k >= skillsSize - 1) {
        int maxIdx = 0;
        for (int i = 1; i < skillsSize; i++) {
            if (skills[i] > skills[maxIdx]) {
                maxIdx = i;
            }
        }
        return maxIdx;
    }
    
    int currentWinner = 0;
    int consecutiveWins = 0;
    
    for (int challenger = 1; challenger < skillsSize; challenger++) {
        if (skills[currentWinner] > skills[challenger]) {
            consecutiveWins++;
        } else {
            currentWinner = challenger;
            consecutiveWins = 1;
        }
        
        if (consecutiveWins == k) {
            return currentWinner;
        }
    }
    
    return currentWinner;
}

int main() {
    printf("Solution implemented\n");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

We process each player at most once. Special case optimization makes k >= n-1 constant time

✓ Linear Growth

Space Complexity

O(1)

Only need to track current leader, their position, and win count

✓ Linear Space

43.7K Views

Medium Frequency

~18 min Avg. Time

1.8K 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

Optimized Simulation (Single Pass) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler