Interval Cancellation - Practice Coding Problems

Interval Cancellation - Problem

JavaScript Easy

Interval Cancellation is a fundamental JavaScript timing problem that tests your understanding of setInterval(), clearInterval(), and function closures.

You're given a function fn, an array of arguments args, and an interval time t (in milliseconds). Your task is to create a cancellation system that:

1. Immediately calls fn with the provided args
2. Repeatedly calls fn every t milliseconds
3. Returns a cancel function that stops the interval when called

The function should continue executing at regular intervals until the cancel function is invoked. This pattern is commonly used in web development for periodic updates, polling APIs, or creating animated effects that can be stopped on demand.

Example: If fn = (x) => console.log(x), args = ['hello'], and t = 1000, then 'hello' should be logged immediately, then again every 1000ms until cancelled.

Input & Output

example_1.js — Basic Counter

$ Input: fn = (x) => x * 2, args = [4], t = 35, cancelTimeMs = 190

› Output: [{"time": 0, "returned": 8}, {"time": 35, "returned": 8}, {"time": 70, "returned": 8}, {"time": 105, "returned": 8}, {"time": 140, "returned": 8}, {"time": 175, "returned": 8}]

💡 Note: The function immediately executes at t=0, then every 35ms until cancelled at 190ms. Each call returns 4 * 2 = 8.

example_2.js — Quick Cancellation

$ Input: fn = (x1, x2) => x1 + x2, args = [2, 5], t = 30, cancelTimeMs = 50

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

💡 Note: Function executes immediately at t=0 returning 2+5=7, then once more at t=30. Cancelled before third execution at t=60.

example_3.js — Immediate Cancellation

$ Input: fn = (a, b, c) => a + b + c, args = [5, 1, 3], t = 50, cancelTimeMs = 25

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

💡 Note: Function executes only once immediately at t=0 returning 5+1+3=9. Cancelled before first interval execution at t=50.

Visualization

Tap to expand

Understanding the Visualization

Immediate Execution

Function runs immediately at t=0 when cancellable() is called

Interval Setup

setInterval schedules repeated executions every t milliseconds

Regular Execution

Function continues to execute at regular intervals

Cancellation

When cancel function is called, clearInterval stops all future executions

Key Takeaway

🎯 Key Insight: Use closure to capture the interval ID, enabling the cancel function to stop the recurring execution. The immediate call + setInterval pattern is the standard JavaScript approach for cancellable intervals.

Time & Space Complexity

Time Complexity

⏱️

O(1)

All operations (function call, setInterval, clearInterval) are constant time

✓ Linear Growth

Space Complexity

O(1)

Only stores one interval ID, constant space regardless of how many times function executes

✓ Linear Space

Constraints

fn is a JavaScript function
args is a valid JSON array of arguments for fn
1 ≤ t ≤ 1000 (interval time in milliseconds)
0 ≤ cancelTimeMs ≤ 1000 (cancellation time in milliseconds)
The function must be called immediately, then at regular intervals
The returned cancel function must stop all future executions

Asked in

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

The optimal solution uses JavaScript's native setInterval() function combined with closure pattern to capture the interval ID. Call the function immediately, set up the interval, and return a cancel function that calls clearInterval(). This approach is efficient, clean, and follows industry standards for timing-based operations in JavaScript.

Common Approaches

Approach	Time	Space	Notes
✓ Manual Timeout Chain (Naive)	O(1)	O(n)	Use recursive setTimeout calls to simulate interval behavior
SetInterval with Closure (Optimal)	O(1)	O(1)	Use built-in setInterval and closure to capture interval ID for cancellation

Manual Timeout Chain (Naive) — Algorithm Steps

Call the function immediately with provided arguments
Create a recursive function that schedules the next execution
Use setTimeout with the interval delay to schedule next call
Track timeouts in an array to cancel them later
Return a cancel function that clears all pending timeouts

Visualization

Tap to expand

Step-by-Step Walkthrough

Immediate Call

Function is called immediately when cancellable() is invoked

Schedule Next

setTimeout schedules the next function call after t milliseconds

Repeat Chain

Each timeout completion schedules the next one, creating a chain

Cancellation

Cancel function clears all pending timeouts and sets cancelled flag

Code -

solution.c — C

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

typedef struct {
    void (*fn)(void);
    int interval_ms;
    int *cancelled;
} interval_data;

void* interval_thread(void* arg) {
    interval_data* data = (interval_data*)arg;
    
    while (!*(data->cancelled)) {
        usleep(data->interval_ms * 1000); // Convert ms to microseconds
        if (!*(data->cancelled)) {
            data->fn();
        }
    }
    return NULL;
}

void* cancellable(void (*fn)(void), int t) {
    static int cancelled = 0;
    static pthread_t thread;
    
    interval_data* data = malloc(sizeof(interval_data));
    data->fn = fn;
    data->interval_ms = t;
    data->cancelled = &cancelled;
    
    // Call immediately
    fn();
    
    pthread_create(&thread, NULL, interval_thread, data);
    
    return &cancelled;
}

Time & Space Complexity

Time Complexity

⏱️

O(1)

Each function call and timeout setup is constant time

✓ Linear Growth

Space Complexity

O(n)

Need to store references to all timeout IDs for cancellation, where n is number of scheduled calls

⚡ Linearithmic Space

Constraints

fn is a JavaScript function
args is a valid JSON array of arguments for fn
1 ≤ t ≤ 1000 (interval time in milliseconds)
0 ≤ cancelTimeMs ≤ 1000 (cancellation time in milliseconds)
The function must be called immediately, then at regular intervals
The returned cancel function must stop all future executions

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

Manual Timeout Chain (Naive) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler