Throttle - Practice Coding Problems

Throttle - Problem

JavaScript Medium

Throttling is a crucial technique in web development for rate limiting function execution. Your task is to implement a throttle function that creates a throttled version of any given function.

Here's how throttling works:

The first call executes immediately without delay
During the throttle period (t milliseconds), subsequent calls are blocked but store the latest arguments
After the throttle period ends, the function executes once more with the most recent arguments received during the blocked period
This creates a new throttle period, and the cycle continues

Example Timeline:

If t = 50ms and calls happen at 30ms, 40ms, and 60ms:

30ms: Function executes immediately, starts 50ms throttle period
40ms: Call blocked, arguments stored
60ms: Call blocked, arguments overwrite previous stored arguments
80ms: Throttle period ends, function executes with arguments from 60ms call

Your throttled function should return a new function that implements this behavior using JavaScript's timing mechanisms.

Input & Output

basic_throttle.js — JavaScript

$ Input: fn = (x) => console.log(x), t = 100 Calls: throttledFn(1) at 0ms, throttledFn(2) at 50ms, throttledFn(3) at 75ms

› Output: Logs '1' at 0ms, logs '3' at 100ms

💡 Note: First call executes immediately. Calls at 50ms and 75ms are blocked during throttle period, but the last call's arguments (3) are stored and executed after the 100ms delay.

multiple_periods.js — JavaScript

$ Input: fn = (x) => x * 2, t = 50 Calls: throttledFn(1) at 0ms, throttledFn(2) at 25ms, throttledFn(3) at 60ms, throttledFn(4) at 80ms

› Output: Returns 2 at 0ms, returns 4 at 50ms, returns 6 at 60ms, returns 8 at 110ms

💡 Note: Two separate throttle periods occur. First period: call at 0ms executes immediately, call at 25ms is stored and executes at 50ms. Second period: call at 60ms executes immediately, call at 80ms is stored and executes at 110ms.

edge_case.js — JavaScript

$ Input: fn = () => 'executed', t = 200 Calls: throttledFn() at 0ms, then no more calls

› Output: Returns 'executed' at 0ms, no further executions

💡 Note: Edge case where only one call is made. The function executes immediately and no delayed execution occurs since no calls were made during the throttle period.

Visualization

Tap to expand

Understanding the Visualization

Immediate Execution

First function call executes without delay

Throttle Period

Subsequent calls during throttle period are blocked but arguments stored

Argument Storage

Latest arguments overwrite previous stored arguments

Delayed Execution

After throttle period ends, function executes with stored arguments

Key Takeaway

🎯 Key Insight: Throttling efficiently limits function execution frequency by immediately executing the first call, storing subsequent arguments during the throttle period, and executing once more with the latest stored arguments when the period expires.

Time & Space Complexity

Time Complexity

⏱️

O(1)

Each function call executes in constant time regardless of call frequency

✓ Linear Growth

Space Complexity

O(1)

Uses fixed amount of space for state variables and stored arguments

✓ Linear Space

Constraints

0 ≤ t ≤ 1000
fn is a valid function
Function calls can happen at any time
The throttled function should preserve the original function's return value and context

Asked in

G Google 45 f Meta 38 a Amazon 32 ⊞ Microsoft 28 N Netflix 22

The optimal solution uses timer-based state management with closure to implement proper throttling. Key components include a boolean flag to track throttling state, variables to store the latest arguments during blocked periods, and setTimeout to schedule delayed execution. The first call executes immediately, subsequent calls during the throttle period store their arguments, and after the delay expires, the function executes once more with the most recently stored arguments.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (No Throttling)	O(1)	O(1)	Execute every function call immediately without any throttling mechanism
Timer-Based Throttling (Optimal)	O(1)	O(1)	Use setTimeout and state management to implement proper throttling with immediate first execution and delayed subsequent execution

Brute Force (No Throttling) — Algorithm Steps

Store the original function
Return a wrapper function
Execute the original function on every call
Return the result immediately

Visualization

Tap to expand

Step-by-Step Walkthrough

Call 1

Function executes immediately

Call 2

Function executes immediately again

Call 3

Function executes immediately once more

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>

// Function pointer type
typedef void (*func_ptr)(void);

// Naive approach - no throttling implemented
void throttled_execute(func_ptr fn) {
    // Execute immediately every time (no throttling)
    fn();
}

void example_function() {
    printf("Function executed\n");
}

int main() {
    throttled_execute(example_function);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(1)

Each function call executes in constant time

✓ Linear Growth

Space Complexity

O(1)

No additional storage needed for throttling state

✓ Linear Space

Constraints

0 ≤ t ≤ 1000
fn is a valid function
Function calls can happen at any time
The throttled function should preserve the original function's return value and context

42.4K Views

High Frequency

~15 min Avg. Time

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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Brute Force (No Throttling) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler