Sleep - Solution & Explanation
Problem Statement
Given a positive integer millis, write an asynchronous function that sleeps for millis milliseconds. It can resolve any value.
Example 1:
Input: millis = 100
Output: 100
Explanation: It should return a promise that resolves after 100ms.
let t = Date.now();
sleep(100).then(() => {
console.log(Date.now() - t); // 100
});
Example 2:
Input: millis = 200 Output: 200 Explanation: It should return a promise that resolves after 200ms.
Constraints:
1 <= millis <= 1000
Approach Overview
Problem Overview: Implement a sleep function that pauses execution for a specified number of milliseconds and resolves afterward. The function should return a promise-like asynchronous result so the caller can await it.
Approach 1: Promise with setTimeout (O(1) time, O(1) space)
The most common JavaScript implementation wraps setTimeout inside a Promise. When the function is called, you create a new promise and schedule setTimeout to call resolve after millis milliseconds. The event loop handles the delay while the main thread continues processing other tasks. This approach relies on the browser or Node.js timer system and is the standard way to implement delays in Promises-based code. Since the function only schedules a timer, the algorithmic complexity is constant: O(1) time and O(1) space.
Approach 2: Python asyncio.sleep (O(1) time, O(1) space)
Python’s asyncio.sleep provides the same behavior in an asynchronous programming environment. The function is defined with async and awaits asyncio.sleep(milliseconds / 1000). Instead of blocking the thread, the coroutine yields control back to the event loop until the timer expires. This allows other coroutines to run concurrently, which is the core advantage of asynchronous I/O. Like the JavaScript version, the operation schedules a timer and therefore runs in O(1) time and O(1) space.
Approach 3: Task.Delay / CompletableFuture Delay (O(1) time, O(1) space)
Languages with structured async frameworks provide built-in delay utilities. In C#, Task.Delay(milliseconds) returns a task that completes after the specified duration. In Java, a similar effect can be achieved using CompletableFuture with a delayed executor or scheduled task. Both rely on runtime schedulers rather than blocking the thread. The caller can await or chain the returned future, integrating naturally with concurrency primitives. Because the runtime simply schedules a timer, the complexity remains O(1) time and O(1) space.
Recommended for interviews: The JavaScript Promise + setTimeout implementation is the expected answer because it demonstrates understanding of the event loop and asynchronous control flow. Showing that you know built-in delay primitives like asyncio.sleep or Task.Delay also signals familiarity with async runtimes. The key insight interviewers look for is recognizing that you should schedule a timer rather than block execution.
Approach 1: Using Promises and setTimeout in JavaScript
This approach utilizes JavaScript's Promise and setTimeout to create an asynchronous sleep function. The setTimeout function is used to delay the promise resolution by the specified number of milliseconds.
The sleep function creates a new Promise. Inside the promise, setTimeout is used to delay the invocation of the resolve function by millis milliseconds. This means the promise will be resolved after the specified delay, implementing a "sleep" behavior.
Code
JavaScript
Complexity
Time Complexity: O(1) because the delay is constant independent of any input size.
Space Complexity: O(1) as we're only storing the promise which requires constant space.
Approach 2: Using Task.Delay in C#
This approach uses C#'s Task.Delay method to implement the asynchronous sleep function. Task.Delay returns a task that completes after the specified delay.
In C#, the Sleep method is marked async to indicate it can execute asynchronously. We use Task.Delay, which returns a Task that completes after a delay specified by millis. The await keyword is used to asynchronously wait for the task's completion.
Code
C#
Complexity
Time Complexity: O(1). The execution time is constant due to the non-blocking nature of tasks.
Space Complexity: O(1) as we're dealing with a single task object.
Approach 3: Using Java's CompletableFuture
This method involves Java's CompletableFuture class which allows for asynchronous programming. We can use this to simulate a sleep by combining it with Thread.sleep.
The sleep function uses CompletableFuture.runAsync to execute a task asynchronously that sleeps for the given milliseconds using Thread.sleep. CompletableFuture handles asynchronous computations and allows us to define a function to be run asynchronously.
Code
Java
Complexity
Time Complexity: O(1). The delay action is constant time as it directly calls Thread.sleep.
Space Complexity: O(1) since the CompletableFuture only maintains a completion stage.
Approach 4: Python's asyncio.sleep
In Python, the asyncio library provides an asynchronous infrastructure, with asyncio.sleep providing sleep functionality without blocking.
The sleep function is asynchronous, using asyncio.sleep to suspend the coroutine for the specified duration. The function converts milliseconds to seconds (since asyncio.sleep accepts seconds) and then awaits the sleep.
Code
Python
Complexity
Time Complexity: O(1). The delay is managed internally by the event loop, thus constant.
Space Complexity: O(1) as only the coroutine object is being utilized.
Approach 5: Default Approach
Code
TypeScript
JavaScript
Complexity Comparison
| Approach | Complexity |
|---|---|
| Using Promises and setTimeout in JavaScript | Time Complexity: O(1) because the delay is constant independent of any input size. |
| Using Task.Delay in C# | Time Complexity: O(1). The execution time is constant due to the non-blocking nature of tasks. |
| Using Java's CompletableFuture | Time Complexity: O(1). The delay action is constant time as it directly calls |
| Python's asyncio.sleep | Time Complexity: O(1). The delay is managed internally by the event loop, thus constant. |
| Default Approach | — |
Detailed Complexity Analysis
| Approach | Time | Space | When to Use |
|---|---|---|---|
| Promise with setTimeout (JavaScript) | O(1) | O(1) | Standard solution in JavaScript environments using promises and the event loop |
| asyncio.sleep (Python) | O(1) | O(1) | Async Python programs using asyncio coroutines |
| Task.Delay / CompletableFuture Delay | O(1) | O(1) | C# or Java async workflows that rely on task or future scheduling |
Video Solution
Sleep - Leetcode 2621 - JavaScript 30-Day Challenge • NeetCodeIO • 13,184 views views
Watch 9 more video solutions →Frequently Asked Questions
Is Sleep easy or hard?
Sleep Python/Java solution
How to solve Sleep in O(1)?
What is the best approach for Sleep?
Is Sleep asked at Google/Amazon/Meta?
What data structure is used in Sleep?
What is the time complexity of Sleep?
Ready to solve this problem?
Practice Sleep with our built-in code editor and test cases.
Practice on FleetCodeTable of Contents
Practice this problem
Open in Editor