Sleep - Practice Coding Problems

Sleep - Problem

JavaScript Easy

Asynchronous Sleep Function

In JavaScript, sometimes you need to pause execution for a specific amount of time before continuing. Your task is to implement an asynchronous sleep function that waits for a given number of milliseconds before resolving.

Goal: Create a function that accepts a positive integer millis representing milliseconds, and returns a Promise that resolves after approximately that duration.

Input: A positive integer millis (milliseconds to sleep)
Output: A Promise that resolves after millis milliseconds (can resolve with any value)

Note: Minor deviations from the exact millisecond timing are acceptable due to JavaScript's event loop nature.

Input & Output

example_1.js — Basic Sleep

$ Input: 100

› Output: Promise resolves after ~100ms

💡 Note: The function creates a Promise that resolves after approximately 100 milliseconds using setTimeout

example_2.js — Longer Sleep

$ Input: 1000

› Output: Promise resolves after ~1000ms (1 second)

💡 Note: Demonstrates sleeping for 1 second (1000 milliseconds) - useful for delays between operations

example_3.js — Short Sleep

$ Input: 1

› Output: Promise resolves after ~1ms

💡 Note: Even very short delays work, though actual timing may be slightly longer due to JavaScript's event loop minimum delay

Constraints

1 ≤ millis ≤ 1000
The function should return a Promise
Minor timing deviations are acceptable
The solution should be non-blocking

Visualization

Tap to expand

Understanding the Visualization

Create Promise

Initialize a new Promise with resolve callback

Set Timer

Use setTimeout to schedule the resolve function

Return Promise

Return immediately - non-blocking

Timer Expires

setTimeout callback executes and resolves the Promise

Promise Resolved

Awaiting code can now continue execution

Key Takeaway

🎯 Key Insight: Use Promise + setTimeout for non-blocking asynchronous delays that don't waste CPU resources

Asked in

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

The optimal solution uses JavaScript's setTimeout wrapped in a Promise to create a non-blocking asynchronous delay. This approach leverages the event loop to pause execution without blocking the main thread, allowing other operations to continue concurrently. The key insight is using Promise + setTimeout for true asynchronous behavior.

Common Approaches

Approach	Time	Space	Notes
✓ Blocking Loop (Inefficient)	O(millis)	O(1)	Use a while loop to continuously check elapsed time
Promise + setTimeout (Optimal)	O(1)	O(1)	Use setTimeout wrapped in a Promise for non-blocking asynchronous delay

Blocking Loop (Inefficient) — Algorithm Steps

Record the start time using Date.now()
Enter a while loop that continues until elapsed time >= millis
Continuously check current time and calculate elapsed time
Return a resolved Promise when time is up

Visualization

Tap to expand

Step-by-Step Walkthrough

Start Timer

Record the start time

Busy Wait

Continuously check time in a loop

Block Thread

Thread is blocked, preventing other operations

Return Result

Finally return after wasting CPU cycles

Code -

solution.c — C

#include <stdio.h>
#include <time.h>

int sleepBlocking(int millis) {
    clock_t start = clock();
    while ((clock() - start) * 1000 / CLOCKS_PER_SEC < millis) {
        // Busy waiting
    }
    return millis;
}

int main() {
    int millis;
    scanf("%d", &millis);
    int result = sleepBlocking(millis);
    printf("%d\n", result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(millis)

The loop runs for approximately millis milliseconds

✓ Linear Growth

Space Complexity

O(1)

Only uses a few variables to track time

✓ Linear Space

58.0K Views

Medium Frequency

~5 min Avg. Time

2.4K 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

Blocking Loop (Inefficient) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler