Codestin Search App

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
✓ Simulation with List	O(n²)	O(n)	Simulate the elimination game step by step using a list
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 — Algorithm Steps

Create a list containing friends numbered 1 to n
Start with position 0 (friend 1)
Count k-1 positions forward (wrapping around)
Remove the friend at that position
Continue from the same index (which now points to the next friend)
Repeat until only one friend remains

Visualization

Tap to expand

Step-by-Step Walkthrough

Initial Setup

Friends 1,2,3,4,5 sit in circle, start at position 1

First Elimination

Count k=2 positions: 1→2, eliminate friend 2

Continue Process

Start from friend 3, count k=2: 3→4, eliminate friend 4

Final Winner

Continue until only one friend remains

Code -

solution.c — C

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

int findTheWinner(int n, int k) {
    int *friends = malloc(n * sizeof(int));
    for (int i = 0; i < n; i++) {
        friends[i] = i + 1;
    }
    
    int pos = 0;
    int size = n;
    
    while (size > 1) {
        pos = (pos + k - 1) % size;
        // Shift elements left to remove element at pos
        for (int i = pos; i < size - 1; i++) {
            friends[i] = friends[i + 1];
        }
        size--;
        if (pos >= size) {
            pos = 0;
        }
    }
    
    int result = friends[0];
    free(friends);
    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²)

We perform n eliminations, and each elimination involves counting k positions plus list removal which can take O(n) in worst case

⚠ Quadratic Growth

Space Complexity

O(n)

We store all n friends in a list

⚡ 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

Simulation with List — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler