Find the Student that Will Replace the Chalk

Find the Student that Will Replace the Chalk - Problem

Imagine a classroom where students take turns solving problems in a circular fashion. There are n students numbered from 0 to n-1, and they sit in a circle. The teacher starts with student 0, then moves to student 1, and so on. After reaching student n-1, the teacher wraps around back to student 0.

Each student needs a certain amount of chalk pieces to solve their assigned problem. You're given an array chalk where chalk[i] represents how many pieces student i needs. Initially, there are k chalk pieces available.

Here's the catch: if when it's a student's turn, there aren't enough chalk pieces left for them to complete their problem, that student must go replace the chalk instead of solving the problem.

Goal: Determine which student will be the one asked to replace the chalk.

Example: If chalk = [5,1,5] and k = 11, student 0 uses 5 pieces (6 left), student 1 uses 1 piece (5 left), student 2 uses 5 pieces (0 left), then when we cycle back to student 0, there are 0 pieces left but they need 5, so student 0 replaces the chalk.

Input & Output

example_1.py — Basic Case

$ Input: chalk = [5,1,5], k = 22

› Output: 0

💡 Note: Total chalk per round = 5+1+5 = 11. After 2 complete rounds (22 ÷ 11 = 2), we have 0 chalk left. Student 0 needs 5 chalk but there are 0 pieces available, so student 0 must replace the chalk.

example_2.py — Partial Round

$ Input: chalk = [3,4,1,2], k = 25

› Output: 1

💡 Note: Total chalk per round = 10. After 2 complete rounds, we have 25 % 10 = 5 chalk left. Student 0 uses 3 (2 left), then student 1 needs 4 but only 2 available, so student 1 replaces the chalk.

example_3.py — Single Student Edge Case

$ Input: chalk = [1], k = 1000000

› Output: 0

💡 Note: Only one student who needs 1 chalk. After 1000000 complete rounds, 0 chalk remains. Student 0 needs 1 but there are 0 pieces, so student 0 replaces the chalk.

Constraints

1 ≤ chalk.length ≤ 10⁵
1 ≤ chalk[i] ≤ 10⁵
1 ≤ k ≤ 10⁹
All array elements are positive integers

Visualization

Tap to expand

Understanding the Visualization

Calculate Round Total

Add up all chalk requirements for one complete round

Skip Complete Rounds

Use modular arithmetic to jump to the final partial round

Find the Answer

Simulate only the final round to find who can't get enough chalk

Key Takeaway

🎯 Key Insight: Use modular arithmetic to avoid simulating every single turn, making the solution efficient for large k values!

Asked in

a Amazon 45 G Google 30 ⊞ Microsoft 25 f Meta 20

The optimal solution uses modular arithmetic to skip complete rounds and only simulate the final partial round. Calculate the total chalk needed for one complete round, then use k % total to find remaining chalk after all complete rounds. This reduces time complexity from O(k) to O(n), making it efficient even for large k values.

Common Approaches

Approach	Time	Space	Notes
✓ Simulation (Brute Force)	O(k)	O(1)	Simulate the entire process step by step until someone can't get enough chalk
Prefix Sum + Modular Arithmetic (Optimal)	O(n)	O(1)	Use modular arithmetic to skip complete rounds, then simulate only the final partial round

Simulation (Brute Force) — Algorithm Steps

Start with the current chalk amount k
Go through students 0, 1, 2, ..., n-1 in order
For each student i, check if chalk[i] <= remaining chalk
If yes, subtract chalk[i] and continue to next student
If no, return student i as the answer
After student n-1, wrap around to student 0

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Start with k=22 chalk pieces and student 0

Student 0

Student 0 needs 5, we have 22, so give 5 (17 left)

Student 1

Student 1 needs 1, we have 17, so give 1 (16 left)

Continue...

Keep going around the circle until someone can't get enough

Code -

solution.c — C

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

int chalkReplacer(int* chalk, int chalkSize, int k) {
    int i = 0;
    
    while (1) {
        if (k < chalk[i]) {
            return i;
        }
        k -= chalk[i];
        i = (i + 1) % chalkSize;
    }
    
    return -1;
}

int main() {
    int chalk[] = {5, 1, 5};
    int k = 22;
    printf("%d\n", chalkReplacer(chalk, 3, k));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(k)

In worst case, we might need to go through k chalk pieces one by one

✓ Linear Growth

Space Complexity

O(1)

Only using a few variables to track current position and remaining chalk

✓ Linear Space

42.3K Views

Medium Frequency

~15 min Avg. Time

1.2K 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 (Brute Force) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler