Find the Winner of the Circular Game - Problem

Array Math Recursion Queue Simulation Medium

There are n friends sitting in a circle, numbered from 1 to n in clockwise order. The game follows these rules:

Start at friend 1
Count k friends clockwise (including the current friend)
The k-th friend is eliminated and leaves the circle
Continue from the next friend clockwise until only one remains

Given n friends and counting number k, return the position of the winner (the last remaining friend).

Input & Output

Example 1 — Basic Case

$ Input: n = 5, k = 2

› Output: 3

💡 Note: Start at friend 1, count 2 friends clockwise (1→2), eliminate friend 2. Continue from friend 3, count 2 (3→4), eliminate friend 4. Process continues until friend 3 remains as winner.

Example 2 — Single Friend

$ Input: n = 1, k = 1

› Output: 1

💡 Note: Only one friend in the circle, so friend 1 automatically wins the game.

Example 3 — Large Step Size

$ Input: n = 6, k = 5

› Output: 1

💡 Note: With 6 friends and k=5, we count 5 positions each time. The elimination pattern results in friend 1 being the last remaining.

Constraints

1 ≤ n ≤ 500
1 ≤ k ≤ n

Visualization

Tap to expand

Asked in

G Google 15 M Microsoft 12 a Amazon 10 f Facebook 8

The key insight is recognizing this as the classic Josephus problem. While simulation works, the optimal approach uses the mathematical Josephus formula: J(n,k) = (J(n-1,k) + k) % n. Best approach achieves Time: O(n), Space: O(1).

Common Approaches

✓ Josephus Formula

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

The Josephus problem has a well-known recursive formula: J(n,k) = (J(n-1,k) + k) % n, with base case J(1,k) = 0. Since the formula uses 0-based indexing, we add 1 to get 1-based result.

Queue-Based Simulation

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

Instead of removing from middle of array, use a queue where we can easily add/remove from ends. Rotate the queue to simulate circular counting.

Simulation with Array

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

Create an array of all friends, repeatedly count k positions and remove friends until only one remains. Handle circular counting by using modulo arithmetic.

Josephus Formula — Algorithm Steps

Use Josephus recurrence relation
J(n,k) = (J(n-1,k) + k) % n
Base case: J(1,k) = 0
Convert from 0-based to 1-based indexing

Visualization

Tap to expand

Step-by-Step Walkthrough

Base Case

J(1,k) = 0 (0-indexed)

Recurrence

J(i,k) = (J(i-1,k) + k) % i

Final Result

Add 1 to convert to 1-indexed

Code -

solution.c — C

#include <stdio.h>

int solution(int n, int k) {
    int result = 0; // J(1, k) = 0 (0-based)
    for (int i = 2; i <= n; i++) {
        result = (result + k) % i;
    }
    return result + 1; // Convert to 1-based indexing
}

int main() {
    int n, k;
    scanf("%d", &n);
    scanf("%d", &k);
    printf("%d\n", solution(n, k));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single loop from 1 to n applying the Josephus formula

✓ Linear Growth

Space Complexity

O(1)

Only using a constant amount of extra variables

✓ Linear Space

28.5K Views

Medium Frequency

~15 min Avg. Time

889 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 Winner of the Circular Game - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Josephus Formula — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler