Timers interview questions

Implement a setInterval wrapper that returns a function which stops the interval when invoked.

Implement a setTimeout wrapper that returns a function you can call to cancel the pending callback.

Build a button that copies text to the clipboard and shows a transient copied confirmation.

Build a countdown timer that ticks down from a start time and can start, pause, and reset.

Implement a function that delays invoking another function until a specified period of inactivity has passed.

Implement a function that returns a promise resolving after the specified number of milliseconds.

Implement a cache whose entries expire a fixed time after their last access, not after being set.

Build a toast that appears on trigger and auto-dismisses after a few seconds, with manual close.

Build a traffic light that cycles green to yellow to red on a timer and loops indefinitely.

Buffer bursty streamed text and emit it one character at a time at a steady cadence, with flush and stop controls.

Build an analog clock whose hour, minute, and second hands move smoothly to reflect the current time.

Build an analytics client that queues tracked events, flushes them in batches, and retries failed sends with backoff.

Implement an async debounce that resolves only the newest call and discards the results of superseded ones.

Implement an async memoize that caches results by key for a TTL and coalesces concurrent calls for the same key.

Build a carousel that auto-advances, wraps, pauses on hover or focus, and supports manual controls.

Buffer events and flush them in batches when a size threshold or a max-wait timer is reached.

Extend debounce with cancel and flush methods to abort or immediately invoke pending calls.

Extend debounce with a maxWait option that forces a call after a maximum delay even under constant activity.

Build a 7-segment style digital clock that updates to display the current time.

Build a grid of cells that light up on click and then deactivate one by one in the reverse order they were activated.

Build a memory card-matching game where players flip cards to find matching pairs.

Build a list of progress bars that fill in sequence, each one starting only after the previous bar finishes.

Implement a function that races a promise against a timer and rejects if the promise doesn't settle in time.

Wrap an async call with retries, backoff, and a per-attempt timeout so transient failures recover.

Implement an interval helper that exposes start, pause, and resume controls while preserving elapsed progress.

Build the classic snake game on a grid with keyboard control, growth on eating, and game over.

Return cached data instantly, serving stale values while revalidating them in the background.

Build a stopwatch widget that measures elapsed time with start, stop, and reset controls.

Implement a function that limits how often a wrapped function can be invoked within a time window.

Extend throttle with cancel and flush methods plus leading and trailing edge options.

Implement a hook that drives a countdown timer with start, pause, and reset controls.

Implement a hook that animates a number to a target over a fixed duration, independent of the display's framerate.

Implement a hook that returns a debounced version of a value, updating only after a quiet period.

Implement a hook that flags the user as idle after a period without keyboard, pointer, or scroll activity.

Implement a hook that runs a callback on a timer with a configurable, pauseable delay.

Implement a useState variant that defers commits to the next animation frame, so rapid updates coalesce to at most one render per frame.

Implement a hook that formats a timestamp as relative time like "3 minutes ago" and refreshes itself as time passes.

Implement a hook that runs a callback after a given delay and cleans up when the component unmounts.

Build the arcade game where moles randomly appear in a grid and players click them to score.

Run a queue of tasks in time slices, yielding control between them so the main thread stays responsive.

Build progress bars that fill concurrently up to three at a time, and let the user pause and resume each one.

Build Tetris with falling tetrominoes, rotation, line clears, and scoring.