Find the Winner of an Array Game - Practice Coding Problems

Find the Winner of an Array Game - Problem

Array Simulation Medium

Imagine a competitive tournament where players face off in head-to-head battles! You're given an integer array arr of distinct integers and an integer k.

The game works like this:

🥊 The first two elements arr[0] and arr[1] compete
🏆 The larger number wins and stays at position 0
📤 The smaller number moves to the end of the array
🔄 This continues until one number wins k consecutive rounds

Your goal: Return the integer that will ultimately win the game.

Example: With arr = [2,1,3,5,4,6,7] and k = 2, the number 5 will win because it can defeat 2 consecutive opponents.

Input & Output

example_1.py — Basic Game

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

› Output: 5

💡 Note: Game progression: [2,1,3,5,4,6,7] → 2 beats 1 → [2,3,5,4,6,7,1] → 3 beats 2 → [3,5,4,6,7,1,2] → 5 beats 3 → [5,4,6,7,1,2,3] → 5 beats 4 → 5 has won 2 consecutive rounds!

example_2.py — Large k Value

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

› Output: 3

💡 Note: Since k=10 is larger than the array length, the maximum element (3) will definitely win. No matter how the game progresses, 3 will eventually reach the front and win forever.

example_3.py — Immediate Winner

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

› Output: 9

💡 Note: Game: [1,9,8,2,3] → 9 beats 1 → [9,8,2,3,1] → 9 beats 8 → [9,2,3,1,8] → 9 beats 2 → 9 has won 3 consecutive rounds and is the winner!

Constraints

2 ≤ arr.length ≤ 10⁵
1 ≤ arr[i] ≤ 10⁶
All integers in arr are distinct
1 ≤ k ≤ 10⁹
It is guaranteed that there will be a winner

Visualization

Tap to expand

Understanding the Visualization

Setup

Line up all contestants with first two ready to compete

Battle

Current champion faces the next challenger

Victory

Winner stays as champion, loser goes to back of line

Count Wins

Track consecutive wins for current champion

Champion

Someone wins k battles in a row or maximum element takes over

Key Takeaway

🎯 Key Insight: The maximum element is the ultimate winner! We only need to check if anyone can achieve k consecutive wins before the max element reaches the front.

Asked in

G Google 42 f Facebook 35 a Amazon 28 ⊞ Microsoft 19

The key insight is that the maximum element will eventually reach the front and win forever. We only need to check if any element can win k consecutive battles before the maximum element gets there. This leads to an O(n) time, O(1) space solution that's much more efficient than simulating the entire game.

Common Approaches

Approach	Time	Space	Notes
✓ Optimized Single Pass (Optimal)	O(n)	O(1)	Key insight: max element always wins, so check if anyone wins k battles before max reaches front
Brute Force Simulation	O(n*k)	O(n)	Simulate the entire game by moving elements and tracking consecutive wins

Optimized Single Pass (Optimal) — Algorithm Steps

Find the maximum element in the array
If k >= array length, return the maximum (it will definitely win)
Simulate only until the maximum element reaches position 0
Track consecutive wins of the current leader
If someone wins k battles before max arrives, return them; else return max

Visualization

Tap to expand

Step-by-Step Walkthrough

Find Maximum

Identify the ultimate winner (maximum element)

Track Current Leader

Process elements left to right, tracking current champion

Count Consecutive Wins

Increment wins when leader beats challenger, reset when leader changes

Early Termination

Return immediately if k consecutive wins achieved before max element

Code -

solution.c — C

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

int findMax(int* arr, int size) {
    int maxVal = arr[0];
    for (int i = 1; i < size; i++) {
        if (arr[i] > maxVal) {
            maxVal = arr[i];
        }
    }
    return maxVal;
}

int findTheWinner(int* arr, int arrSize, int k) {
    int maxVal = findMax(arr, arrSize);
    
    // If k is large enough, max element will definitely win
    if (k >= arrSize) {
        return maxVal;
    }
    
    int current = arr[0];
    int wins = 0;
    
    for (int i = 1; i < arrSize; i++) {
        if (arr[i] > current) {
            current = arr[i];
            wins = 1;
        } else {
            wins++;
        }
        
        // If current leader wins k consecutive battles
        if (wins == k) {
            return current;
        }
    }
    
    // If we reach here, max element has reached front
    return maxVal;
}

int main() {
    // Parse input and call solution
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

We process at most n elements once, since we stop when max element reaches front

✓ Linear Growth

Space Complexity

O(1)

Only using a few variables to track current state, no extra arrays needed

✓ Linear Space

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

Optimized Single Pass (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler