Ant on the Boundary - Practice Coding Problems

Ant on the Boundary - Problem

An adventurous ant is exploring a one-dimensional world where it starts at position 0 (the boundary). The ant follows a sequence of movement instructions, where each instruction tells it to move left or right by a certain number of units.

Given an array nums of non-zero integers representing movement instructions:

If nums[i] > 0, the ant moves right by nums[i] units
If nums[i] < 0, the ant moves left by |nums[i]| units

Goal: Count how many times the ant returns to the boundary (position 0) after completing each movement instruction.

Note: We only check if the ant is at the boundary after each complete movement. If the ant crosses the boundary during a movement, it doesn't count as a return.

Input & Output

example_1.py — Basic Movement

$ Input: nums = [2, 3, -5]

› Output: 1

💡 Note: Start at 0 → move right 2 (pos: 2) → move right 3 (pos: 5) → move left 5 (pos: 0). The ant returns to boundary once.

example_2.py — Multiple Returns

$ Input: nums = [3, -3, 4, -4]

› Output: 2

💡 Note: Start at 0 → pos: 3 → pos: 0 (return 1) → pos: 4 → pos: 0 (return 2). The ant returns to boundary twice.

example_3.py — No Returns

$ Input: nums = [1, 2, 3]

› Output: 0

💡 Note: Start at 0 → pos: 1 → pos: 3 → pos: 6. The ant never returns to the boundary.

Visualization

Tap to expand

Understanding the Visualization

Start

Ant starts at position 0 (boundary)

Move

Ant moves according to each instruction

Check

Count when ant returns to position 0

Continue

Process all movements and return total count

Key Takeaway

🎯 Key Insight: Using prefix sum eliminates the need to recalculate position from scratch at each step, reducing time complexity from O(n²) to O(n).

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through the array, processing each element once

✓ Linear Growth

Space Complexity

O(1)

Only using two variables: position and count

✓ Linear Space

Constraints

1 ≤ nums.length ≤ 10⁴
-50 ≤ nums[i] ≤ 50
nums[i] ≠ 0 (no zero movements)

Asked in

G Google 15 a Amazon 12 ⊞ Microsoft 8 f Meta 6

The optimal solution uses a prefix sum approach with O(n) time and O(1) space. We maintain a running total of the ant's position and increment our counter each time the position equals zero, indicating a return to the boundary.

Common Approaches

Approach	Time	Space	Notes
✓ Prefix Sum (Optimal)	O(n)	O(1)	Track running position and count boundary returns in one pass
Brute Force (Recalculate Position)	O(n²)	O(1)	Recalculate ant's position from beginning for each step

Prefix Sum (Optimal) — Algorithm Steps

Initialize position = 0 and count = 0
For each movement in nums:
Add movement to current position
If position equals 0, increment count
Return count

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

position = 0, count = 0

Process each move

Add movement to current position

Check boundary

If position = 0, increment count

Code -

solution.c — C

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

int solution(int* nums, int n) {
    int position = 0;
    int count = 0;
    
    for (int i = 0; i < n; i++) {
        position += nums[i];
        if (position == 0) {
            count++;
        }
    }
    
    return count;
}

int main() {
    int n;
    scanf("%d", &n);
    int* nums = (int*)malloc(n * sizeof(int));
    for (int i = 0; i < n; i++) {
        scanf("%d", &nums[i]);
    }
    printf("%d\n", solution(nums, n));
    free(nums);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through the array, processing each element once

✓ Linear Growth

Space Complexity

O(1)

Only using two variables: position and count

✓ Linear Space

Constraints

1 ≤ nums.length ≤ 10⁴
-50 ≤ nums[i] ≤ 50
nums[i] ≠ 0 (no zero movements)

25.4K Views

Medium Frequency

~12 min Avg. Time

847 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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Prefix Sum (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler