What is the pricing and subscription model for Hi👋SpeedAlgo?

The entire core curriculum of 13 patterns and 225 practice problems is 100% free to access with no credit card required. New accounts get 40 free coins once, the daily claim adds +20 coins once a day, and inviting a friend earns you +25 coins when they complete their first practice step. These are the only ways to earn coins. Each AI coach question costs 1-5 coins, priced by the server according to its size. AI coaching is free with your own Google Gemini, OpenAI or OpenRouter API key (BYOK). Coins also unlock extras for 24 hours: a Recall hint level (1 coin), a Solve solution reveal (2), a LeetCode problem card's solutions (1) and a pattern's extra canonical problems (1). Nothing on the site is sold for money: coins can only be earned, never bought.

What is the refund and cancellation policy?

Hi👋SpeedAlgo sells nothing for money: there are no subscriptions, renewals or charges, so there is nothing to cancel or refund. Nothing on the site is sold for money: coins can only be earned, never bought.

Who creates and maintains the curriculum?

Hi👋SpeedAlgo is developed and maintained by Hi👋WebEnterprise (https://hiwebenterprise.com), an engineering organization focused on developer education, deliberate practice methodologies, and cognitive ergonomics for technical interviews.

How does Hi👋SpeedAlgo prepare candidates for senior and staff SWE interviews?

Rather than rote LeetCode grinding, Hi👋SpeedAlgo uses deliberate practice for each pattern: learn the loop invariant, Big-O proof and edge cases from a side-by-side template and a step-by-step debugger, rebuild the template from memory, then solve a new problem on your own against a graded test suite.

4. Circular Elimination: Find the Winner of the Circular Game (LC 1823) • Invariant Proof & Speed-Run

Theory Context•Math & Geometry

MediumLC 1823

Find the Winner of the Circular Game (LeetCode 1823)

Target Frequency:GoogleAppleNetflix

n friends sit around a circle, labeled 1 through n going clockwise, so stepping clockwise past friend n wraps you straight back to friend 1.

Play unfolds like this:

Everyone begins with friend 1 as the current spot.
From there, tick off k friends moving clockwise, counting the current friend as the first tick -- looping around the circle again if k is larger than however many friends remain.
Whichever friend the k-th tick lands on is eliminated and steps out of the circle.
As long as two or more friends remain, the next round starts its count from the friend standing immediately clockwise of the one who just left.
Once only one friend is left, that friend is declared the winner.

Given n and k, work out which friend wins.

Worked Examples

Example 1

Input:n = 5, k = 2

Output:3

Explanation: Tracking each round: (1) counting 1,2 from friend 1 eliminates 2, next count starts at 3; (2) counting 3,4 eliminates 4, next count starts at 5; (3) counting 5,1 eliminates 1, next count starts at 3; (4) counting 3,5 eliminates 5, leaving only friend 3, so friend 3 wins.

Example 2

Input:n = 6, k = 5

Output:1

Explanation: Elimination order across the rounds is 5, then 4, then 6, then 2, then 3, which leaves friend 1 as the sole survivor and winner.

⚖️Formal Constraints & Bounds

1 <= k <= n <= 500

Deep-Dive & Conceptual Insights

Core Insight

Simulating circular array deletion takes O(n * k) or O(n^2) time. The subproblem recurrence f(n, k) = (f(n - 1, k) + k) % n computes the answer iteratively in O(N) time with O(1) extra space.

Real-World Scenario & Production Applications

Counting-out games, where players stand in a circle and every k-th player drops out until one is left, like a playground rhyme that picks who is "it".

Subproblems & Recurrence Decomposition3 Phases

🧩Subproblem 1: Base Case -- A Single Survivor

With exactly 1 person in the circle, position 0 (0-indexed) trivially wins -- there's no one else to eliminate.

Mathematical Recurrence / Code Invariant

if n == 1:
    return 0

Step-by-Step Execution Trace Table

Iteration i (Circle Size)	Subproblem State f(i, k)	Shift (+ k)	Modulo (% i)	Winner (0-indexed)
1	Base case (single person)	0	0 % 1 = 0	0
2	(0 + 2) % 2	2	2 % 2 = 0	0
3	(0 + 2) % 3	2	2 % 3 = 2	2
4	(2 + 2) % 4	4	4 % 4 = 0	0
5	(0 + 2) % 5	2	2 % 5 = 2	2 (1-indexed -> 3)

Worked on Paper

The Math, Step by Step

1. The winner as a seat number from 0

Number the seats from 0 instead of from 1: friend $f$ sits at seat $f - 1$ . Write $J(s)$ for the seat of the winner in a game with $s$ friends that starts counting at seat 0. The answer to the problem is $J(n) + 1$ .

A game with one friend needs no round, so $J(1) = 0$ .

2. What the first round does

In a game of $s$ friends, the count starts at seat 0 and ticks off $k$ friends. The $k$ -th tick lands on seat $(k - 1) \bmod s$ , and that friend leaves. Here $x \bmod s$ is the remainder after dividing $x$ by $s$ , which wraps the count around the circle. The next round starts at the seat right after it, seat $k \bmod s$ .

Now $s - 1$ friends are left, and the next count starts at seat $k \bmod s$ . This is a new game of $s - 1$ friends. Give its seats new numbers, starting with 0 at seat $k \bmod s$ :

New seat in the game of $s - 1$	Old seat in the game of $s$
0	$k \bmod s$
1	$(k + 1) \bmod s$
$w$	$(w + k) \bmod s$

The new numbering has seats 0 to $s - 2$ . A new seat $s - 1$ would be old seat $(s - 1 + k) \bmod s = (k - 1) \bmod s$ , the friend who left, so it is not part of the smaller game.

3. The recurrence

The smaller game follows exactly the same rules, so its winner sits at new seat $J(s - 1)$ . The table turns that into an old seat:

$J(s) = \big(J(s - 1) + k\big) \bmod s$

Starting from $J(1) = 0$ , the code applies this rule for $s = 2, 3, \ldots, n$ . It never simulates the circle. This is the Josephus recurrence.

4. Why the seats count from 0

The mod of part 3 only works with seats numbered from 0. The remainder $x \bmod s$ is always between 0 and $s - 1$ , which are exactly the seat numbers. With seats numbered from 1, a remainder of 0 would name a seat that does not exist. So the code works with $J$ from 0 and adds 1 only at the end, in return winner + 1.

$k$ may be larger than the number of friends left, for example $k = 5$ with 2 friends. The mod handles this, because counting past the last seat wraps to the first.

5. Example 1 by hand

n = 5, k = 2.

`size`	`winner` before	`winner + k`	`winner = (winner + k) % size`
2	0	2	$2 \bmod 2 = 0$
3	0	2	$2 \bmod 3 = 2$
4	2	4	$4 \bmod 4 = 0$
5	0	2	$2 \bmod 5 = 2$

$J(5) = 2$ , so the code returns $2 + 1 = 3$ , the expected output. A direct simulation removes friends 2, 4, 1 and 5, and friend 3 is left, which agrees.

6. Example 2 by hand

n = 6, k = 5.

`size`	`winner` before	`winner + k`	`winner = (winner + k) % size`
2	0	5	$5 \bmod 2 = 1$
3	1	6	$6 \bmod 3 = 0$
4	0	5	$5 \bmod 4 = 1$
5	1	6	$6 \bmod 5 = 1$
6	1	6	$6 \bmod 6 = 0$

$J(6) = 0$ , so the code returns $0 + 1 = 1$ , the expected output. A direct simulation removes friends 5, 4, 6, 2 and 3, and friend 1 is left.

7. From the math to the code

Math	In `findTheWinner`
$J(1) = 0$	`winner = 0`
$s = 2, 3, \ldots, n$	`for size in range(2, n + 1):`
$J(s) = (J(s - 1) + k) \bmod s$	`winner = (winner + k) % size`
friend number $J(n) + 1$	`return winner + 1`

The loop runs $n - 1$ times with one addition and one remainder each, so the code takes $O(n)$ time and $O(1)$ space.

Code Shape

Archetype Code Shape

Python

1	winner = 0
2	for size in range(2, n + 1):
3	winner = (winner + k) % size
4	return winner + 1

Conceptual Narrative

🧭 Conceptual Foundation & Pattern Intuition

Simulating the entire circle of friends being eliminated one by one feels like the obvious approach — but this solution never simulates a single elimination. It builds the answer backward, from the smallest possible circle up.

🔄 The Analogy: Rewind, Then Fast-Forward One Person at a Time

Start from the trivial case: with just 1 friend in the circle, that friend obviously wins — position 0. Now imagine you already know the winning position for a circle of size - 1 friends. What happens when you add one more friend to make a circle of size? The entire elimination pattern is identical to before — it's just been rotated by k seats, and wrapped around a slightly bigger circle. So the new winner's seat is simply the old winner's seat, shifted by k, wrapped around using the new, larger circle size.

You never touch a real elimination — you just replay "shift by k, wrap around" one circle-size at a time, growing the circle from 1 person up to n.

🔑 The Key Idea in the Code

Each loop iteration answers "if I already know the winner for a circle of size - 1 friends, what's the winner for a circle of size friends?" — a single O(1) rotation, repeated n - 1 times, instead of an O(N·K) simulation of the whole game.

1-indexed to 0-indexed conversion off-by-one: The mathematical recurrence $f(n, k) = (f(n-1, k) + k) \pmod n$ operates on 0-indexed positions. Forgetting to add $+1$ at the final return violates 1-indexed output requirements.
Simulating with list deletion taking $O(N^2)$ time: Simulating circle elimination with list.pop(index) takes $O(N^2)$ time due to array element shifts. The bottom-up iterative DP formula computes the survivor in $O(N)$ time and $O(1)$ space.
Base case $n = 1$ : winner starts at 0, the seat of the only friend counted from 0; the function still returns winner + 1 = 1.

Senior SWE Reasoning Architecture

4-Phase Thought Process Model

Pattern Recognition Signals

The 10-second spot

"n friends sit around a circle", "the k-th tick ... is eliminated and steps out of the circle", "the next round starts its count from the friend standing immediately clockwise" and "once only one friend is left, that friend is declared the winner": every k-th one leaves a circle and only the last one is asked for. That is the Josephus Problem: solve the smaller circle, then shift its answer.

Formulating the Predicate & Invariants

Turning intuition into a boolean rule

Invariant: winner is the 0-indexed seat of the winner for size friends. Going from size - 1 to size friends shifts that seat by k: winner = (winner + k) % size.

Silent Failure Traps & Edge Cases

Where confident candidates still lose points

The card's trap: start from winner = 0 and add 1 only in the final return.
k can be larger than the circle (up to n): (winner + k) % size already counts whole laps, so no special case is needed.

The 60-Second Interview Pitch

Say this out loud before you type a single line

I'd use the Josephus recurrence. Once the first friend leaves, what's left is the same game with one friend fewer, only started k seats later. So if winner is the 0-indexed winner for size - 1 friends, the winner for size friends is (winner + k) % size. That's correct because removing the k-th friend and restarting from the next seat is exactly the smaller circle shifted by k seats, and % size wraps the shift around the bigger circle. I start with winner = 0 for one friend and loop size from 2 up to n. The trap is the index base: the recurrence counts seats from 0 but the friends are numbered from 1, so I add 1 only in the final return. That's O(N) time and O(1) space.

Big-O Invariant Derivation

Complexity & Mathematical Proof

TIME COMPLEXITY

O(N)

Look at the execution steps: Bottom-up Josephus recurrence: f(1) = 0, f(i) = (f(i-1) + k) % i for i from 2 to N. Single linear for-loop with N - 1 arithmetic updates.

SPACE COMPLEXITY

O(1) Auxiliary

Look at memory allocations: Call stack uses O(1) Iterative. Single scalar integer register storing winner index in O(1) space.

Formal Recurrence Relation

$T(N) = N - 1 \text{ modulo additions} = O(N)$

Derivation Progression

Base Case

f(1) = 0

With 1 person, winner is at 0-based index 0.

Index Shift Recurrence

f(i) = (f(i-1) + k) (mod i)

Remaps winner index when subproblem size expands from i-1 to i.

Linear Loop

N-1 arithmetic steps = O(N)

Computes exact winner in single linear loop.

Variable Definitions

$N$

Total number of friends in the circular game

$K$

Step counting offset for eliminations

Memory Architecture & Bounds

🟣 Call Stack

O(1) Iterative

🔵 Auxiliary Heap

O(1) Single integer register

🟢 Output Space

O(1) 1-based winner integer

Boundary Best / Worst Cases

Best Case

$O(N)$

Average Case

$O(N)$

Worst Case

$O(N)$

Recurrence Tree Topology

Synthesizing vector architecture diagram...

Staff+ Engineering Perspective

Senior SWE Deconstruction & Hardware Caveats

ARCHITECTURAL SIGNALS & INTERVIEW TRIGGERS

Structural triggers: "clock-wise circular order", "eliminate every k-th friend", "last friend remaining". Direct simulation via linked list or array pop costs $O(N \cdot k)$ or $O(N^2)$ time. A Senior SWE immediately recognizes the historic Josephus Problem, solvable in $O(N)$ time and $O(1)$ space using bottom-up dynamic programming via cyclic coordinate shifting.

CONSTRAINTS & BOUNDS

$1 \le k \le n \le 500$ : at most $499$ constant-time updates, with no list of friends and no node allocation.

FAANG PRODUCTION TRAPS & EDGE CASES

With fixed-width integers, winner + k is below $2n$ , which only overflows a 32-bit int once $n$ passes $2^{30}$ .

Core Algorithmic State Invariants

Only the Winner Is Cheap

The recurrence tracks one seat, the winner's, so it never knows who left in which round. If a problem asks for the whole elimination order, you have to simulate the removals instead.

k = 2 Has a Closed Form

For k = 2, write n = 2^m + L with 0 <= L < 2^m: the winner (numbered from 1) is 2L + 1. For n = 5 = 4 + 1 that is 3, which the loop also returns.

Loop, Not Recursion

The same rule written top-down, f(size) = (f(size - 1) + k) % size, recurses n levels deep. The loop from size = 2 up to n gives the same answer with no call stack.

Theory Context•Math & Geometry

MediumLC 1823

Find the Winner of the Circular Game (LeetCode 1823)

Target Frequency:GoogleAppleNetflix

n friends sit around a circle, labeled 1 through n going clockwise, so stepping clockwise past friend n wraps you straight back to friend 1.

Play unfolds like this:

Everyone begins with friend 1 as the current spot.
From there, tick off k friends moving clockwise, counting the current friend as the first tick -- looping around the circle again if k is larger than however many friends remain.
Whichever friend the k-th tick lands on is eliminated and steps out of the circle.
As long as two or more friends remain, the next round starts its count from the friend standing immediately clockwise of the one who just left.
Once only one friend is left, that friend is declared the winner.

Given n and k, work out which friend wins.

Worked Examples

Example 1

Input:n = 5, k = 2

Output:3

Example 2

Input:n = 6, k = 5

Output:1

Explanation: Elimination order across the rounds is 5, then 4, then 6, then 2, then 3, which leaves friend 1 as the sole survivor and winner.

⚖️Formal Constraints & Bounds

1 <= k <= n <= 500

Deep-Dive & Conceptual Insights

Core Insight

Simulating circular array deletion takes O(n * k) or O(n^2) time. The subproblem recurrence f(n, k) = (f(n - 1, k) + k) % n computes the answer iteratively in O(N) time with O(1) extra space.

Real-World Scenario & Production Applications

Counting-out games, where players stand in a circle and every k-th player drops out until one is left, like a playground rhyme that picks who is "it".

Subproblems & Recurrence Decomposition3 Phases

🧩Subproblem 1: Base Case -- A Single Survivor

With exactly 1 person in the circle, position 0 (0-indexed) trivially wins -- there's no one else to eliminate.

Mathematical Recurrence / Code Invariant

if n == 1:
    return 0

Step-by-Step Execution Trace Table

Iteration i (Circle Size)	Subproblem State f(i, k)	Shift (+ k)	Modulo (% i)	Winner (0-indexed)
1	Base case (single person)	0	0 % 1 = 0	0
2	(0 + 2) % 2	2	2 % 2 = 0	0
3	(0 + 2) % 3	2	2 % 3 = 2	2
4	(2 + 2) % 4	4	4 % 4 = 0	0
5	(0 + 2) % 5	2	2 % 5 = 2	2 (1-indexed -> 3)

Worked on Paper

The Math, Step by Step

1. The winner as a seat number from 0

A game with one friend needs no round, so $J(1) = 0$ .

2. What the first round does

Now $s - 1$ friends are left, and the next count starts at seat $k \bmod s$ . This is a new game of $s - 1$ friends. Give its seats new numbers, starting with 0 at seat $k \bmod s$ :

New seat in the game of $s - 1$	Old seat in the game of $s$
0	$k \bmod s$
1	$(k + 1) \bmod s$
$w$	$(w + k) \bmod s$

The new numbering has seats 0 to $s - 2$ . A new seat $s - 1$ would be old seat $(s - 1 + k) \bmod s = (k - 1) \bmod s$ , the friend who left, so it is not part of the smaller game.

3. The recurrence

The smaller game follows exactly the same rules, so its winner sits at new seat $J(s - 1)$ . The table turns that into an old seat:

$J(s) = \big(J(s - 1) + k\big) \bmod s$

Starting from $J(1) = 0$ , the code applies this rule for $s = 2, 3, \ldots, n$ . It never simulates the circle. This is the Josephus recurrence.

4. Why the seats count from 0

$k$ may be larger than the number of friends left, for example $k = 5$ with 2 friends. The mod handles this, because counting past the last seat wraps to the first.

5. Example 1 by hand

n = 5, k = 2.

`size`	`winner` before	`winner + k`	`winner = (winner + k) % size`
2	0	2	$2 \bmod 2 = 0$
3	0	2	$2 \bmod 3 = 2$
4	2	4	$4 \bmod 4 = 0$
5	0	2	$2 \bmod 5 = 2$

$J(5) = 2$ , so the code returns $2 + 1 = 3$ , the expected output. A direct simulation removes friends 2, 4, 1 and 5, and friend 3 is left, which agrees.

6. Example 2 by hand

n = 6, k = 5.

`size`	`winner` before	`winner + k`	`winner = (winner + k) % size`
2	0	5	$5 \bmod 2 = 1$
3	1	6	$6 \bmod 3 = 0$
4	0	5	$5 \bmod 4 = 1$
5	1	6	$6 \bmod 5 = 1$
6	1	6	$6 \bmod 6 = 0$

$J(6) = 0$ , so the code returns $0 + 1 = 1$ , the expected output. A direct simulation removes friends 5, 4, 6, 2 and 3, and friend 1 is left.

7. From the math to the code

Math	In `findTheWinner`
$J(1) = 0$	`winner = 0`
$s = 2, 3, \ldots, n$	`for size in range(2, n + 1):`
$J(s) = (J(s - 1) + k) \bmod s$	`winner = (winner + k) % size`
friend number $J(n) + 1$	`return winner + 1`

The loop runs $n - 1$ times with one addition and one remainder each, so the code takes $O(n)$ time and $O(1)$ space.

Code Shape

Archetype Code Shape

Python

1	winner = 0
2	for size in range(2, n + 1):
3	winner = (winner + k) % size
4	return winner + 1

Conceptual Narrative

🧭 Conceptual Foundation & Pattern Intuition

🔄 The Analogy: Rewind, Then Fast-Forward One Person at a Time

You never touch a real elimination — you just replay "shift by k, wrap around" one circle-size at a time, growing the circle from 1 person up to n.

🔑 The Key Idea in the Code

1-indexed to 0-indexed conversion off-by-one: The mathematical recurrence $f(n, k) = (f(n-1, k) + k) \pmod n$ operates on 0-indexed positions. Forgetting to add $+1$ at the final return violates 1-indexed output requirements.
Simulating with list deletion taking $O(N^2)$ time: Simulating circle elimination with list.pop(index) takes $O(N^2)$ time due to array element shifts. The bottom-up iterative DP formula computes the survivor in $O(N)$ time and $O(1)$ space.
Base case $n = 1$ : winner starts at 0, the seat of the only friend counted from 0; the function still returns winner + 1 = 1.

Senior SWE Reasoning Architecture

4-Phase Thought Process Model

Pattern Recognition Signals

The 10-second spot

Formulating the Predicate & Invariants

Turning intuition into a boolean rule

Invariant: winner is the 0-indexed seat of the winner for size friends. Going from size - 1 to size friends shifts that seat by k: winner = (winner + k) % size.

Silent Failure Traps & Edge Cases

Where confident candidates still lose points

The card's trap: start from winner = 0 and add 1 only in the final return.
k can be larger than the circle (up to n): (winner + k) % size already counts whole laps, so no special case is needed.

The 60-Second Interview Pitch

Say this out loud before you type a single line

I'd use the Josephus recurrence. Once the first friend leaves, what's left is the same game with one friend fewer, only started k seats later. So if winner is the 0-indexed winner for size - 1 friends, the winner for size friends is (winner + k) % size. That's correct because removing the k-th friend and restarting from the next seat is exactly the smaller circle shifted by k seats, and % size wraps the shift around the bigger circle. I start with winner = 0 for one friend and loop size from 2 up to n. The trap is the index base: the recurrence counts seats from 0 but the friends are numbered from 1, so I add 1 only in the final return. That's O(N) time and O(1) space.

Big-O Invariant Derivation

Complexity & Mathematical Proof

TIME COMPLEXITY

O(N)

Look at the execution steps: Bottom-up Josephus recurrence: f(1) = 0, f(i) = (f(i-1) + k) % i for i from 2 to N. Single linear for-loop with N - 1 arithmetic updates.

SPACE COMPLEXITY

O(1) Auxiliary

Look at memory allocations: Call stack uses O(1) Iterative. Single scalar integer register storing winner index in O(1) space.

Formal Recurrence Relation

$T(N) = N - 1 \text{ modulo additions} = O(N)$

Derivation Progression

Base Case

f(1) = 0

With 1 person, winner is at 0-based index 0.

Index Shift Recurrence

f(i) = (f(i-1) + k) (mod i)

Remaps winner index when subproblem size expands from i-1 to i.

Linear Loop

N-1 arithmetic steps = O(N)

Computes exact winner in single linear loop.

Variable Definitions

$N$

Total number of friends in the circular game

$K$

Step counting offset for eliminations

Memory Architecture & Bounds

🟣 Call Stack

O(1) Iterative

🔵 Auxiliary Heap

O(1) Single integer register

🟢 Output Space

O(1) 1-based winner integer

Boundary Best / Worst Cases

Best Case

$O(N)$

Average Case

$O(N)$

Worst Case

$O(N)$

Recurrence Tree Topology

Synthesizing vector architecture diagram...

Staff+ Engineering Perspective

Senior SWE Deconstruction & Hardware Caveats

ARCHITECTURAL SIGNALS & INTERVIEW TRIGGERS

CONSTRAINTS & BOUNDS

$1 \le k \le n \le 500$ : at most $499$ constant-time updates, with no list of friends and no node allocation.

FAANG PRODUCTION TRAPS & EDGE CASES

With fixed-width integers, winner + k is below $2n$ , which only overflows a 32-bit int once $n$ passes $2^{30}$ .

Core Algorithmic State Invariants

Only the Winner Is Cheap

The recurrence tracks one seat, the winner's, so it never knows who left in which round. If a problem asks for the whole elimination order, you have to simulate the removals instead.

k = 2 Has a Closed Form

For k = 2, write n = 2^m + L with 0 <= L < 2^m: the winner (numbered from 1) is 2L + 1. For n = 5 = 4 + 1 that is 3, which the loop also returns.

Loop, Not Recursion

The same rule written top-down, f(size) = (f(size - 1) + k) % size, recurses n levels deep. The loop from size = 2 up to n gives the same answer with no call stack.

Iteration i (Circle Size)

Subproblem State f(i, k)

Shift (+ k)

Modulo (% i)

Winner (0-indexed)

Base case (single person)

0 % 1 = 0

(0 + 2) % 2

2 % 2 = 0

(0 + 2) % 3

2 % 3 = 2

(2 + 2) % 4

4 % 4 = 0

(0 + 2) % 5

2 % 5 = 2

2 (1-indexed -> 3)

s - 1

s

k \bmod s

(k + 1) \bmod s

w

(w + k) \bmod s

size

winner before

winner + k

winner = (winner + k) % size

2 \bmod 2 = 0

2 \bmod 3 = 2

4 \bmod 4 = 0

2 \bmod 5 = 2

size

winner before

winner + k

winner = (winner + k) % size

5 \bmod 2 = 1

6 \bmod 3 = 0

5 \bmod 4 = 1

6 \bmod 5 = 1

6 \bmod 6 = 0

Math

In findTheWinner

J(1) = 0

winner = 0

s = 2, 3, \ldots, n

for size in range(2, n + 1):

J(s) = (J(s - 1) + k) \bmod s

winner = (winner + k) % size

friend number

J(n) + 1

return winner + 1

🧭 Conceptual Foundation & Pattern Intuition

🔄 The Analogy: Rewind, Then Fast-Forward One Person at a Time

You never touch a real elimination — you just replay "shift by k, wrap around" one circle-size at a time, growing the circle from 1 person up to n.

🔑 The Key Idea in the Code

Iteration i (Circle Size)

Subproblem State f(i, k)

Shift (+ k)

Modulo (% i)

Winner (0-indexed)

Base case (single person)

0 % 1 = 0

(0 + 2) % 2

2 % 2 = 0

(0 + 2) % 3

2 % 3 = 2

(2 + 2) % 4

4 % 4 = 0

(0 + 2) % 5

2 % 5 = 2

2 (1-indexed -> 3)

s - 1

s

k \bmod s

(k + 1) \bmod s

w

(w + k) \bmod s

size

winner before

winner + k

winner = (winner + k) % size

2 \bmod 2 = 0

2 \bmod 3 = 2

4 \bmod 4 = 0

2 \bmod 5 = 2

size

winner before

winner + k

winner = (winner + k) % size

5 \bmod 2 = 1

6 \bmod 3 = 0

5 \bmod 4 = 1

6 \bmod 5 = 1

6 \bmod 6 = 0

Math

In findTheWinner

J(1) = 0

winner = 0

s = 2, 3, \ldots, n

for size in range(2, n + 1):

J(s) = (J(s - 1) + k) \bmod s

winner = (winner + k) % size

friend number

J(n) + 1

return winner + 1