Counter II - Practice Coding Problems

Counter II - Problem

JavaScript Easy

Write a function createCounter that accepts an initial integer init and returns an object with three functions.

The three functions are:

increment() increases the current value by 1 and then returns it.
decrement() reduces the current value by 1 and then returns it.
reset() sets the current value to init and then returns it.

Input & Output

Example 1 — Basic Counter Operations

$ Input: init = 5, calls = ["increment", "increment", "decrement", "reset", "reset"]

› Output: [6,7,6,5,5]

💡 Note: Starting with 5: increment() → 6, increment() → 7, decrement() → 6, reset() → 5, reset() → 5

Example 2 — Starting from Zero

$ Input: init = 0, calls = ["increment", "decrement", "reset"]

› Output: [1,-1,0]

💡 Note: Starting with 0: increment() → 1, decrement() → 0, then decrement() → -1, reset() → 0

Example 3 — Negative Initial Value

$ Input: init = -2, calls = ["reset", "increment", "decrement"]

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

💡 Note: Starting with -2: reset() → -2, increment() → -1, decrement() → -2

Constraints

-1000 ≤ init ≤ 1000
At most 1000 calls will be made to increment, decrement and reset

Visualization

Tap to expand

Understanding the Visualization

Input

Initial value init=5 and sequence of method calls

Process

Counter object tracks current value and responds to increment/decrement/reset

Output

Array of return values from each method call

Key Takeaway

🎯 Key Insight: Use closures or classes to create persistent state between method calls

Asked in

G Google 15 f Facebook 12

The key insight is to use closures or classes to maintain state between function calls. The optimal approach uses JavaScript closures to encapsulate the initial and current values, returning an object with methods that operate on shared state. Time: O(1) per operation, Space: O(1) for state storage.

Common Approaches

Approach	Time	Space	Notes
✓ Closure with Object Methods	O(1)	O(1)	Use JavaScript closure to maintain state with object methods
Class-Based Implementation	O(1)	O(1)	Use class/object to encapsulate counter state and methods

Closure with Object Methods — Algorithm Steps

Store init value and current value in closure
Return object with increment, decrement, reset methods
Each method modifies current value and returns it

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Create counter with init=5, current=5

Operations

Call increment(), decrement(), reset() methods

State Changes

Track how current value changes with each call

Code -

solution.c — C

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

typedef struct {
    int init;
    int current;
} Counter;

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

int increment(Counter* counter) {
    counter->current += 1;
    return counter->current;
}

int decrement(Counter* counter) {
    counter->current -= 1;
    return counter->current;
}

int reset(Counter* counter) {
    counter->current = counter->init;
    return counter->current;
}

int main() {
    int init;
    scanf("%d", &init);
    
    Counter* counter = solution(init);
    int result[5];
    result[0] = increment(counter);
    result[1] = increment(counter);
    result[2] = decrement(counter);
    result[3] = reset(counter);
    result[4] = reset(counter);
    
    printf("[");
    for (int i = 0; i < 5; i++) {
        printf("%d", result[i]);
        if (i < 4) printf(",");
    }
    printf("]\n");
    
    free(counter);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(1)

Each method performs constant time operations

✓ Linear Growth

Space Complexity

O(1)

Only stores two integer variables in closure

✓ Linear Space

23.4K Views

Medium Frequency

~10 min Avg. Time

876 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

Closure with Object Methods — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler