Debounce - Leetcode Solution

The Debounce problem on LeetCode is a simple one that requires you to implement a 'debounce' function for a certain event. The problem statement is as follows:

Implement the Debounce class:

• Debounce(int timeout) Initializes the object with the timeout value, in milliseconds, for the debounce timer.
• bool shouldInvoke() Returns true if the debounced function should be called according to the timeout value from the last debounced invocation.

The Debounce class is meant to be instantiated and used to debounce a function call. Debouncing is a technique that can be used to prevent a function from being called multiple times within a certain period of time.

The solution to this problem can be implemented using two variables: a timer variable and a function variable. The timer variable will be used to keep track of the time that has elapsed since the last invocation of the function, and the function variable will be used to store the function that needs to be debounced.

Here's the detailed solution to the Debounce problem on LeetCode:

Step 1: Declare the Debounce class

Start by declaring the Debounce class that will contain the two variables: a timer variable and a function variable.

class Debounce { private: int timeout; // timeout value in milliseconds int timer; // timer variable to keep track of time

public: function<void()> functionToDebounce; // function to be debounced

Debounce(int timeout) {
    this->timeout = timeout;
    this->timer = 0;
}

};

Step 2: Implement the shouldInvoke() method

The shouldInvoke() method will be used to determine whether the debounced function should be called according to the timeout value.

bool shouldInvoke() { if (timer >= timeout) { timer = 0; return true; } return false; }

This method checks whether the timer variable has exceeded the timeout value. If it has, it resets the timer variable to 0 and returns true. Otherwise, it returns false, indicating that the debounced function should not be called yet.

Step 3: Implement the functionToDebounceWrapper() method

The functionToDebounceWrapper() method is a wrapper function that will be used to invoke the functionToDebounce() method after a certain amount of time has elapsed since the last invocation.

void functionToDebounceWrapper() { if (shouldInvoke()) { functionToDebounce(); } }

This method checks whether the debounced function should be called by calling the shouldInvoke() method. If it returns true, it invokes the functionToDebounce() method.

Step 4: Implement the debounce() method

The debounce() method is used to debounce the function that needs to be called.

void debounce(function<void()> func) { functionToDebounce = func; timer = 0; }

This method takes in a function as a parameter and assigns it to the functionToDebounce variable. It also resets the timer variable to 0.

Step 5: Implement the updateTimer() method

The updateTimer() method is used to update the timer variable every time it is called. This method will be called in the main loop of the program to ensure that the timer variable is being updated regularly.

void updateTimer(int deltaTime) { timer += deltaTime; }

This method takes in a deltaTime value that indicates the time elapsed since the last update, and adds it to the timer variable.

Step 6: Use the Debounce class to debounce a function call

To use the Debounce class to debounce a function call, you need to follow these steps:

• Instantiate a Debounce object with a timeout value in milliseconds.
• Call the debounce() method with the function that needs to be debounced as a parameter.
• Call the functionToDebounceWrapper() method in the main loop of the program.
• Call the updateTimer() method in the main loop of the program with the deltaTime value as a parameter.

Here's an example of how to use the Debounce class to debounce a function call:

Debounce myDebounce(1000); // debounce with timeout of 1 second

void myFunction() { // do something here }

void setup() { myDebounce.debounce(myFunction); // debounce myFunction }

void loop() { myDebounce.functionToDebounceWrapper(); // call the debounced function myDebounce.updateTimer(100); // update the timer every 100 milliseconds }

This code sets up a Debounce object with a timeout value of 1 second, and debounces the myFunction() function. In the main loop of the program, the debounced function is called using the functionToDebounceWrapper() method, and the timer is updated every 100 milliseconds using the updateTimer() method.

That's it! You have now implemented a Debounce class that can be used to debounce a function call.

1