Eliminate Maximum Number of Monsters - Practice Coding Problems

Eliminate Maximum Number of Monsters - Problem

You're the last defender of your city, facing a horde of n monsters approaching from different distances! Each monster starts at a specific distance from your city and moves toward it at a constant speed.

You have a powerful weapon that can eliminate any monster with a single shot, but it takes exactly 1 minute to charge between shots. The weapon starts fully charged, so you can eliminate the first monster immediately.

The catch: If any monster reaches your city at the exact moment your weapon finishes charging, you lose the game before you can fire! You must eliminate monsters before they arrive.

Goal: Determine the maximum number of monsters you can eliminate before losing, or return n if you can eliminate all monsters.

Input: Two arrays of size n:

dist[i] - initial distance of monster i from the city (km)
speed[i] - speed of monster i (km/minute)

Output: Maximum number of monsters you can eliminate

Input & Output

example_1.py — Basic Case

$ Input: dist = [1,3,4], speed = [1,1,1]

› Output: 3

💡 Note: Monster arrival times: [1.0, 3.0, 4.0]. At time 0: eliminate monster at distance 1. At time 1: eliminate monster at distance 3. At time 2: eliminate monster at distance 4. All monsters eliminated successfully!

example_2.py — Partial Success

$ Input: dist = [1,1,2,3], speed = [1,1,1,1]

› Output: 1

💡 Note: Monster arrival times: [1.0, 1.0, 2.0, 3.0]. At time 0: eliminate first monster (arrives at 1.0). At time 1: second monster already arrived at time 1.0, so we lose. Maximum eliminated: 1.

example_3.py — Different Speeds

$ Input: dist = [3,2,4], speed = [5,3,2]

› Output: 1

💡 Note: Monster arrival times: [0.6, 0.67, 2.0]. At time 0: eliminate monster 0 (arrives at 0.6). At time 1: monster 1 already arrived at 0.67, game over. Maximum eliminated: 1.

Visualization

Tap to expand

Understanding the Visualization

Calculate Threat Level

Determine when each monster will arrive at your city

Prioritize Targets

Sort monsters by arrival time - most urgent first

Execute Strategy

Eliminate monsters in order, checking if each can be stopped in time

Key Takeaway

🎯 Key Insight: Always eliminate the monster that will reach your city first (considering when your weapon will be ready). This greedy strategy maximizes the number of monsters you can eliminate.

Time & Space Complexity

Time Complexity

⏱️

O(n log n)

Sorting the arrival times takes O(n log n), iteration takes O(n)

⚡ Linearithmic

Space Complexity

O(n)

Space for storing arrival times and sorting

⚡ Linearithmic Space

Constraints

n == dist.length == speed.length
1 ≤ n ≤ 10⁵
1 ≤ dist[i], speed[i] ≤ 10⁵
Time limit: 1000ms

Asked in

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

The optimal solution uses a greedy approach: calculate each monster's arrival time (distance/speed), sort by urgency, and eliminate monsters in order of when they'll reach the city. This ensures we always handle the most threatening monster first, maximizing our eliminations before losing the game.

Common Approaches

Approach	Time	Space	Notes
✓ Greedy with Sorting (Optimal)	O(n log n)	O(n)	Calculate arrival times, sort by urgency, and eliminate in optimal order
Brute Force (Try All Orders)	O(n! × n)	O(n)	Try every possible order of eliminating monsters

Greedy with Sorting (Optimal) — Algorithm Steps

Calculate arrival time for each monster: time = distance / speed
Sort monsters by their arrival times (most urgent first)
Iterate through sorted monsters and eliminate them in order
For each monster, check if it arrives before our weapon is ready
Count successful eliminations until we lose or eliminate all

Visualization

Tap to expand

Step-by-Step Walkthrough

Calculate Arrival Times

For each monster: time = distance / speed

Sort by Urgency

Order monsters by when they'll reach the city

Eliminate in Order

Process monsters from most to least urgent

Code -

solution.c — C

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

int compare(const void* a, const void* b) {
    double da = *(double*)a;
    double db = *(double*)b;
    if (da < db) return -1;
    if (da > db) return 1;
    return 0;
}

int eliminateMaximum(int* dist, int* speed, int n) {
    // Calculate arrival times
    double* arrivalTimes = malloc(n * sizeof(double));
    for (int i = 0; i < n; i++) {
        arrivalTimes[i] = (double)dist[i] / speed[i];
    }
    
    // Sort by arrival time
    qsort(arrivalTimes, n, sizeof(double), compare);
    
    // Eliminate monsters in order of urgency
    int time = 0;
    int eliminated = 0;
    
    for (int i = 0; i < n; i++) {
        if (arrivalTimes[i] <= time) break;
        
        eliminated++;
        time++;
    }
    
    free(arrivalTimes);
    return eliminated;
}

int main() {
    int dist[] = {1, 3, 4};
    int speed[] = {1, 1, 1};
    printf("%d\n", eliminateMaximum(dist, speed, 3));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n log n)

Sorting the arrival times takes O(n log n), iteration takes O(n)

⚡ Linearithmic

Space Complexity

O(n)

Space for storing arrival times and sorting

⚡ Linearithmic Space

Constraints

n == dist.length == speed.length
1 ≤ n ≤ 10⁵
1 ≤ dist[i], speed[i] ≤ 10⁵
Time limit: 1000ms

28.4K Views

Medium Frequency

~15 min Avg. Time

892 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

Greedy with Sorting (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler