Counter II - Practice Coding Problems

Counter II - Problem

JavaScript Easy

Imagine you have a digital counter with buttons to increment, decrement, and reset. Your task is to create a JavaScript function that simulates this behavior!

Write a function createCounter that accepts an initial integer init. It should return an object with three functions:

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

This problem tests your understanding of closures, object methods, and state management in JavaScript. The counter should maintain its state between function calls and remember the original initialization value.

Example: If you create a counter with init = 5, calling increment() returns 6, decrement() returns 5, and reset() returns 5.

Input & Output

example_1.js — Basic Operations

$ Input: init = 5 counter.increment() counter.reset() counter.decrement()

› Output: [6, 5, 4]

💡 Note: Starting with 5: increment gives 6, reset returns to 5, decrement gives 4

example_2.js — Negative Initial Value

$ Input: init = 0 counter.increment() counter.increment() counter.decrement() counter.reset()

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

💡 Note: Starting with 0: two increments reach 2, decrement gives 1, reset returns to 0

example_3.js — Multiple Resets

$ Input: init = 1 counter.increment() counter.increment() counter.increment() counter.reset() counter.reset() counter.increment()

› Output: [2, 3, 4, 1, 1, 2]

💡 Note: Multiple operations showing that reset always returns to the original init value

Constraints

-1000 ≤ init ≤ 1000
At most 1000 calls will be made to increment, decrement and reset
All operations should return the updated value

Visualization

Tap to expand

Understanding the Visualization

Initialization

Counter is created with init=5, both initial and current values are set to 5

Increment Operation

Current value increases to 6, initial value remains 5 for future resets

Reset Operation

Current value is restored to the initial value (5)

Decrement Operation

Current value decreases to 4, demonstrating independent state management

Key Takeaway

🎯 Key Insight: JavaScript closures create a private scope that perfectly encapsulates state while providing controlled access through methods

Asked in

f Meta 25 G Google 20 a Amazon 15 ⊞ Microsoft 12

The optimal solution uses JavaScript closures to create a private scope that maintains both the initial value and current state. Each method has access to these variables through closure, enabling O(1) operations while preserving encapsulation and state persistence.

Common Approaches

Approach	Time	Space	Notes
✓ Basic Closure Implementation	O(1)	O(1)	Simple closure-based counter with straightforward state management

Basic Closure Implementation — Algorithm Steps

Create a function that accepts initial value
Declare a current value variable inside the function
Return an object with three methods
Each method updates and returns the current value

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Create counter with init=5, current=5

Increment

current becomes 6, return 6

Reset

current becomes init (5), return 5

Decrement

current becomes 4, return 4

Code -

solution.c — C

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

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

typedef struct {
    CounterData* data;
    int (*increment)(struct Counter*);
    int (*decrement)(struct Counter*);
    int (*reset)(struct Counter*);
} Counter;

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

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

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

Counter* createCounter(int init) {
    Counter* counter = malloc(sizeof(Counter));
    counter->data = malloc(sizeof(CounterData));
    counter->data->current = init;
    counter->data->init = init;
    counter->increment = increment;
    counter->decrement = decrement;
    counter->reset = reset;
    return counter;
}

int main() {
    Counter* counter = createCounter(5);
    printf("%d\n", counter->increment(counter)); // 6
    printf("%d\n", counter->reset(counter));     // 5
    printf("%d\n", counter->decrement(counter)); // 4
    free(counter->data);
    free(counter);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(1)

Each operation (increment, decrement, reset) takes constant time

✓ Linear Growth

Space Complexity

O(1)

Only stores two integers: initial value and current value

✓ Linear Space

28.7K Views

Medium Frequency

~12 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

Basic Closure Implementation — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler