Find the Winner of an Array Game

Find the Winner of an Array Game - Problem

Array Simulation Medium

Given an integer array arr of distinct integers and an integer k.

A game will be played between the first two elements of the array (i.e. arr[0] and arr[1]). In each round of the game, we compare arr[0] with arr[1], the larger integer wins and remains at position 0, and the smaller integer moves to the end of the array. The game ends when an integer wins k consecutive rounds.

Return the integer which will win the game.

It is guaranteed that there will be a winner of the game.

Input & Output

Example 1 — Basic Case

$ Input: arr = [2,1,3,5,4,6,7], k = 2

› Output: 5

💡 Note: Initially 2 is champion. 2 beats 1 (wins=1), then loses to 3. 3 becomes champion, loses to 5. 5 becomes champion, beats 4 (wins=1), beats 6 (wins=2). Since 5 gets k=2 consecutive wins, return 5.

Example 2 — Small k

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

› Output: 3

💡 Note: 3 starts as champion and immediately beats 2, achieving k=1 consecutive wins. Return 3.

Example 3 — Large k

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

› Output: 9

💡 Note: Since k=5 >= n-1=4, the maximum element 9 will eventually become champion and stay there forever. Return 9.

Constraints

2 ≤ arr.length ≤ 10⁵
1 ≤ k ≤ 10⁹
arr[i] is a distinct integer.
1 ≤ arr[i] ≤ 10⁶
It's guaranteed that there will be a winner of the game.

Visualization

Tap to expand

Asked in

G Google 15 a Amazon 12 M Microsoft 8 A Apple 6

The key insight is that when k is large (>= n-1), the maximum element will eventually become champion and stay there forever. For smaller k values, we simulate the game efficiently by tracking the current champion and counting consecutive wins. Best approach uses mathematical optimization with O(n) time and O(1) space.

Common Approaches

✓ Brute Force Simulation

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

Actually simulate the game by comparing first two elements, moving the loser to the end, and counting consecutive wins until we reach k wins.

Mathematical Insight

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

Key insight: if k is large enough (>= n-1), the maximum element will eventually become champion and stay there forever. Otherwise, simulate the optimized way.

Optimized Simulation

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

Instead of physically moving elements, track the current champion and iterate through the array to find challengers. Count consecutive wins more efficiently.

Brute Force Simulation — Algorithm Steps

Step 1: Compare arr[0] and arr[1]
Step 2: Move loser to end of array
Step 3: Count consecutive wins
Step 4: Repeat until k consecutive wins

Visualization

Tap to expand

Step-by-Step Walkthrough

Initial Setup

Array with first two elements competing

Winner Stays

Larger element stays at front, smaller moves to end

Count Wins

Track consecutive wins until reaching k

Code -

solution.c — C

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

int solution(int* arr, int n, int k) {
    int currentWinner = arr[0];
    int wins = 0;
    int i = 0;
    int rounds = 0;
    
    while (wins < k) {
        int nextChallenger = arr[(i + 1) % n];
        
        if (currentWinner > nextChallenger) {
            wins++;
        } else {
            currentWinner = nextChallenger;
            wins = 1;
        }
        
        i = (i + 1) % n;
        rounds++;
        
        // If we've processed all elements and no one got k wins,
        // the current winner is the max and will keep winning
        if (rounds >= n - 1 && wins < k) {
            break;
        }
    }
    
    return currentWinner;
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    // Parse array
    int arr[1000];
    int n = 0;
    char* token = strtok(line + 1, ",]");
    while (token != NULL) {
        arr[n++] = atoi(token);
        token = strtok(NULL, ",]");
    }
    
    int k;
    scanf("%d", &k);
    
    int result = solution(arr, n, k);
    printf("%d\n", result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n × k)

Each round takes O(n) time to move elements, and we may need up to k rounds

✓ Linear Growth

Space Complexity

O(1)

Only using constant extra variables for counting

✓ Linear Space

28.5K Views

Medium Frequency

~15 min Avg. Time

892 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

Brute Force Simulation — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler