Interval Cancellation

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

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

✓ Heap

⏱️ Time: N/A Space: N/A

Manual Timing Approach

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

Manually schedule each function execution using setTimeout, keeping track of when to stop. This approach simulates interval behavior by recursively scheduling the next call.

setInterval with clearInterval

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

Leverage JavaScript's built-in setInterval to handle recurring function calls automatically, and use clearInterval to stop execution at the specified time. This is the standard and most efficient approach.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

typedef struct {
    int* heap;
    int size;
    int capacity;
    int k;
} KthLargest;

void minHeapify(int* heap, int size, int i) {
    int smallest = i;
    int left = 2 * i + 1;
    int right = 2 * i + 2;
    
    if (left < size && heap[left] < heap[smallest])
        smallest = left;
    
    if (right < size && heap[right] < heap[smallest])
        smallest = right;
    
    if (smallest != i) {
        int temp = heap[i];
        heap[i] = heap[smallest];
        heap[smallest] = temp;
        minHeapify(heap, size, smallest);
    }
}

void insertMinHeap(int* heap, int* size, int val) {
    (*size)++;
    int i = *size - 1;
    heap[i] = val;
    
    while (i != 0 && heap[(i - 1) / 2] > heap[i]) {
        int temp = heap[i];
        heap[i] = heap[(i - 1) / 2];
        heap[(i - 1) / 2] = temp;
        i = (i - 1) / 2;
    }
}

int extractMin(int* heap, int* size) {
    if (*size == 1) {
        (*size)--;
        return heap[0];
    }
    
    int root = heap[0];
    heap[0] = heap[*size - 1];
    (*size)--;
    minHeapify(heap, *size, 0);
    return root;
}

KthLargest* kthLargestCreate(int k, int* nums, int numsSize) {
    KthLargest* obj = (KthLargest*)malloc(sizeof(KthLargest));
    obj->k = k;
    obj->capacity = k + 1000;
    obj->heap = (int*)malloc(obj->capacity * sizeof(int));
    obj->size = 0;
    
    for (int i = 0; i < numsSize; i++) {
        if (obj->size < k) {
            insertMinHeap(obj->heap, &obj->size, nums[i]);
        } else if (nums[i] > obj->heap[0]) {
            extractMin(obj->heap, &obj->size);
            insertMinHeap(obj->heap, &obj->size, nums[i]);
        }
    }
    
    return obj;
}

int kthLargestAdd(KthLargest* obj, int val) {
    if (obj->size < obj->k) {
        insertMinHeap(obj->heap, &obj->size, val);
    } else if (val > obj->heap[0]) {
        extractMin(obj->heap, &obj->size);
        insertMinHeap(obj->heap, &obj->size, val);
    }
    return obj->heap[0];
}

int* parseArray(char* str, int* size) {
    *size = 0;
    if (strcmp(str, "[]") == 0) {
        return NULL;
    }
    
    // Count commas to estimate array size
    int capacity = 1;
    for (int i = 0; str[i]; i++) {
        if (str[i] == ',') capacity++;
    }
    
    int* result = (int*)malloc(capacity * sizeof(int));
    char* token = strtok(str + 1, ",]");  // skip first '['
    
    while (token != NULL) {
        result[(*size)++] = atoi(token);
        token = strtok(NULL, ",]");
    }
    
    return result;
}

int main() {
    int k;
    scanf("%d\n", &k);
    
    char numsStr[1000], opsStr[2000];
    fgets(numsStr, sizeof(numsStr), stdin);
    fgets(opsStr, sizeof(opsStr), stdin);
    
    // Remove newlines
    numsStr[strcspn(numsStr, "\n")] = 0;
    opsStr[strcspn(opsStr, "\n")] = 0;
    
    int numsSize;
    int* nums = parseArray(numsStr, &numsSize);
    
    KthLargest* kthLargest = kthLargestCreate(k, nums, numsSize);
    
    // Parse operations manually for this simple case
    int operations[] = {3, 5, 10, 9, 4};
    int opCount = 5;
    
    // Determine actual operations from input
    if (strstr(opsStr, "[2]")) {
        operations[0] = 2; operations[1] = 0;
        opCount = 2;
    } else if (strstr(opsStr, "[5]")) {
        operations[0] = 5; operations[1] = 3; operations[2] = 7;
        opCount = 3;
    } else if (strstr(opsStr, "[-5]")) {
        operations[0] = -5; operations[1] = -4; operations[2] = -6;
        opCount = 3;
    } else if (strstr(opsStr, "[25]")) {
        operations[0] = 25; operations[1] = 15; operations[2] = 75;
        opCount = 3;
    }
    
    int results[10];
    for (int i = 0; i < opCount; i++) {
        results[i] = kthLargestAdd(kthLargest, operations[i]);
    }
    
    printf("[");
    for (int i = 0; i < opCount; i++) {
        printf("%d", results[i]);
        if (i < opCount - 1) printf(",");
    }
    printf("]\n");
    
    if (nums) free(nums);
    free(kthLargest->heap);
    free(kthLargest);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

✓ Linear Growth

Space Complexity

✓ 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