Throttle - Practice Coding Problems

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

Understanding the Visualization

Input Function

Original function with timing parameter t

Throttle Logic

Add timing control and argument storage

Controlled Output

Function executes at controlled intervals

Key Takeaway

🎯 Key Insight: Execute immediately on first call, then batch subsequent calls during cooldown period

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

Approach	Time	Space	Notes
✓ Optimized State Management	O(1)	O(1)	Use single timer with better state tracking to avoid multiple timers
Basic Timer Approach	O(1)	O(1)	Use setTimeout to track cooldown period and store latest arguments

Optimized State Management — Algorithm Steps

Track last execution time
Check if enough time has passed
If yes, execute immediately
If no, schedule single delayed execution

Visualization

Tap to expand

Step-by-Step Walkthrough

Time Check

Compare current time with last execution time

Immediate or Delay

Execute if enough time passed, else schedule

Single Timer

Use one timer to prevent conflicts

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <pthread.h>
#include <unistd.h>
#include <sys/time.h>

static struct timeval lastExecTime = {0, 0};
static int* pendingArgs = NULL;
static int argsSize = 0;
static int timerActive = 0;
static pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;

long long getTimeMillis() {
    struct timeval tv;
    gettimeofday(&tv, NULL);
    return tv.tv_sec * 1000LL + tv.tv_usec / 1000;
}

typedef struct {
    void (*fn)(int*, int);
    int delay;
} ThreadData;

void* executePending(void* arg) {
    ThreadData* data = (ThreadData*)arg;
    usleep(data->delay * 1000);
    
    pthread_mutex_lock(&mutex);
    if (pendingArgs != NULL) {
        data->fn(pendingArgs, argsSize);
        gettimeofday(&lastExecTime, NULL);
        free(pendingArgs);
        pendingArgs = NULL;
    }
    timerActive = 0;
    pthread_mutex_unlock(&mutex);
    free(data);
    return NULL;
}

void throttledFunction(void (*fn)(int*, int), int t, int* args, int size) {
    pthread_mutex_lock(&mutex);
    
    long long currentTime = getTimeMillis();
    long long lastTime = lastExecTime.tv_sec * 1000LL + lastExecTime.tv_usec / 1000;
    long long timeSinceLast = currentTime - lastTime;
    
    if (timeSinceLast >= t || lastTime == 0) {
        fn(args, size);
        gettimeofday(&lastExecTime, NULL);
    } else {
        if (pendingArgs != NULL) {
            free(pendingArgs);
        }
        pendingArgs = malloc(size * sizeof(int));
        memcpy(pendingArgs, args, size * sizeof(int));
        argsSize = size;
        
        if (!timerActive) {
            timerActive = 1;
            ThreadData* data = malloc(sizeof(ThreadData));
            data->fn = fn;
            data->delay = t - timeSinceLast;
            
            pthread_t thread;
            pthread_create(&thread, NULL, executePending, data);
            pthread_detach(thread);
        }
    }
    
    pthread_mutex_unlock(&mutex);
}

int main() {
    char fnCode[1000];
    fgets(fnCode, sizeof(fnCode), stdin);
    fnCode[strcspn(fnCode, "\n")] = 0;
    
    int t;
    scanf("%d", &t);
    
    printf("throttled_function\n");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(1)

Each function call performs constant time operations with better efficiency

✓ Linear Growth

Space Complexity

O(1)

Uses minimal state 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

Optimized State Management — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler