Koko Eating Bananas - Practice Coding Problems

Koko Eating Bananas - Problem

Koko the gorilla loves bananas! 🍌 There are n piles of bananas scattered around, where the i-th pile contains piles[i] bananas. The guards have left and will return in exactly h hours.

Koko must decide on her eating speed k (bananas per hour). Each hour, she picks one pile and eats at most k bananas from it. If a pile has fewer than k bananas, she eats the entire pile and then takes a break for the rest of that hour.

Koko wants to eat slowly (she's a mindful eater!), but she also needs to finish all the bananas before the guards return. Your task is to find the minimum eating speed k that allows her to consume all bananas within h hours.

Input & Output

example_1.py — Basic Case

$ Input: piles = [3,6,7,11], h = 8

› Output: 4

💡 Note: At speed 4: pile 3 takes 1h, pile 6 takes 2h, pile 7 takes 2h, pile 11 takes 3h. Total = 8h exactly.

example_2.py — More Time Available

$ Input: piles = [30,11,23,4,20], h = 5

› Output: 30

💡 Note: With only 5 hours for 5 piles, Koko must eat the largest pile (30) in 1 hour, so minimum speed is 30.

example_3.py — Plenty of Time

$ Input: piles = [30,11,23,4,20], h = 6

› Output: 23

💡 Note: At speed 23: piles take [2,1,1,1,1] hours respectively, totaling 6 hours exactly.

Constraints

1 ≤ piles.length ≤ 10⁴
piles.length ≤ h ≤ 10⁹
1 ≤ piles[i] ≤ 10⁹
Key constraint: h ≥ piles.length (enough time to eat at least one pile per hour)

Visualization

Tap to expand

Understanding the Visualization

Define Search Space

Reading speed must be between 1 and the thickest book's pages

Test Middle Speed

For each book, calculate ceil(pages/speed) hours needed

Check Feasibility

If total time ≤ h, try slower speed; otherwise need faster speed

Narrow Search

Binary search eliminates half the possibilities each iteration

Find Minimum

Converge to the slowest speed that still meets the deadline

Key Takeaway

🎯 Key Insight: The problem has a monotonic property - if eating speed k works, then any speed > k also works. This allows us to binary search the answer space efficiently, reducing time complexity from O(max(piles) × n) to O(log(max(piles)) × n).

Asked in

A Amazon 45 G Google 35 f Meta 28 ⊞ Microsoft 22

The optimal solution uses binary search on the eating speed range [1, max(piles)]. For each candidate speed, we check if Koko can finish all bananas in time using ceiling division. The key insight is the monotonic property: if speed k works, then any speed > k also works, making binary search applicable with O(n × log(max(piles))) time complexity.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Linear Search)	O(max(piles) × n)	O(1)	Try every possible eating speed from 1 to max pile size
Binary Search (Optimal)	O(n × log(max(piles)))	O(1)	Binary search on the eating speed range to find minimum viable speed

Brute Force (Linear Search) — Algorithm Steps

Start with k = 1 (slowest possible speed)
For each k, calculate total hours needed using math.ceil(pile/k) for each pile
If total hours ≤ h, return k as the answer
Otherwise, increment k and repeat
Continue until a valid k is found

Visualization

Tap to expand

Step-by-Step Walkthrough

Start with k=1

Test if speed 1 allows finishing all piles in time

Calculate total hours

For each pile, add ceil(pile_size/k) to total time

Check constraint

If total_hours ≤ h, we found our answer

Increment speed

If not feasible, try k+1 and repeat

Code -

solution.c — C

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

int minEatingSpeed(int* piles, int pilesSize, int h) {
    int maxPile = 0;
    for (int i = 0; i < pilesSize; i++) {
        if (piles[i] > maxPile) {
            maxPile = piles[i];
        }
    }
    
    // Try every speed from 1 to max pile size
    for (int k = 1; k <= maxPile; k++) {
        long long totalHours = 0;
        
        // Calculate hours needed for this speed
        for (int i = 0; i < pilesSize; i++) {
            totalHours += (piles[i] + k - 1) / k; // Ceiling division
        }
        
        // If we can finish in time, return this speed
        if (totalHours <= h) {
            return k;
        }
    }
    
    return maxPile; // Fallback
}

int main() {
    int piles[] = {3, 6, 7, 11};
    int h = 8;
    printf("%d\n", minEatingSpeed(piles, 4, h));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(max(piles) × n)

We try up to max(piles) different speeds, and for each speed we check all n piles

✓ Linear Growth

Space Complexity

O(1)

Only using a few variables for calculations

✓ Linear Space

67.2K Views

High Frequency

~18 min Avg. Time

1.8K 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

Constraints

Visualization

Related Problems

Common Approaches

Brute Force (Linear Search) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler