875. Piles banana

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];

    int left = 1, right = maxPile;
    while (left < right) {
        int k = left + (right - left) / 2;
        int hours = 0;
        for (int i = 0; i < pilesSize; i++)
            hours += (piles[i] + k - 1) / k;

        if (hours > h)
            left = k + 1;
        else
            right = k;
    }
    return left;
}

#include <algorithm>
#include <vector>
using namespace std;

class Solution {
public:
  int minEatingSpeed(vector<int> &piles, int h) {
    int left = 1, right = *max_element(piles.begin(), piles.end());
    int k = right;

    while (left <= right) {
      int mid = left + (right - left) / 2;
      long long sum = 0;

      for (int n : piles)
        sum += ((long long)n + mid - 1) / mid;

      if (sum > h)
        left = mid + 1;
      if (sum <= h) {
        k = min(k, mid);
        right = mid - 1;
      }
    }

    return k;
  }
};

package main

func minEatingSpeed(piles []int, h int) int {
    maxPile := 0
    for _, p := range piles {
        if p > maxPile {
            maxPile = p
        }
    }

    left, right := 1, maxPile
    for left < right {
        k := left + (right-left)/2
        hours := 0
        for _, p := range piles {
            hours += (p + k - 1) / k
        }

        if hours > h {
            left = k + 1
        } else {
            right = k
        }
    }
    return left
}

class Solution {
    public int minEatingSpeed(int[] piles, int h) {
        int maxPile = 0;
        for (int p : piles)
            maxPile = Math.max(maxPile, p);

        int left = 1, right = maxPile;
        while (left < right) {
            int k = left + (right - left) / 2;
            int hours = 0;
            for (int p : piles)
                hours += (p + k - 1) / k;

            if (hours > h)
                left = k + 1;
            else
                right = k;
        }
        return left;
    }
}

class Solution {
  minEatingSpeed(piles, h) {
    let maxPile = Math.max(...piles);
    let left = 1, right = maxPile;

    while (left < right) {
      const k = left + Math.floor((right - left) / 2);
      let hours = 0;
      for (const p of piles) hours += Math.ceil(p / k);

      if (hours > h) left = k + 1;
      else right = k;
    }
    return left;
  }
}

import math


class Solution:
    def minEatingSpeed(self, piles: list[int], h: int) -> int:
        left, right = 1, max(piles)

        while left < right:
            k = left + (right - left) // 2
            hours = sum(math.ceil(p / k) for p in piles)

            if hours > h:
                left = k + 1
            else:
                right = k
        return left

struct Solution;

impl Solution {
    fn min_eating_speed(piles: Vec<i32>, h: i32) -> i32 {
        let mut left = 1;
        let mut right = *piles.iter().max().unwrap();

        while left < right {
            let k = left + (right - left) / 2;
            let hours: i32 = piles.iter().map(|&p| (p + k - 1) / k).sum();

            if hours > h {
                left = k + 1;
            } else {
                right = k;
            }
        }
        left
    }
}