Codestin Search App

Destroying Asteroids - Problem

Destroying Asteroids

You're given a planet with an initial mass and an array of asteroids where each asteroid has its own mass. The planet can collide with asteroids in any order you choose.

Collision Rules:

If planet_mass ≥ asteroid_mass: The asteroid is destroyed and the planet absorbs the asteroid's mass
If planet_mass < asteroid_mass: The planet is destroyed and the game ends

Your goal is to determine if there exists an order of collisions such that all asteroids can be destroyed.

Example: Planet mass = 10, asteroids = [3, 9, 19, 5, 21]
One winning strategy: destroy asteroids in order [3, 5, 9, 19, 21]
Mass progression: 10 → 13 → 18 → 27 → 46 → 67

Input & Output

example_1.py — Basic Success Case

$ Input: mass = 10, asteroids = [3, 9, 19, 5, 21]

› Output: true

💡 Note: Sort to [3, 5, 9, 19, 21]. Planet can destroy all: 10→13→18→27→46→67. The greedy strategy works perfectly here.

example_2.py — Impossible Case

$ Input: mass = 5, asteroids = [4, 9, 23, 4]

› Output: false

💡 Note: Sort to [4, 4, 9, 23]. Planet progresses: 5→9→13→22, but 22 < 23. Cannot destroy the largest asteroid.

example_3.py — Edge Case: Single Large Asteroid

$ Input: mass = 1, asteroids = [2]

› Output: false

💡 Note: Planet mass 1 is less than asteroid mass 2. Planet gets destroyed immediately.

Constraints

1 ≤ mass ≤ 10⁵
1 ≤ asteroids.length ≤ 10⁵
1 ≤ asteroids[i] ≤ 10⁵
Important: Planet mass can grow beyond initial constraints after absorbing asteroids

Visualization

Tap to expand

Understanding the Visualization

Sort enemies by strength

Arrange asteroids from weakest (smallest mass) to strongest (largest mass)

Fight in optimal order

Always challenge the weakest opponent you can currently defeat

Grow stronger with victories

Each victory adds the defeated asteroid's mass to your planet

Check if all can be defeated

If you can defeat every asteroid in this order, return true

Key Takeaway

🎯 Key Insight: The greedy approach works because destroying smaller asteroids first maximizes our future potential. This is a classic example of how local optimal choices lead to a globally optimal solution.

Asked in

G Google 25 a Amazon 18 f Meta 12 ⊞ Microsoft 8

The optimal solution uses a greedy approach: sort the asteroids in ascending order and destroy them from smallest to largest. This maximizes the planet's mass growth potential, giving it the best chance to handle larger asteroids later. Time complexity is O(n log n) due to sorting, with O(1) extra space.

Common Approaches

Approach	Time	Space	Notes
✓ Greedy Approach (Optimal)	O(n log n)	O(1)	Sort asteroids and destroy them in ascending order of mass
Brute Force (Try All Permutations)	O(n! × n)	O(n)	Generate all possible orders of destroying asteroids and check if any works

Greedy Approach (Optimal) — Algorithm Steps

Sort the asteroids array in ascending order
Iterate through the sorted asteroids from smallest to largest
For each asteroid, check if current planet mass >= asteroid mass
If yes, add the asteroid's mass to the planet's mass
If no, return false (planet gets destroyed)
If all asteroids are successfully destroyed, return true

Visualization

Tap to expand

Step-by-Step Walkthrough

Sort asteroids

Arrange asteroids from smallest to largest mass

Greedy destruction

Always take the smallest asteroid we can handle

Mass accumulation

Planet grows stronger with each successful collision

Code -

solution.c — C

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

int compare(const void *a, const void *b) {
    return (*(int*)a - *(int*)b);
}

bool asteroidDestruction(int mass, int* asteroids, int size) {
    // Sort asteroids in ascending order
    qsort(asteroids, size, sizeof(int), compare);
    
    long long currentMass = mass;
    
    // Try to destroy asteroids from smallest to largest
    for (int i = 0; i < size; i++) {
        if (currentMass >= asteroids[i]) {
            currentMass += asteroids[i];
        } else {
            return false;
        }
    }
    
    return true;
}

int main() {
    int mass = 10;
    int asteroids[] = {3, 9, 19, 5, 21};
    int size = 5;
    printf("%s\n", asteroidDestruction(mass, asteroids, size) ? "true" : "false");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n log n)

Dominated by sorting the asteroids array, iteration is O(n)

⚡ Linearithmic

Space Complexity

O(1)

Only using constant extra space (not counting input)

✓ Linear Space

27.8K Views

Medium Frequency

~15 min Avg. Time

856 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

Destroying Asteroids

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Greedy Approach (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler