Increment and decrement in Go - Time & Space Complexity

Time Complexity: Increment and decrement

O(n)

Understanding Time Complexity

Increment and decrement operations change a value by one step. We want to see how these operations affect the time it takes to run a program.

How does the number of increments or decrements grow when we repeat them many times?

Scenario Under Consideration

Analyze the time complexity of the following code snippet.

package main

func countUp(n int) int {
    total := 0
    for i := 0; i < n; i++ {
        total++
    }
    return total
}

This code counts up from zero to n by adding one each time in a loop.

Identify Repeating Operations

Identify the loops, recursion, array traversals that repeat.

• Primary operation: Incrementing the variable total inside the loop.
• How many times: Exactly n times, once per loop cycle.

How Execution Grows With Input

Each time we increase n, the loop runs that many times, doing one increment each time.

Input Size (n)	Approx. Operations
10	10 increments
100	100 increments
1000	1000 increments

Pattern observation: The number of increments grows directly with n. Double n, double the work.

Final Time Complexity

Time Complexity: O(n)

This means the time to finish grows in a straight line with the size of n.

Common Mistake

[X] Wrong: "Incrementing inside a loop is always very fast, so it doesn't affect time much."

[OK] Correct: Even simple increments add up when repeated many times, so the total time depends on how many increments happen.

Interview Connect

Understanding how simple steps like increments add up helps you explain how loops affect program speed. This skill shows you can think about how code grows with input size.

Self-Check

"What if we replaced the increment total++ with a function call inside the loop? How would the time complexity change?"