Throttle

Throttle - Problem

JavaScript Medium

Given a function fn and a time in milliseconds t, return a throttled version of that function.

A throttled function is first called without delay and then, for a time interval of t milliseconds, can't be executed but should store the latest function arguments provided to call fn with them after the end of the delay.

For instance, t = 50ms, and the function was called at 30ms, 40ms, and 60ms:

• At 30ms: function executes immediately without delay
• At 40ms: function is blocked, arguments stored
• At 60ms: arguments overwrite the stored ones from 40ms
• At 80ms (30ms + 50ms): function executes with the latest arguments from 60ms

The throttled function should create another delay period after each execution.

Input & Output

Example 1 — Basic Throttling

$ Input: fn = (x) => console.log(x), t = 100

› Output: throttled function

💡 Note: Creates a throttled version that executes immediately on first call, then blocks for 100ms while storing latest arguments

Example 2 — Multiple Calls During Cooldown

$ Input: fn = (a,b) => console.log(a+b), t = 50

› Output: throttled function

💡 Note: Function executes first call immediately, subsequent calls during 50ms cooldown period store latest arguments for delayed execution

Example 3 — Long Cooldown Period

$ Input: fn = () => console.log('fired'), t = 1000

› Output: throttled function

💡 Note: With 1000ms cooldown, function executes immediately then ignores calls for 1 second, executing with latest args after cooldown

Constraints

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

Visualization

Tap to expand

Asked in

F Facebook 35 G Google 28 A Amazon 22

The key insight is to execute the first call immediately, then enter a cooldown period where subsequent calls store their arguments. The optimal approach uses timestamp tracking to manage timing precisely. Time: O(1), Space: O(1)

Common Approaches

✓ Basic Timer Approach

⏱️ Time: O(1) Space: O(1)

Track if the function is in cooldown period using a boolean flag. Execute immediately on first call, then store arguments and set timer for delayed execution.

Optimized State Management

⏱️ Time: O(1) Space: O(1)

Maintain cleaner state management using a single timer approach. Track the last execution time and pending arguments more efficiently to prevent timer conflicts.

Basic Timer Approach — Algorithm Steps

Check if function is in cooldown
If not, execute immediately and start cooldown
If in cooldown, store latest arguments
Use setTimeout for delayed execution with latest args

Visualization

Tap to expand

Step-by-Step Walkthrough

First Call

Execute immediately, start cooldown timer

During Cooldown

Store latest arguments, ignore execution

Timer Expires

Execute with stored args, start new cooldown

Code -

solution.c — C

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

typedef struct {
    int inCooldown;
    void* latestArgs;
    void* timerId;
} ThrottleState;

static ThrottleState state = {0, NULL, NULL};

void* solution(void* fn, int t) {
    // This is a simplified representation since C doesn't have closures
    // The actual throttled function would need to be implemented separately
    
    if (!state.inCooldown) {
        // First call - execute immediately
        void* result = NULL; // Would call fn(...args)
        state.inCooldown = 1;
        
        // Reset cooldown logic (would be in a timer callback)
        void reset_cooldown() {
            state.inCooldown = 0;
            if (state.latestArgs != NULL) {
                // Execute with latest stored arguments
                void* storedArgs = state.latestArgs;
                state.latestArgs = NULL;
                state.inCooldown = 1;
                // Would call fn(...storedArgs)
                // Set another timer for next cooldown
                state.timerId = NULL; // Would be setTimeout equivalent
            }
        }
        
        state.timerId = NULL; // Would be setTimeout(reset_cooldown, t)
        return result;
    } else {
        // During cooldown - store latest arguments
        state.latestArgs = NULL; // Would store actual args
    }
    
    return NULL;
}

int main() {
    char fnCode[1000];
    fgets(fnCode, sizeof(fnCode), stdin);
    fnCode[strcspn(fnCode, "\n")] = 0;
    
    int t;
    scanf("%d", &t);
    
    // Create test function (simplified)
    void* testFn = NULL;
    
    // Call solution
    void* result = solution(testFn, t);
    (void)result;
    
    printf("throttled_function\n");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(1)

Each function call performs constant time operations

✓ Linear Growth

Space Complexity

O(1)

Only stores a few variables regardless of call frequency

✓ Linear Space

23.5K Views

Medium Frequency

~25 min Avg. Time

892 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

Constraints

Visualization

Related Problems

Common Approaches

Basic Timer Approach — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler