Pass the Pillow - Practice Coding Problems

Pass the Pillow - Problem

Math Simulation Easy

Imagine n people standing in a line, numbered from 1 to n. The first person starts with a pillow and passes it down the line every second. But here's the twist: when the pillow reaches the end of the line, it bounces back and travels in the opposite direction!

Think of it like a pendulum swing - the pillow moves from person 1 → 2 → 3 → ... → n, then reverses direction: n → (n-1) → (n-2) → ... → 1, and continues this back-and-forth pattern.

Your task: Given the number of people n and the time elapsed time, determine which person is holding the pillow after time seconds.

Example: With 4 people, the sequence goes: 1 → 2 → 3 → 4 → 3 → 2 → 1 → 2 → ...

Input & Output

example_1.py — Basic Forward Movement

$ Input: n = 4, time = 2

› Output: 3

💡 Note: At time 0: position 1. At time 1: position 2. At time 2: position 3. The pillow is moving forward and hasn't reached the end yet.

example_2.py — Direction Reversal

$ Input: n = 3, time = 4

› Output: 2

💡 Note: Sequence: 1→2→3→2→1. At time 4, we've gone forward to position 3, then started moving backward: 3→2. So position is 2.

example_3.py — Complete Cycle

$ Input: n = 4, time = 6

› Output: 1

💡 Note: One complete cycle takes 2(n-1) = 6 seconds: 1→2→3→4→3→2→1. After 6 seconds, we're back at the starting position.

Constraints

2 ≤ n ≤ 1000
1 ≤ time ≤ 1000
The pillow always starts at person 1
Time represents seconds elapsed, not the final timestamp

Visualization

Tap to expand

Understanding the Visualization

Forward Phase

Pillow moves from position 1 to n (takes n-1 steps)

Backward Phase

Pillow moves from position n back to 1 (takes n-1 steps)

Complete Cycle

Total cycle time is 2(n-1) seconds

Mathematical Shortcut

Use time % cycle_length to skip repetitive simulation

Key Takeaway

🎯 Key Insight: The pillow's movement is cyclical with period 2(n-1). Instead of simulating each step, we can use modular arithmetic to instantly calculate the final position, achieving O(1) time complexity!

Asked in

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

This problem has two approaches: simulation (O(time) complexity) and mathematical optimization (O(1) complexity). The key insight is recognizing that the pillow follows a cyclical pattern with period 2(n-1). Using modular arithmetic, we can instantly determine the position without simulating each step.

Common Approaches

Approach	Time	Space	Notes
✓ Mathematical Optimization (Optimal)	O(1)	O(1)	Use modular arithmetic to find position without simulation
Simulation (Step by Step)	O(time)	O(1)	Simulate each second of pillow passing until time runs out

Mathematical Optimization (Optimal) — Algorithm Steps

Calculate cycle length: 2(n-1) seconds for a complete round trip
Find position in cycle: time % cycle_length
If in first half of cycle (0 to n-1): position = time_in_cycle + 1
If in second half of cycle (n to 2n-2): position = n - (time_in_cycle - (n-1))
Return the calculated position

Visualization

Tap to expand

Step-by-Step Walkthrough

Identify Cycle

Pattern repeats every 2(n-1) seconds

Find Remainder

Use time % cycle_length to find position in cycle

Determine Direction

First half = forward, second half = backward

Calculate Position

Apply formula based on direction

Code -

solution.c — C

#include <stdio.h>

int passThePillow(int n, int time) {
    // Handle edge case: only one person
    if (n == 1) {
        return 1;
    }
    
    // Calculate cycle length (complete round trip)
    int cycleLength = 2 * (n - 1);
    
    // Find position within the current cycle
    int timeInCycle = time % cycleLength;
    
    // Determine position based on which half of cycle we're in
    if (timeInCycle <= n - 1) {
        // First half: moving forward (1 -> n)
        return timeInCycle + 1;
    } else {
        // Second half: moving backward (n -> 1)
        return n - (timeInCycle - (n - 1));
    }
}

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

Time & Space Complexity

Time Complexity

⏱️

O(1)

Only constant-time arithmetic operations regardless of input size

✓ Linear Growth

Space Complexity

O(1)

Only need a few variables to store intermediate calculations

✓ Linear Space

23.5K Views

Medium Frequency

~15 min Avg. Time

892 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

Mathematical Optimization (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler