Problem Description

This problem asks you to create a function createCounter that implements a simple counter with closure functionality in TypeScript.

The function createCounter takes one parameter:

• init: an integer that serves as the initial value of the counter

The function should return an object containing three methods:

1. increment(): Increases the counter's current value by 1 and returns the new value
2. decrement(): Decreases the counter's current value by 1 and returns the new value
3. reset(): Resets the counter back to the original init value and returns it

The key concept being tested here is closures - the returned object's methods need to maintain access to both the current counter value and the original init value even after createCounter has finished executing.

For example, if you create a counter with initial value 5:

• Calling increment() would return 6 (and the counter is now at 6)
• Calling reset() would return 5 (counter goes back to initial value)
• Calling decrement() would return 4 (counter decreases by 1 from 5)

The solution uses a local variable val to track the current counter value, while keeping init accessible for the reset functionality. The prefix increment (++val) and decrement (--val) operators are used to modify the value before returning it.

Intuition

The core challenge is creating a counter that "remembers" its state between function calls. In JavaScript/TypeScript, when a function finishes executing, its local variables are typically destroyed. However, we need our counter to persist its value across multiple method calls.

This naturally leads us to think about closures - a fundamental concept where inner functions retain access to variables from their outer function's scope, even after the outer function has returned.

Here's the thought process:

1. We need to store the current counter value somewhere that persists between calls. Creating a local variable val inside createCounter gives us this storage.

2. We also need to remember the original init value for the reset functionality. Since init is a parameter to createCounter, it remains accessible to all inner functions through closure.

3. The three methods (increment, decrement, reset) need to be returned as part of an object. These methods, defined inside createCounter, will form closures that capture both val and init.

4. For the increment and decrement operations, we use prefix operators (++val and --val) rather than postfix because we want to return the value after modification, not before. The prefix operator modifies first, then returns the new value.

5. The reset operation simply reassigns val to the original init value. The expression val = init both performs the assignment and returns the assigned value, which is exactly what we need.

This pattern of returning an object with methods that close over shared state is a common way to create encapsulated, stateful components in JavaScript/TypeScript without using classes.

Solution Approach

The implementation uses the closure pattern to maintain state across function calls. Let's walk through each part of the solution:

1. Type Definition:

type ReturnObj = {
    increment: () => number;
    decrement: () => number;
    reset: () => number;
};

First, we define a TypeScript type ReturnObj that specifies the structure of the object we'll return. Each method takes no parameters and returns a number.

2. Main Function Structure:

function createCounter(init: number): ReturnObj {
    let val = init;
    // ... methods defined here
}

The createCounter function accepts init as a parameter. We immediately create a local variable val and initialize it with init. This val will serve as our mutable counter state.

3. Method Implementations:

• increment():

  increment() {
      return ++val;
  }

  Uses the prefix increment operator ++val which increases val by 1 and returns the new value. The prefix operator is crucial here - it modifies first, then returns.

• decrement():

  decrement() {
      return --val;
  }

  Similarly uses the prefix decrement operator --val to decrease val by 1 and return the new value.

• reset():

  reset() {
      return (val = init);
  }

  Assigns init back to val and returns the assigned value. The assignment expression itself evaluates to the assigned value, so we can return it directly.

4. Closure Mechanism: When createCounter returns the object with these three methods, each method maintains access to:

• The val variable (current counter state)
• The init parameter (original value for reset)

Even after createCounter finishes executing, these variables remain accessible to the returned methods through JavaScript's closure mechanism. Each call to createCounter creates a new closure with its own independent val and init values, allowing multiple counters to exist simultaneously without interfering with each other.

Example Walkthrough

Let's walk through a concrete example to understand how the closure-based counter works:

Step 1: Create a counter with initial value 10

const counter = createCounter(10);

At this point:

• init = 10 (stored in closure)
• val = 10 (local variable in closure)
• counter now holds an object with three methods

Step 2: Call increment() twice

counter.increment(); // returns 11
counter.increment(); // returns 12

What happens internally:

• First call: ++val changes val from 10 to 11, then returns 11
• Second call: ++val changes val from 11 to 12, then returns 12
• Current state: val = 12, init = 10 (unchanged)

Step 3: Call decrement() once

counter.decrement(); // returns 11

What happens internally:

• --val changes val from 12 to 11, then returns 11
• Current state: val = 11, init = 10

Step 4: Call reset()

counter.reset(); // returns 10

What happens internally:

• val = init assigns 10 back to val and returns 10
• Current state: val = 10, init = 10

Step 5: Continue using the counter

counter.decrement(); // returns 9
counter.decrement(); // returns 8

The counter continues working from the reset value:

• Each call modifies val and returns the new value
• init remains at 10 for future resets

Key Insight: Throughout all these operations, the val and init variables persist in memory because the returned methods have closed over them. Each method call can read and modify val, while init remains constant as our reset reference point.

Solution Implementation

Time and Space Complexity

Time Complexity: O(1) for the createCounter function and O(1) for each method call (increment, decrement, reset).

• The createCounter function performs a constant amount of work: initializing a variable val and returning an object with three methods. This takes O(1) time.
• Each method (increment, decrement, reset) performs a single arithmetic operation or assignment, which executes in constant time O(1).

Space Complexity: O(1)

• The createCounter function creates a closure that stores:
  • One integer variable val to maintain the current counter value
  • One integer parameter init that remains in the closure scope
  • One object with three method references
• The space used is constant regardless of how many times the methods are called or what value is passed as init.
• Each counter instance created by calling createCounter will use O(1) space independently.

Common Pitfalls

1. Global State Contamination

The Python implementation uses global variables (current_value and initial_value), which creates a critical issue: only one counter can exist at a time. Creating a second counter will overwrite the state of the first one.

Problem Example:

counter1 = createCounter(5)
counter2 = createCounter(10)

print(counter1.increment())  # Expected: 6, Actual: 11
print(counter2.increment())  # Expected: 11, Actual: 12

Both counters share the same global state, making them interfere with each other.

Solution: Use closures properly with nested functions to maintain independent state for each counter:

def createCounter(init):
    # Local variable specific to this counter instance
    current_value = init
  
    def increment():
        nonlocal current_value
        current_value += 1
        return current_value
  
    def decrement():
        nonlocal current_value
        current_value -= 1
        return current_value
  
    def reset():
        nonlocal current_value
        current_value = init
        return current_value
  
    # Return a simple object-like structure
    class Counter:
        pass
  
    counter = Counter()
    counter.increment = increment
    counter.decrement = decrement
    counter.reset = reset
  
    return counter

2. Using Postfix Instead of Prefix Operators (TypeScript)

A common mistake is using postfix operators (val++ or val--) instead of prefix operators.

Problem Example:

increment() {
    return val++;  // Wrong: returns old value, then increments
}

This would return the value before incrementing, not after.

Solution: Always use prefix operators when you need the updated value immediately:

increment() {
    return ++val;  // Correct: increments first, then returns
}

3. Mutating the Init Parameter

Some might accidentally modify the init parameter itself instead of maintaining a separate counter variable.

Problem Example:

function createCounter(init: number): ReturnObj {
    return {
        increment() {
            return ++init;  // Wrong: modifying parameter directly
        },
        decrement() {
            return --init;
        },
        reset() {
            return init;  // This won't work as expected
        }
    };
}

The reset function becomes useless since init has been modified.

Solution: Always create a separate variable for the current value:

let val = init;  // Separate variable for current state