Instance states (running, stopped, terminated) in GCP - Time & Space Complexity

Time Complexity: Instance states (running, stopped, terminated)

O(n)

Understanding Time Complexity

We want to understand how the time to check or change instance states grows as we handle more instances.

How does the number of instances affect the work done by the system?

Scenario Under Consideration

Analyze the time complexity of the following operation sequence.

# List all instances in a project
instances = compute.instances().list(project=project_id, zone=zone).execute()

# For each instance, check its state
for instance in instances['items']:
    state = instance['status']
    if state == 'TERMINATED':
        # Optionally delete or ignore
        pass
    elif state == 'STOPPED':
        # Optionally start instance
        pass
    elif state == 'RUNNING':
        # Optionally stop instance
        pass

This code lists all instances and checks their current state to decide what action to take.

Identify Repeating Operations

Identify the API calls, resource provisioning, data transfers that repeat.

• Primary operation: Checking each instance's state via the list API and iterating over each instance.
• How many times: Once per instance in the project and zone.

How Execution Grows With Input

As the number of instances grows, the number of state checks grows at the same rate.

Input Size (n)	Approx. Api Calls/Operations
10	10 state checks
100	100 state checks
1000	1000 state checks

Pattern observation: The work grows linearly with the number of instances.

Final Time Complexity

Time Complexity: O(n)

This means the time to check or act on instance states grows directly with how many instances there are.

Common Mistake

[X] Wrong: "Checking all instance states takes the same time no matter how many instances exist."

[OK] Correct: Each instance adds one more check, so more instances mean more work and longer time.

Interview Connect

Understanding how operations scale with instance count helps you design efficient cloud management scripts and shows you think about system behavior as it grows.

Self-Check

"What if we batch instance state checks instead of checking one by one? How would the time complexity change?"