Custom Interval - Practice Coding Problems

Custom Interval - Problem

JavaScript Medium

Custom Interval System

You need to implement a custom interval system that schedules function execution with dynamically increasing delays. Unlike the standard setInterval which uses fixed delays, your custom interval should calculate delays using the formula:

next_delay = delay + period × count

Where count starts at 0 and increments after each execution.

Implement two functions:

1. customInterval(fn, delay, period) - Returns an ID and schedules fn to execute with increasing delays
2. customClearInterval(id) - Stops the interval identified by id

Example Timeline:
• First execution: after delay + period × 0 = delay ms
• Second execution: after delay + period × 1 = delay + period ms
• Third execution: after delay + period × 2 = delay + 2×period ms

This creates a linear progression of delays, useful for implementing backoff strategies, progressive polling, or adaptive scheduling systems.

Input & Output

basic_interval.js — JavaScript

$ Input: fn = () => console.log('executed'), delay = 100, period = 50

› Output: Executions at: 100ms, 250ms, 450ms, 700ms, ...

💡 Note: First execution after 100ms, then each subsequent execution has 50ms more delay (100+50×1=150ms, 100+50×2=200ms, etc.)

clear_interval.js — JavaScript

$ Input: id = customInterval(() => console.log('test'), 200, 100); customClearInterval(id);

› Output: No executions (cleared before first execution)

💡 Note: The interval is cleared before the first execution at 200ms, so nothing gets printed

multiple_intervals.js — JavaScript

$ Input: Two intervals: (fn1, 100, 0) and (fn2, 50, 100)

› Output: fn1 executions: 100ms, 200ms, 300ms... | fn2 executions: 50ms, 250ms, 550ms...

💡 Note: First interval has constant 100ms delay (period=0), second has increasing delays: 50, 150, 250, 350ms...

Constraints

1 ≤ delay ≤ 10⁴ (delay in milliseconds)
0 ≤ period ≤ 10³ (period increment in milliseconds)
Function fn will not throw exceptions
Maximum 100 concurrent intervals
IDs must be unique and persistent until cleared

Visualization

Tap to expand

Understanding the Visualization

Initial Setup

Create interval with delay=100ms, period=50ms

First Execution

Execute after 100ms (100 + 50×0)

Second Execution

Execute after 150ms (100 + 50×1)

Third Execution

Execute after 200ms (100 + 50×2)

Pattern Emerges

Each execution has progressively longer delay

Key Takeaway

🎯 Key Insight: Instead of polling continuously, let each interval calculate and schedule its own next execution using recursive setTimeout calls. This creates precise timing with minimal system overhead.

Asked in

G Google 35 f Meta 28 a Amazon 22 ⊞ Microsoft 18

The optimal solution uses recursive setTimeout calls with dynamically calculated delays. Each interval manages its own schedule using the formula delay + period × count, eliminating the need for continuous polling and providing precise, efficient timing with O(1) time complexity per operation.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Polling Approach)	O(n)	O(n)	Use setInterval to check every millisecond if functions should execute
Optimal Recursive setTimeout	O(1)	O(n)	Use recursive setTimeout with calculated delays for precise, efficient scheduling

Brute Force (Polling Approach) — Algorithm Steps

Store intervals with start times and execution counts
Use setInterval to check every 1ms if any function should execute
Calculate elapsed time and compare with formula result
Execute functions when their time comes
Clear intervals by removing from storage

Visualization

Tap to expand

Step-by-Step Walkthrough

Store Intervals

Add new interval to global storage with metadata

Continuous Polling

Check every 1ms if any interval should execute

Time Calculation

For each interval, calculate if enough time has passed

Execute & Update

Run function and increment count when time matches

Code -

solution.c — C

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

#define MAX_INTERVALS 100
#define ID_LENGTH 9

typedef struct {
    char id[ID_LENGTH];
    void (*fn)(void);
    int delay;
    int period;
    long long start_time;
    int count;
    long long last_execution;
    int active;
} IntervalData;

typedef struct {
    IntervalData intervals[MAX_INTERVALS];
    int interval_count;
    pthread_t poller_thread;
    int running;
    pthread_mutex_t mutex;
} CustomIntervalBruteForce;

CustomIntervalBruteForce interval_manager;

long long current_time_ms() {
    struct timespec ts;
    clock_gettime(CLOCK_MONOTONIC, &ts);
    return ts.tv_sec * 1000 + ts.tv_nsec / 1000000;
}

void generate_id(char* id) {
    const char chars[] = "abcdefghijklmnopqrstuvwxyz0123456789";
    for (int i = 0; i < ID_LENGTH - 1; i++) {
        id[i] = chars[rand() % (sizeof(chars) - 1)];
    }
    id[ID_LENGTH - 1] = '\0';
}

void* poll_intervals(void* arg) {
    while (interval_manager.running) {
        long long now = current_time_ms();
        
        pthread_mutex_lock(&interval_manager.mutex);
        for (int i = 0; i < interval_manager.interval_count; i++) {
            IntervalData* data = &interval_manager.intervals[i];
            if (!data->active) continue;
            
            long long expected_time = data->delay + data->period * data->count;
            long long elapsed = now - data->start_time - data->last_execution;
            
            if (elapsed >= expected_time) {
                data->fn();
                data->last_execution = now - data->start_time;
                data->count++;
            }
        }
        pthread_mutex_unlock(&interval_manager.mutex);
        
        usleep(1000); // Sleep for 1ms
    }
    return NULL;
}

char* custom_interval(void (*fn)(void), int delay, int period) {
    static char id[ID_LENGTH];
    generate_id(id);
    
    pthread_mutex_lock(&interval_manager.mutex);
    if (interval_manager.interval_count < MAX_INTERVALS) {
        IntervalData* data = &interval_manager.intervals[interval_manager.interval_count];
        strcpy(data->id, id);
        data->fn = fn;
        data->delay = delay;
        data->period = period;
        data->start_time = current_time_ms();
        data->count = 0;
        data->last_execution = 0;
        data->active = 1;
        interval_manager.interval_count++;
    }
    pthread_mutex_unlock(&interval_manager.mutex);
    
    return id;
}

void custom_clear_interval(const char* id) {
    pthread_mutex_lock(&interval_manager.mutex);
    for (int i = 0; i < interval_manager.interval_count; i++) {
        if (strcmp(interval_manager.intervals[i].id, id) == 0) {
            interval_manager.intervals[i].active = 0;
            // Shift remaining intervals
            for (int j = i; j < interval_manager.interval_count - 1; j++) {
                interval_manager.intervals[j] = interval_manager.intervals[j + 1];
            }
            interval_manager.interval_count--;
            break;
        }
    }
    pthread_mutex_unlock(&interval_manager.mutex);
}

void init_interval_manager() {
    interval_manager.interval_count = 0;
    interval_manager.running = 1;
    pthread_mutex_init(&interval_manager.mutex, NULL);
    pthread_create(&interval_manager.poller_thread, NULL, poll_intervals, NULL);
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Constant polling requires checking n active intervals every millisecond

✓ Linear Growth

Space Complexity

O(n)

Storage for n active intervals with their metadata

⚡ Linearithmic Space

34.7K Views

Medium-High 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

Brute Force (Polling Approach) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler