Counter - Practice Coding Problems

Counter - Problem

JavaScript Easy

Given an integer n, return a counter function. This counter function initially returns n and then returns 1 more than the previous value every subsequent time it is called (n, n + 1, n + 2, etc).

The counter function should maintain its internal state between calls and increment the value each time it's invoked.

Input & Output

Example 1 — Positive Counter

$ Input: n = 10

› Output: [10, 11, 12]

💡 Note: counter() returns 10, then counter() returns 11, then counter() returns 12. Each call increments the internal state.

Example 2 — Negative Counter

$ Input: n = -2

› Output: [-2, -1, 0]

💡 Note: counter() returns -2, then counter() returns -1, then counter() returns 0. Works with negative starting values.

Example 3 — Zero Counter

$ Input: n = 0

› Output: [0, 1, 2]

💡 Note: counter() returns 0, then counter() returns 1, then counter() returns 2. Starting from zero and incrementing normally.

Constraints

-1000 ≤ n ≤ 1000
At most 1000 calls will be made to counter()

Visualization

Tap to expand

Understanding the Visualization

Input

Initial value n = 10

Process

Create counter function using closure

Output

Each call returns current value then increments

Key Takeaway

🎯 Key Insight: Closures allow functions to remember and modify variables from their creation scope, enabling persistent state between calls

Asked in

G Google 15 f Meta 12 a Amazon 8

The key insight is using JavaScript closures to maintain state between function calls. The counter function captures the initial value n in its closure scope and uses the post-increment operator to return the current value while incrementing for the next call. Best approach uses arrow function syntax: (n) => () => n++. Time: O(1), Space: O(1)

Common Approaches

Approach	Time	Space	Notes
✓ Basic Closure Implementation	O(1)	O(1)	Use JavaScript closure to maintain counter state
Arrow Function Closure	O(1)	O(1)	Concise arrow function implementation using closure

Basic Closure Implementation — Algorithm Steps

Create outer function that takes initial value n
Define inner function that returns current value and increments
Return the inner function to caller

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Counter function created with n=10

First Call

Returns 10, increments internal state to 11

Subsequent Calls

Returns 11, then 12, maintaining state

Code -

solution.c — C

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

typedef struct {
    int count;
} Counter;

Counter* solution(int n) {
    Counter* counter = (Counter*)malloc(sizeof(Counter));
    counter->count = n;
    return counter;
}

int call_counter(Counter* counter) {
    return counter->count++;
}

int main() {
    int n;
    scanf("%d", &n);
    
    Counter* counter = solution(n);
    printf("[");
    for (int i = 0; i < 3; i++) {
        printf("%d", call_counter(counter));
        if (i < 2) printf(",");
    }
    printf("]\n");
    
    free(counter);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(1)

Each function call performs constant time operations

✓ Linear Growth

Space Complexity

O(1)

Only stores one variable in closure scope

✓ Linear Space

98.0K Views

High Frequency

~5 min Avg. Time

2.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

Constraints

Visualization

Related Problems

Common Approaches

Basic Closure Implementation — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler