Pass the Pillow - Practice Coding Problems

Pass the Pillow - Problem

Math Simulation Easy

There are n people standing in a line labeled from 1 to n. The first person in the line is holding a pillow initially. Every second, the person holding the pillow passes it to the next person standing in the line. Once the pillow reaches the end of the line, the direction changes, and people continue passing the pillow in the opposite direction.

For example, once the pillow reaches the nth person they pass it to the n - 1th person, then to the n - 2th person and so on.

Given the two positive integers n and time, return the index of the person holding the pillow after time seconds.

Input & Output

Example 1 — Basic Case

$ Input: n = 4, time = 5

› Output: 2

💡 Note: The pillow passes: 1→2→3→4→3→2. After 5 seconds, person 2 holds the pillow.

Example 2 — Single Person

$ Input: n = 1, time = 3

› Output: 1

💡 Note: Only one person, so they always hold the pillow regardless of time.

Example 3 — Complete Cycle

$ Input: n = 3, time = 4

› Output: 1

💡 Note: Pattern: 1→2→3→2→1. After 4 seconds, back to person 1.

Constraints

1 ≤ n ≤ 1000
0 ≤ time ≤ 1000

Visualization

Tap to expand

Understanding the Visualization

Input

n=4 people, time=5 seconds

Process

Pillow moves: 1→2→3→4→3→2

Output

Person 2 holds the pillow

Key Takeaway

🎯 Key Insight: The pillow follows a repeating back-and-forth cycle that can be calculated mathematically

Asked in

G Google 15 a Amazon 12 M Microsoft 8

The key insight is recognizing that the pillow follows a predictable back-and-forth pattern that repeats every 2(n-1) seconds. The optimal approach uses mathematical formulas to calculate the position directly in O(1) time, avoiding simulation. Time: O(1), Space: O(1).

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force Simulation	O(time)	O(1)	Simulate each second, tracking current position and direction
Mathematical Formula	O(1)	O(1)	Use cycle patterns and modular arithmetic to calculate position directly

Brute Force Simulation — Algorithm Steps

Start at position 1, direction = forward
For each second: move in current direction
Change direction when reaching position 1 or n
Return final position

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Start at position 1, direction forward

Simulate

Move position by direction each second

Result

Return final position after time seconds

Code -

solution.c — C

#include <stdio.h>

int solution(int n, int time) {
    if (time == 0) {
        return 1;
    }
    
    int position = 1;
    int direction = 1; // 1 for forward, -1 for backward
    
    for (int i = 0; i < time; i++) {
        position += direction;
        
        // Change direction if we reach the ends
        if (position == n) {
            direction = -1;
        } else if (position == 1) {
            direction = 1;
        }
    }
    
    return position;
}

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

Time & Space Complexity

Time Complexity

⏱️

O(time)

We simulate each second from 0 to time

✓ Linear Growth

Space Complexity

O(1)

Only using variables for position and direction

✓ Linear Space

31.2K Views

Medium Frequency

~15 min Avg. Time

890 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

Brute Force Simulation — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler