Find the Winner of the Circular Game - Practice Coding Problems

Find the Winner of the Circular Game - Problem

Array Math Recursion Queue Simulation Medium

Imagine n friends sitting in a circle playing an elimination game - this is the famous Josephus Problem! 🎯

The friends are numbered 1 to n clockwise. Starting from friend 1, you count k friends clockwise (including your starting position). The k-th friend gets eliminated and leaves the circle.

Then, you start counting again from the next friend clockwise and repeat the process. This continues until only one winner remains.

Goal: Given n friends and step size k, determine which friend wins the game.

Example: With 5 friends and k=2, starting from friend 1, count 2 positions → eliminate friend 2, then start from friend 3, count 2 → eliminate friend 4, and so on.

Input & Output

example_1.py — Python

$ Input: n = 5, k = 2

› Output: 3

💡 Note: Friends are numbered 1,2,3,4,5. Start at 1, count 2 positions (1→2), eliminate 2. Start at 3, count 2 (3→4), eliminate 4. Start at 5, count 2 (5→1), eliminate 1. Start at 3, count 2 (3→5), eliminate 5. Friend 3 wins!

example_2.py — Python

$ Input: n = 6, k = 5

› Output: 1

💡 Note: With 6 friends and k=5, we eliminate every 5th person. Starting from friend 1, count 5 positions to eliminate friend 5, then continue the process. After all eliminations, friend 1 is the winner.

example_3.py — Python

$ Input: n = 1, k = 1

› Output: 1

💡 Note: Edge case: Only one friend in the circle, so friend 1 is automatically the winner.

Constraints

1 ≤ n ≤ 500
1 ≤ k ≤ n
n represents the number of friends in the circle
k represents the step size for counting

Visualization

Tap to expand

Understanding the Visualization

Initial Circle

All n friends sit in a circle, numbered 1 to n clockwise

Start Counting

Begin at friend 1, count k positions clockwise

Eliminate Friend

The k-th friend leaves the circle

Continue Process

Start from next friend and repeat until one remains

Mathematical Pattern

The Josephus formula captures this pattern: J(n,k) = (J(n-1,k) + k) % n

Key Takeaway

🎯 Key Insight: The Josephus problem has an elegant mathematical solution that avoids simulation entirely. The recurrence relation J(n,k) = (J(n-1,k) + k) % n captures the pattern of how the winner's position changes as we add more people to the circle.

Asked in

f Facebook 45 a Amazon 38 ⊞ Microsoft 32 G Google 28

This is the famous Josephus Problem! While simulation approaches work, the optimal solution uses the mathematical recurrence relation: J(n,k) = (J(n-1,k) + k) % n with base case J(1,k) = 0. This gives us O(n) time and O(1) space complexity. The key insight is that the winner's position in a smaller circle can predict the winner's position in a larger circle through mathematical transformation.

Common Approaches

Approach	Time	Space	Notes
✓ Queue-based Simulation	O(n×k)	O(n)	Use queue to efficiently simulate the circular elimination
Mathematical Formula (Josephus Problem)	O(n)	O(1)	Use the mathematical Josephus formula for O(n) solution
Simulation with List	O(n²)	O(n)	Simulate the elimination game step by step using a list

Queue-based Simulation — Algorithm Steps

Create a queue with friends numbered 1 to n
For each elimination round:
Rotate k-1 friends from front to back
Remove the friend now at the front (this is the k-th friend)
Repeat until only one friend remains in queue

Visualization

Tap to expand

Step-by-Step Walkthrough

Initial Queue

Queue: [1,2,3,4,5], k=3

First Rotation

Rotate k-1=2 times: [3,4,5,1,2], eliminate front (3)

Continue Process

Queue: [4,5,1,2], rotate 2 times: [1,2,4,5], eliminate 1

Final Steps

Continue until one winner remains

Code -

solution.c — C

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

typedef struct {
    int *data;
    int front, rear, size, capacity;
} Queue;

Queue* createQueue(int capacity) {
    Queue *q = malloc(sizeof(Queue));
    q->data = malloc(capacity * sizeof(int));
    q->front = 0;
    q->rear = -1;
    q->size = 0;
    q->capacity = capacity;
    return q;
}

void enqueue(Queue *q, int val) {
    q->rear = (q->rear + 1) % q->capacity;
    q->data[q->rear] = val;
    q->size++;
}

int dequeue(Queue *q) {
    int val = q->data[q->front];
    q->front = (q->front + 1) % q->capacity;
    q->size--;
    return val;
}

int findTheWinner(int n, int k) {
    Queue *q = createQueue(n);
    for (int i = 1; i <= n; i++) {
        enqueue(q, i);
    }
    
    while (q->size > 1) {
        // Rotate k-1 positions
        for (int i = 0; i < k - 1; i++) {
            enqueue(q, dequeue(q));
        }
        // Remove the k-th friend
        dequeue(q);
    }
    
    int result = q->data[q->front];
    free(q->data);
    free(q);
    return result;
}

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

Time & Space Complexity

Time Complexity

⏱️

O(n×k)

We perform n eliminations, each requiring k rotations of the queue

✓ Linear Growth

Space Complexity

O(n)

We store all n friends in the queue

⚡ Linearithmic Space

48.3K Views

Medium Frequency

~15 min Avg. Time

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

Queue-based Simulation — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler