Find the Losers of the Circular Game - Practice Coding Problems

Find the Losers of the Circular Game - Problem

Imagine n friends sitting in a circle, numbered 1 to n clockwise. They're playing a special ball-passing game with an interesting twist!

Game Rules:

Friend 1 starts with the ball
On turn 1: Pass to friend k steps clockwise
On turn 2: Pass to friend 2×k steps clockwise
On turn 3: Pass to friend 3×k steps clockwise
And so on... on turn i, pass i×k steps clockwise

The game ends when someone receives the ball for the second time.

Your task: Find all the "losers" - friends who never got to touch the ball during the entire game. Return them in ascending order.

Note: Moving clockwise from friend n brings you back to friend 1 (circular array).

Input & Output

example_1.py — Basic Case

$ Input: n = 5, k = 2

› Output: [4, 5]

💡 Note: Game flow: Friend 1 starts → passes 2 steps to Friend 3 → Friend 3 passes 4 steps to Friend 2 → Friend 2 passes 6 steps (6%5=1) back to Friend 1. Friend 1 receives ball twice, so game ends. Friends 4 and 5 never received the ball.

example_2.py — Single Step

$ Input: n = 4, k = 1

› Output: []

💡 Note: Game flow: Friend 1 → Friend 2 (1 step) → Friend 4 (2 steps) → Friend 3 (3 steps) → Friend 2 (4 steps). Friend 2 receives ball twice, game ends. All friends participated, so no losers.

example_3.py — Large Steps

$ Input: n = 6, k = 3

› Output: [2, 3, 5, 6]

💡 Note: Game flow: Friend 1 starts → passes 3 steps to Friend 4 → Friend 4 passes 6 steps (6%6=0, so back to Friend 4). Friend 4 receives ball twice immediately. Only friends 1 and 4 participated.

Constraints

2 ≤ n ≤ 50
1 ≤ k ≤ n
The game will always end (mathematical guarantee)
Note: Friends are numbered from 1 to n, not 0-indexed

Visualization

Tap to expand

Understanding the Visualization

Setup Circle

Friends 1-n sit in clockwise circle, friend 1 has ball

Escalating Steps

Each turn increases step size: k, 2k, 3k, etc.

Track Visited

Use hash set to remember who got the ball

Find Duplicate

Stop when someone receives ball second time

Identify Losers

Return friends who never got the ball

Key Takeaway

🎯 Key Insight: The game naturally creates a cycle, and we only need to simulate until we find the first repeat visitor. Hash sets make duplicate detection O(1), leading to optimal O(n) performance.

Asked in

G Google 15 a Amazon 12 f Meta 8 ⊞ Microsoft 6

The optimal solution uses a hash set to efficiently track visited friends during game simulation. We start at friend 1, calculate each next position using modular arithmetic (current + turn*k) % n, and stop when we encounter a friend who already received the ball. The key insight is that hash set lookups are O(1), making the overall time complexity O(n) where n is the number of friends.

Common Approaches

Approach	Time	Space	Notes
✓ One-Pass Hash Set (Optimal)	O(n)	O(n)	Use a hash set to track visited friends while simulating the game
Brute Force Simulation	O(n²)	O(n)	Simulate the game step by step, tracking all friends and checking for duplicates

One-Pass Hash Set (Optimal) — Algorithm Steps

Initialize a hash set to track visited friends
Start at friend 1 and add to visited set
For each turn, calculate next position using modular arithmetic
Check if next friend is already in visited set (O(1) lookup)
If found, stop game; otherwise add to visited set
Create result by finding all friends not in visited set

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Create empty hash set, add friend 1

Calculate Next

Use (current + turn*k) % n formula

Check Set

O(1) lookup in hash set

Add or Stop

Add new friend or stop if duplicate found

Code -

solution.c — C

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

int* circularGameLosers(int n, int k, int* returnSize) {
    bool* visited = (bool*)calloc(n + 1, sizeof(bool));
    int current = 0; // 0-indexed (friend 1)
    int turn = 1;
    
    visited[current + 1] = true; // Add friend 1
    
    while (true) {
        // Calculate next position
        current = (current + turn * k) % n;
        int friend = current + 1; // Convert to 1-indexed
        
        // Check if already visited
        if (visited[friend]) {
            break;
        }
        visited[friend] = true;
        turn++;
    }
    
    // Find losers - all friends not visited
    int* losers = (int*)malloc(n * sizeof(int));
    int loserCount = 0;
    
    for (int i = 1; i <= n; i++) {
        if (!visited[i]) {
            losers[loserCount++] = i;
        }
    }
    
    free(visited);
    *returnSize = loserCount;
    return losers;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

We visit each friend at most once during simulation, and set operations are O(1)

✓ Linear Growth

Space Complexity

O(n)

Hash set stores visited friends (at most n friends) plus result array

⚡ Linearithmic Space

24.6K Views

Medium Frequency

~12 min Avg. Time

845 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

One-Pass Hash Set (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler