2627. Debounce LeetCode Solution

In this guide, you will get 2627. Debounce LeetCode Solution with the best time and space complexity. The solution to Debounce problem is provided in various programming languages like C++, Java, and Python. This will be helpful for you if you are preparing for placements, hackathons, interviews, or practice purposes. The solutions provided here are very easy to follow and include detailed explanations.

Table of Contents

  1. Problem Statement
  2. Complexity Analysis
  3. Debounce solution in C++
  4. Debounce solution in Java
  5. Debounce solution in Python
  6. Additional Resources
2627. Debounce LeetCode Solution image

Problem Statement of Debounce

Given a function fn and a time in milliseconds t, return a debounced version of that function.
A debounced function is a function whose execution is delayed by t milliseconds and whose execution is cancelled if it is called again within that window of time. The debounced function should also receive the passed parameters.
For example, let’s say t = 50ms, and the function was called at 30ms, 60ms, and 100ms.
The first 2 function calls would be cancelled, and the 3rd function call would be executed at 150ms.
If instead t = 35ms, The 1st call would be cancelled, the 2nd would be executed at 95ms, and the 3rd would be executed at 135ms.

The above diagram shows how debounce will transform events. Each rectangle represents 100ms and the debounce time is 400ms. Each color represents a different set of inputs.
Please solve it without using lodash’s _.debounce() function.

Example 1:

Input:
t = 50
calls = [
{“t”: 50, inputs: [1]},
{“t”: 75, inputs: [2]}
]
Output: [{“t”: 125, inputs: [2]}]
Explanation:
let start = Date.now();
function log(…inputs) {
console.log([Date.now() – start, inputs ])
}
const dlog = debounce(log, 50);
setTimeout(() => dlog(1), 50);
setTimeout(() => dlog(2), 75);

See also  1722. Minimize Hamming Distance After Swap Operations LeetCode Solution

The 1st call is cancelled by the 2nd call because the 2nd call occurred before 100ms
The 2nd call is delayed by 50ms and executed at 125ms. The inputs were (2).

Example 2:

Input:
t = 20
calls = [
{“t”: 50, inputs: [1]},
{“t”: 100, inputs: [2]}
]
Output: [{“t”: 70, inputs: [1]}, {“t”: 120, inputs: [2]}]
Explanation:
The 1st call is delayed until 70ms. The inputs were (1).
The 2nd call is delayed until 120ms. The inputs were (2).

Example 3:

Input:
t = 150
calls = [
{“t”: 50, inputs: [1, 2]},
{“t”: 300, inputs: [3, 4]},
{“t”: 300, inputs: [5, 6]}
]
Output: [{“t”: 200, inputs: [1,2]}, {“t”: 450, inputs: [5, 6]}]
Explanation:
The 1st call is delayed by 150ms and ran at 200ms. The inputs were (1, 2).
The 2nd call is cancelled by the 3rd call
The 3rd call is delayed by 150ms and ran at 450ms. The inputs were (5, 6).

Constraints:

0 <= t <= 1000
1 <= calls.length <= 10
0 <= calls[i].t <= 1000
0 <= calls[i].inputs.length <= 10

Complexity Analysis

  • Time Complexity: Google AdSense
  • Space Complexity: Google Analytics

2627. Debounce LeetCode Solution in C++

type F = (...args: number[]) => void;

function debounce(fn: F, t: number): F {
  let timeout: ReturnType<typeof setTimeout> | undefined;
  return function (...args) {
    clearTimeout(timeout);
    timeout = setTimeout(() => fn(...args), t);
  };
}
/* code provided by PROGIEZ */

2627. Debounce LeetCode Solution in Java

N/A
// code provided by PROGIEZ

2627. Debounce LeetCode Solution in Python

N/A
# code by PROGIEZ

Additional Resources

Happy Coding! Keep following PROGIEZ for more updates and solutions.