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

Array Simulation Medium

A competition consists of n players numbered from 0 to n - 1. You are given an integer array skills of size n and a positive integer k, where skills[i] is the skill level of player i. All integers in skills are unique.

All players are standing in a queue in order from player 0 to player n - 1. The competition process is as follows:

The first two players in the queue play a game, and the player with the higher skill level wins.
After the game, the winner stays at the beginning of the queue, and the loser goes to the end of it.
The winner of the competition is the first player who wins k games in a row.

Return the initial index of the winning player.

Input & Output

Example 1 — Basic Competition

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

› Output: 4

💡 Note: Player 4 has the highest skill (9). After several games, player 4 reaches the front and wins 3 consecutive games, so return index 4.

Example 2 — Early Winner

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

› Output: 0

💡 Note: Since k=1, we only need one win. Player 0 (skill=2) beats player 1 (skill=1) in the first game, so return index 0.

Example 3 — Small k Value

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

› Output: 1

💡 Note: Player 1 (skill=9) beats player 0, then beats player 2. Two consecutive wins with k=2, so return index 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

Asked in

G Google 25 a Amazon 18 M Microsoft 15 f Meta 12

The key insight is that once the player with maximum skill reaches the front of the queue, they will win all subsequent games. The optimal approach simulates the competition while tracking consecutive wins, with an early exit optimization when the strongest player takes the lead. Time: O(n + k), Space: O(n)

Common Approaches

✓ Direct Simulation

⏱️ Time: O(n * k) Space: O(n)

Directly simulate the competition process by maintaining the actual queue of players. For each game, compare the first two players, move the winner to front and loser to back, and count consecutive wins.

Optimized Simulation

⏱️ Time: O(n + k) Space: O(n)

Instead of simulating every single game, realize that once the player with maximum skill reaches the front of the queue, they will win all subsequent games. We only need to simulate until this happens or until someone gets k wins.

Direct Simulation — Algorithm Steps

Initialize queue with all players in order
Simulate each game: compare first two players
Track consecutive wins for current leader
Return when someone reaches k wins

Visualization

Tap to expand

Step-by-Step Walkthrough

Initial Queue

Players lined up by index: [0,1,2,3,4]

Game Simulation

First two players compete, winner stays front, loser goes back

Track Wins

Count consecutive wins until k is reached

Code -

solution.c — C

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

int solution(int* skills, int n, int k) {
    int* queue = (int*)malloc(n * sizeof(int));
    int front = 0, rear = n - 1;
    
    // Initialize queue with player indices
    for (int i = 0; i < n; i++) {
        queue[i] = i;
    }
    
    int consecutiveWins = 0;
    int currentWinner = -1;
    
    while (consecutiveWins < k) {
        int player1 = queue[front];
        front = (front + 1) % n;
        int player2 = queue[front];
        front = (front + 1) % n;
        
        int winner, loser;
        if (skills[player1] > skills[player2]) {
            winner = player1;
            loser = player2;
        } else {
            winner = player2;
            loser = player1;
        }
        
        // Winner goes to front, loser to back
        front = (front - 1 + n) % n;
        queue[front] = winner;
        rear = (rear + 1) % n;
        queue[rear] = loser;
        
        if (winner == currentWinner) {
            consecutiveWins++;
        } else {
            currentWinner = winner;
            consecutiveWins = 1;
        }
    }
    
    free(queue);
    return currentWinner;
}

void parseArray(const char* str, int* arr, int* size) {
    *size = 0;
    const char* p = str;
    while (*p && *p != '[') p++;
    if (*p == '[') p++;
    while (*p && *p != ']') {
        while (*p == ' ' || *p == ',') p++;
        if (*p == ']' || *p == '\0') break;
        arr[(*size)++] = (int)strtol(p, (char**)&p, 10);
    }
}

int main() {
    char line[10000];
    int skills[1000];
    int n = 0;
    
    // Parse skills array
    fgets(line, sizeof(line), stdin);
    char* token = strtok(line, "[,]");
    while (token != NULL) {
        char* end;
        long val = strtol(token, &end, 10);
        if (end != token) { // Valid number
            skills[n++] = (int)val;
        }
        token = strtok(NULL, "[,]");
    }
    
    // Parse k
    int k;
    scanf("%d", &k);
    
    printf("%d\n", solution(skills, n, k));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n * k)

In worst case, need k wins and each win processes through n players

✓ Linear Growth

Space Complexity

O(n)

Queue to store all n players

⚡ Linearithmic Space

28.5K Views

Medium Frequency

~25 min Avg. Time

890 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

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

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Direct Simulation — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler