Find the slowest integer eating speed that still clears every banana pile within the allotted hours. Try it free and read the solution.

Koko Eating Bananas

Integer to Roman

Two Sum II - Input Array Is Sorted

Find the slowest integer eating speed that still clears every banana pile within the allotted hours.

Koko loves bananas. There are `piles.length` piles, and the `i`-th pile has `piles[i]` bananas. The guards have gone and will come back in `h` hours.

Koko decides her eating speed `k` (bananas per hour). Each hour she picks a pile and eats `k` bananas from it. If the pile has fewer than `k` bananas, she eats all of them and will **not** eat any more during that hour.

Return the **minimum** integer speed `k` such that she can finish every pile within `h` hours.

Because she can only eat from one pile per hour, a pile of `p` bananas always takes `ceil(p / k)` hours at speed `k`.

**Input / output**
- Input: `piles: int[]`, `h: int`
- Output: `int` — the minimum feasible speed

## Examples
```
Input: {"piles":[3,6,7,11],"h":8}
Output: 4
```

```
Input: {"piles":[30,11,23,4,20],"h":5}
Output: 30
```

```
Input: {"piles":[30,11,23,4,20],"h":6}
Output: 23
```

## Constraints
- `1 <= piles.length <= 10000`
- `piles.length <= h <= 1000000000`
- `1 <= piles[i] <= 1000000000`

## Follow-up
The hours-needed function is monotonic in `k` (faster is never slower to finish). How does that monotonicity let you binary-search the answer instead of trying every speed?

- Define `feasible(k)` = "Koko finishes within `h` hours at speed `k`".
- If a speed works, every larger speed also works, and if a speed fails, every smaller speed also fails.
- That monotonic yes/no boundary is the hallmark of binary-searching the answer rather than a sorted array.

Recognize a monotonic predicate

- At speed `k`, a pile of `p` bananas takes `ceil(p / k)` hours because only one pile is eaten per hour.
- Sum `ceil(p / k)` over all piles; the speed is feasible when that total is `<= h`.
- Use integer math: `ceil(p / k)` is `(p + k - 1) / k` with integer division.

Compute hours at a given speed

- The slowest sensible speed is `1` banana per hour.
- The fastest useful speed is `max(piles)`: going faster never reduces the hour count below one pile per hour.
- So the answer lies in `[1, max(piles)]`.

Bound the search

- Try speeds `1, 2, 3, ...` and stop at the first feasible one.
- Correct but up to `O(max(piles) * n)` time — fine as a reference, too slow for the largest inputs.

Brute-force baseline

- Search the boundary in `[1, max(piles)]`.
- When `mid` is feasible, it might still be too fast, so keep it and move `hi` down to `mid`.
- When `mid` is infeasible, discard it and everything slower by setting `lo = mid + 1`.
- The loop converges on the smallest feasible speed.

Binary search the speed

- Using floating-point division and `round` instead of a true ceiling — off-by-one hours creep in.
- Setting `hi = mid - 1` when `mid` is feasible, which can skip the real answer.
- Starting `hi` above `max(piles)`, which still works but wastes iterations.