Koko has $n$ piles of bananas in front of her, where the $i^{th}$ pile has piles[i] bananas. The guards have left and will return in h hours, and Koko must finish all the bananas before they come back.

Before eating, Koko chooses an integer as an eating speed $k$ (bananas per hour). She keeps this speed constant throughout.

In each hour, Koko selects one pile of bananas and eats from it according to the following rules:

• If the pile contains at least $k$ bananas, she eats exactly $k$ bananas from it.

• If the pile contains fewer than $k$ bananas, she eats all the bananas from that pile and does not eat from any other pile during that hour.

Your task is to return the minimum eating speed $k$ that allows Koko to finish all the bananas within h hours before the guards return.

Constraints:

• $1$ $\leq$ piles.length $\leq$ $10^{3}$

• piles.length $\leq$h $\leq$ $10^{9}$

• $1$ $\leq$piles[i] $\leq$ $10^{4}$

The intuition behind this solution is that we don’t need to try every possible eating speed from 1 to the maximum pile size, because that would be inefficient. Instead, we can use the fact that the problem has a monotonic pass/fail behavior:

• If Koko can finish eating all the bananas at some speed k within h hours, then she can also finish at any faster speed, because eating faster never increases the time needed.

• Conversely, if she cannot finish at speed k, she cannot finish at any slower speed either, because eating slower only takes longer.

This means the set of all possible speeds naturally splits into two regions:

• Failing speeds on the left (too slow)

• Succeeding speeds on the right (fast enough)

There is a single boundary point between these regions, and our task is to find the smallest successful speed. Binary search is the most efficient way to find the answer because the search space is ordered and follows this monotonic pass/fail behavior. Binary search works by repeatedly checking the middle speed and then narrowing the range to only the half that could contain the boundary.

Let’s break down the key steps of the solution:

1. Initialize left to 1 and right to the maximum number of bananas in any pile.

2. Iterate while left is less than right:

   1. Calculate the middle speed mid as the average of left and right.

   2. Compute the total number of hours required at this speed:
      hours = sum( (pile + mid - 1)

   3. If hours are less than or equal to h, it means mid is fast enough, so move the search space to the left by setting right to mid.

   4. Otherwise, if hours exceed h, it means mid is too slow, so move the search space to the right by setting left to mid + 1.

3. When the iteration ends, return left as the minimum eating speed that allows Koko to eat all the bananas within h hours.

Let’s look at the following illustration to get a better understanding of the solution: