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 <= 1000This 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.
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.
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.
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.
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.
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.
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.
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 | 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. |
Stop solving 500+ Leetcode problems • Sahil & Sarra • 512,531 views views
Watch 9 more video solutions →Practice Sleep with our built-in code editor and test cases.
Practice on FleetCodePractice this problem
Open in Editor