Asteroid Collision - Practice Coding Problems

Asteroid Collision - Problem

Imagine a row of asteroids floating in space, each with a specific size and direction. In this cosmic simulation, we need to determine what happens when these space rocks collide!

You're given an array asteroids where:

Positive values represent asteroids moving right →
Negative values represent asteroids moving left ←
The absolute value represents the asteroid's size
All asteroids move at the same speed

Collision Rules:

When two asteroids meet, the smaller one explodes 💥
If both asteroids are the same size, both explode 💥💥
Asteroids moving in the same direction will never collide

Goal: Return the final state of asteroids after all collisions have occurred.

Example: [5, 10, -5] → The asteroid of size 10 moving right collides with size 5 moving left. Size 10 survives, so result is [5, 10].

Input & Output

example_1.py — Basic Collision

$ Input: [5, 10, -5]

› Output: [5, 10]

💡 Note: The asteroid of size 10 moving right collides with size 5 moving left. Since 10 > 5, the left-moving asteroid explodes and we're left with [5, 10].

example_2.py — Multiple Collisions

$ Input: [8, -8]

› Output: []

💡 Note: The asteroid of size 8 moving right collides with size 8 moving left. Since they're equal size, both explode, leaving an empty array.

example_3.py — Chain Reaction

$ Input: [10, 2, -5]

› Output: [10]

💡 Note: Size 2 (right) meets size 5 (left): 5 wins. Then size 10 (right) meets size 5 (left): 10 wins. Final result: [10].

Visualization

Tap to expand

Understanding the Visualization

Setup Stack

Initialize empty stack to hold surviving right-moving asteroids

Process Right-Movers

Add right-moving asteroids to stack - they're safe for now

Collision Time!

Left-moving asteroid arrives and battles stack contents

Chain Reaction

Continue collisions until no more conflicts exist

Final State

Stack contains all surviving asteroids in correct order

Key Takeaway

🎯 Key Insight: Stack naturally models the collision process - right-moving asteroids wait in stack until left-moving ones arrive to challenge them!

Time & Space Complexity

Time Complexity

⏱️

O(n)

Each asteroid is pushed and popped from stack at most once, giving us linear time

✓ Linear Growth

Space Complexity

O(n)

Stack can hold up to n asteroids in worst case (all moving right)

⚡ Linearithmic Space

Constraints

2 ≤ asteroids.length ≤ 10⁴
-1000 ≤ asteroids[i] ≤ 1000
asteroids[i] ≠ 0 (no stationary asteroids)

Asked in

a Amazon 45 G Google 32 f Meta 28 ⊞ Microsoft 22 Apple 18

The optimal solution uses a stack-based simulation approach. We iterate through asteroids once, using the stack to track right-moving asteroids. When encountering a left-moving asteroid, we resolve all collisions with the stack before proceeding. This achieves O(n) time complexity with O(n) space, making it significantly more efficient than the brute force O(n²) approach.

Common Approaches

Approach	Time	Space	Notes
✓ Simulation with Repeated Scanning	O(n²)	O(1)	Repeatedly scan the array and simulate collisions until no more occur
Stack-Based Simulation (Optimal)	O(n)	O(n)	Use a stack to efficiently handle collisions in a single pass

Simulation with Repeated Scanning — Algorithm Steps

Scan the array from left to right looking for collision patterns
When we find a positive followed by a negative, simulate collision
Remove exploded asteroids and restart the scan
Repeat until no more collisions occur
Return the remaining asteroids

Visualization

Tap to expand

Step-by-Step Walkthrough

Initial State

Start with array [5, 10, -5, 4, -3]

Find Collision

Scan finds 10 (right) meets -5 (left)

Resolve

10 > 5, so -5 explodes: [5, 10, 4, -3]

Scan Again

Find 4 (right) meets -3 (left)

Final

4 > 3, so -3 explodes: [5, 10, 4]

Code -

solution.c — C

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

int* asteroidCollision(int* asteroids, int asteroidsSize, int* returnSize) {
    int* result = (int*)malloc(asteroidsSize * sizeof(int));
    int size = asteroidsSize;
    
    for (int i = 0; i < size; i++) {
        result[i] = asteroids[i];
    }
    
    int collisionOccurred = 1;
    while (collisionOccurred) {
        collisionOccurred = 0;
        
        for (int i = 0; i < size - 1; i++) {
            if (result[i] > 0 && result[i + 1] < 0) {
                int leftSize = result[i];
                int rightSize = abs(result[i + 1]);
                
                if (leftSize > rightSize) {
                    for (int j = i + 1; j < size - 1; j++) {
                        result[j] = result[j + 1];
                    }
                    size--;
                } else if (leftSize < rightSize) {
                    for (int j = i; j < size - 1; j++) {
                        result[j] = result[j + 1];
                    }
                    size--;
                } else {
                    for (int j = i; j < size - 2; j++) {
                        result[j] = result[j + 2];
                    }
                    size -= 2;
                }
                
                collisionOccurred = 1;
                break;
            }
        }
    }
    
    *returnSize = size;
    return result;
}

int main() {
    int asteroids[] = {5, 10, -5};
    int size = 3;
    int returnSize;
    
    int* result = asteroidCollision(asteroids, size, &returnSize);
    
    printf("[");
    for (int i = 0; i < returnSize; i++) {
        printf("%d", result[i]);
        if (i < returnSize - 1) printf(",");
    }
    printf("]\n");
    
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

In worst case, we might need to scan the array n times, and each scan takes O(n) time

⚠ Quadratic Growth

Space Complexity

O(1)

Only using a few variables to track collision state, modifying array in-place

✓ Linear Space

Constraints

2 ≤ asteroids.length ≤ 10⁴
-1000 ≤ asteroids[i] ≤ 1000
asteroids[i] ≠ 0 (no stationary asteroids)

89.6K Views

High Frequency

~18 min Avg. Time

2.8K 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

Simulation with Repeated Scanning — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler