Interval Cancellation - Practice Coding Problems

Interval Cancellation - Problem

JavaScript Easy

Given a function fn, an array of arguments args, and an interval time t, return a cancel function cancelFn.

After a delay of cancelTimeMs, the returned cancel function cancelFn will be invoked:

setTimeout(cancelFn, cancelTimeMs)

The function fn should be called with args immediately and then called again every t milliseconds until cancelFn is called at cancelTimeMs ms.

Input & Output

Example 1 — Basic Interval

$ Input: fn = () => x++, args = [2], t = 20, cancelTimeMs = 50

› Output: [{"time":0,"returned":2},{"time":20,"returned":3},{"time":40,"returned":4}]

💡 Note: Function called immediately at t=0 returning 2, then at t=20 returning 3, then at t=40 returning 4. Cancelled before t=60.

Example 2 — Short Interval

$ Input: fn = () => x++, args = [5], t = 25, cancelTimeMs = 30

› Output: [{"time":0,"returned":5},{"time":25,"returned":6}]

💡 Note: Function called at t=0 returning 5, then at t=25 returning 6. Next call would be at t=50 but cancelled at t=30.

Example 3 — Immediate Cancel

$ Input: fn = () => x++, args = [1], t = 100, cancelTimeMs = 10

› Output: [{"time":0,"returned":1}]

💡 Note: Only the immediate call at t=0 executes returning 1. Cancelled at t=10 before first interval at t=100.

Constraints

1 ≤ t ≤ 10³
1 ≤ cancelTimeMs ≤ 10⁴
fn is a JavaScript function
args is an array of valid JavaScript values

Visualization

Tap to expand

Understanding the Visualization

Input

Function fn, args=[2], interval t=20ms, cancel at 50ms

Process

Call immediately, then every 20ms until cancellation

Output

Array of {time, returned} objects for each execution

Key Takeaway

🎯 Key Insight: Use setInterval for recurring execution and clearInterval for clean cancellation

Asked in

M Meta 25 A Amazon 20

The key insight is to use JavaScript's built-in setInterval for recurring function calls and clearInterval for clean cancellation. Call the function immediately, then use setInterval for subsequent calls every t milliseconds, and setTimeout to trigger cancellation. Best approach is setInterval with clearInterval. Time: O(1), Space: O(1)

Common Approaches

Approach	Time	Space	Notes
✓ Manual Timing Approach	O(1)	O(1)	Use setTimeout recursively to schedule each function call manually
setInterval with clearInterval	O(1)	O(1)	Use native setInterval for recurring calls and clearInterval for cancellation

Manual Timing Approach — Algorithm Steps

Call function immediately
Schedule next call with setTimeout
Track elapsed time and cancel when needed

Visualization

Tap to expand

Step-by-Step Walkthrough

Immediate Call

Execute function at time 0

Schedule Next

Use setTimeout to schedule next call

Repeat Until Cancel

Continue scheduling until cancellation time

Code -

solution.c — C

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

typedef struct {
    int time;
    int returned;
} Result;

Result* solution(char* fnCode, int* args, int argsSize, int t, int cancelTimeMs, int* returnSize) {
    Result* results = malloc(100 * sizeof(Result));
    int currentTime = 0;
    int count = 0;
    
    // First call at time 0
    int result = (argsSize > 0) ? args[0] : 0;
    results[count].time = currentTime;
    results[count].returned = result;
    count++;
    
    // Schedule subsequent calls
    currentTime += t;
    while (currentTime < cancelTimeMs) {
        result = (argsSize > 0) ? args[0] : 0;
        results[count].time = currentTime;
        results[count].returned = result;
        count++;
        currentTime += t;
    }
    
    *returnSize = count;
    return results;
}

int main() {
    char fnCode[100];
    char argsStr[100];
    int t, cancelTimeMs;
    
    fgets(fnCode, sizeof(fnCode), stdin);
    fgets(argsStr, sizeof(argsStr), stdin);
    scanf("%d", &t);
    scanf("%d", &cancelTimeMs);
    
    // Simple args parsing
    int args[10];
    int argsSize = 0;
    
    int returnSize;
    Result* result = solution(fnCode, args, argsSize, t, cancelTimeMs, &returnSize);
    
    printf("[");
    for (int i = 0; i < returnSize; i++) {
        if (i > 0) printf(",");
        printf("{\"time\":%d,\"returned\":%d}", result[i].time, result[i].returned);
    }
    printf("]\n");
    
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(1)

Each function call and scheduling operation is constant time

✓ Linear Growth

Space Complexity

O(1)

Only stores timeout references and timing variables

✓ Linear Space

23.0K Views

Medium Frequency

~15 min Avg. Time

850 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

Manual Timing Approach — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler