
### Problem Statement

###### UN Spy satellite Watchtower-14 has detected martian stealth ballistic missile platforms. It holds 10 planet busters with 20 high yield nuclear warheads. Our watch tower satellite is the only thing that can penetrate their stealth tech but its far from perfect. It is the first time we have been able to locate their platform , its hell of a break and a golden oppurtunity.

###### The martians are always moving their platforms and they have sensor blinding so when they move we loose them but as a group they must be always positioned optimized strike times to earth in order to fire.

###### The only defence against those beasts is our planetary railgun. Earth has decided to launch a preemptive strike to destroy those platforms and eliminate the MCR's first strike capability.

###### Lets say that the watchtower has detected **n** planet busters.We are given a 0-indexed integer array dist of size **n**, where **dist[i]** is the initial distance in kilometers of the ith planet busters from the location where they can get target locked on earth.

###### The planet busters move toward the location(from where it will get a target lock on earth), at a constant speed. The speed of each planet busters is given to us in an integer array **speed** of size **n**, where **speed[i]** is the speed of the ith planet busters in kilometers per minute.

###### Our Railgun once fully charged, can eliminate a single planet buster. However, our railgun takes one minute to charge for firing . The railgun is fully charged at the very start.

###### Millions of life are at stake if the planet busters reach the location from where it can target lock on earth. If a planet buster reaches the location at the exact moment the railgun is fully charged, it counts as a loss, and the warhead gets launched before we can use our railgun.

###### Return the maximum number of planet busters that we can eliminate before we lose, or n if we can eliminate all the planet busters before they reach the location.

**INPUT**

- **dist = [1,3,4]** , **speed = [1,1,1]**

**OUTPUT**

- **3**

**EXPLANATION**

- In the beginning, the distances of the planet busters are [1,3,4]. We eliminate the first planet buster.
- After a minute, the distances of the planet busters are [X,2,3]. We eliminate the second planet buster.
- After a minute, the distances of the planet busters are [X,X,2]. We eliminate the third planet buster.
- All 3 planet busters can be eliminated.

**Steps To Solve**

- So we need to stop the planet busters from reaching the firing location but shooting it down every second, the greedy choice will be to shoot the planet buster whose current position is closest to target location.

- Although a planet buster might be at a farther position than others at the current second, it might have such a high speed than others and might reach the target location before the others do.

- So, now we need something that will take care of both distance and speed? TIME!
- As each planet busters much be destroyed at an inital second.
- So for example if dist = 1, and speed = 2 , although time will be = 1/2, which in integer will give 0, we can still destroy this planet buster, as at time=0 , this planet buster will be 1/2 time units away from arrival at location of target lock.

- Now we will sort all the time values and greedily shoot the planet buster with lowest time of arrival value at each second.

- If at any instance the lowest time value is less than or equal to our curent time instant of fire , we are done.
- GO INTO A ROOM TO FAST KID!!!, THE ROOM EATS YOU !!!

###### JavaScript

```js
const stin = (a) => a.sort((x, y) => x - y);
const eliminateMaximum = (dist, speed) => {
  let n = dist.length;
  let t = [];
  for (let i = 0; i < n; i++) t.push(dist[i] / speed[i]);
  stin(t);
  let pass = (res = 0);
  for (const e of t) {
    if (e - pass <= 0) break;
    res++;
    pass++; // each round time pass++
  }
  return res;
};
```

###### Go

```go
func eliminateMaximum(dist []int, speed []int) int {
    for i := range speed {
        speed[i] = int(math.Ceil(float64(dist[i])/float64(speed[i])))
    }
    sort.Ints(speed)
    c := 0
    for i := range speed {
        if speed[i]<i+1 {
            break
        } else {
            c+=1
        }
    }
    return c
}
```

###### Java

```java
class Solution {
    public int eliminateMaximum(int[] dist, int[] speed) {
    for (int i = 0; i < dist.length; ++i)
        dist[i] = (dist[i] - 1) / speed[i];
    Arrays.sort(dist);
    for (int i = 0; i < dist.length; ++i)
        if (i > dist[i])
            return i;
        return dist.length;
    }
}
```

###### C++

```cpp
class Solution {
public:
    int eliminateMaximum(vector<int>& dist, vector<int>& speed) {
    for (int i = 0; i < dist.size(); ++i)
        dist[i] = (dist[i] - 1) / speed[i];
    sort(begin(dist), end(dist));
    for (int i = 0; i < dist.size(); ++i)
        if (i > dist[i])
            return i;
        return dist.size();
    }
};
```

###### Python

```py
class Solution:
    def eliminateMaximum(self, dist: List[int], speed: List[int]) -> int:
        for i, t in enumerate(sorted([(d - 1) // s for d, s in zip(dist, speed)])):
            if i > t:
                return i
        return len(dist)
```
