Asteroid Collision

Asteroid Collision - Problem

We are given an array asteroids of integers representing asteroids in a row. The indices represent their relative position in space.

For each asteroid, the absolute value represents its size, and the sign represents its direction (positive meaning right, negative meaning left). Each asteroid moves at the same speed.

Find out the state of the asteroids after all collisions. If two asteroids meet, the smaller one will explode. If both are the same size, both will explode. Two asteroids moving in the same direction will never meet.

Input & Output

Example 1 — Basic Collision

$ Input: asteroids = [5,10,-5]

› Output: [5,10]

💡 Note: The 10 and -5 collide. Since 10 > 5, the -5 explodes. The 5 and 10 never collide.

Example 2 — Chain Reaction

$ Input: asteroids = [8,-8]

› Output: []

💡 Note: The 8 and -8 collide and both explode, leaving an empty array.

Example 3 — Multiple Collisions

$ Input: asteroids = [10,2,-5]

› Output: [10]

💡 Note: The 2 and -5 collide, -5 wins. Then 10 and -5 collide, 10 wins.

Constraints

2 ≤ asteroids.length ≤ 10⁴
-1000 ≤ asteroids[i] ≤ 1000
asteroids[i] ≠ 0

Visualization

Tap to expand

Asked in

G Google 15 a Amazon 12 f Facebook 8 M Microsoft 6

The key insight is that only right-moving asteroids (positive) can collide with left-moving asteroids (negative). Use a stack to efficiently handle chain reactions by processing asteroids left to right. Time: O(n), Space: O(n)

Common Approaches

✓ Bfs

⏱️ Time: N/A Space: N/A

Brute Force Simulation

⏱️ Time: O(n²) Space: O(n)

Keep scanning the array for adjacent asteroids that collide (right-moving followed by left-moving), resolve each collision, and repeat until no more collisions happen.

Stack-Based Solution

⏱️ Time: O(n) Space: O(n)

Process asteroids one by one from left to right. Use a stack to keep track of surviving asteroids. When we encounter a left-moving asteroid, it collides with right-moving asteroids in the stack.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

struct TreeNode {
    int val;
    struct TreeNode* left;
    struct TreeNode* right;
};

struct TreeNode* createNode(int val) {
    struct TreeNode* node = (struct TreeNode*)malloc(sizeof(struct TreeNode));
    node->val = val;
    node->left = NULL;
    node->right = NULL;
    return node;
}

struct TreeNode* buildTree(char* input) {
    if (strlen(input) < 3) return NULL;
    
    // Remove brackets and spaces
    char* start = strchr(input, '[');
    char* end = strrchr(input, ']');
    if (!start || !end) return NULL;
    
    start++;
    *end = '\0';
    
    if (strlen(start) == 0) return NULL;
    
    struct TreeNode* nodes[10000];
    int nodeCount = 0;
    struct TreeNode* queue[10000];
    int front = 0, rear = 0;
    
    char* token = strtok(start, ",");
    if (!token) return NULL;
    
    // Skip whitespace
    while (*token == ' ') token++;
    
    if (strcmp(token, "null") == 0) return NULL;
    
    int rootVal = atoi(token);
    struct TreeNode* root = createNode(rootVal);
    queue[rear++] = root;
    
    while ((token = strtok(NULL, ",")) != NULL && front < rear) {
        struct TreeNode* node = queue[front++];
        
        // Skip whitespace
        while (*token == ' ') token++;
        
        // Process left child
        if (strcmp(token, "null") != 0) {
            int leftVal = atoi(token);
            node->left = createNode(leftVal);
            queue[rear++] = node->left;
        }
        
        // Process right child
        token = strtok(NULL, ",");
        if (token != NULL) {
            // Skip whitespace
            while (*token == ' ') token++;
            
            if (strcmp(token, "null") != 0) {
                int rightVal = atoi(token);
                node->right = createNode(rightVal);
                queue[rear++] = node->right;
            }
        }
    }
    
    return root;
}

double* solution(struct TreeNode* root, int* returnSize) {
    if (!root) {
        *returnSize = 0;
        return NULL;
    }
    
    double* result = (double*)malloc(1000 * sizeof(double));
    struct TreeNode* queue[10000];
    int front = 0, rear = 0;
    int resultSize = 0;
    
    queue[rear++] = root;
    
    while (front < rear) {
        int levelSize = rear - front;
        double levelSum = 0;
        int currentRear = rear;
        
        for (int i = front; i < currentRear; i++) {
            struct TreeNode* node = queue[i];
            levelSum += node->val;
            
            if (node->left) queue[rear++] = node->left;
            if (node->right) queue[rear++] = node->right;
        }
        
        result[resultSize++] = levelSum / levelSize;
        front = currentRear;
    }
    
    *returnSize = resultSize;
    return result;
}

int main() {
    char input[10000];
    fgets(input, sizeof(input), stdin);
    
    struct TreeNode* root = buildTree(input);
    int returnSize;
    double* result = solution(root, &returnSize);
    
    printf("[");
    for (int i = 0; i < returnSize; i++) {
        printf("%g", result[i]);
        if (i < returnSize - 1) printf(",");
    }
    printf("]\n");
    
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

✓ Linear Growth

Space Complexity

⚡ Linearithmic Space

158.0K Views

Medium Frequency

~25 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