koko-bananas py3

0907_koko-eating-bananas/README.md

@@ -0,0 +1,33 @@
+Koko loves to eat bananas. There are `n` piles of bananas, the `ith` pile has `piles[i]` bananas. The guards have gone and will come back in `h` hours.
+
+Koko can decide her bananas-per-hour eating speed of `k`. Each hour, she chooses some pile of bananas and eats `k` bananas from that pile. If the pile has less than `k` bananas, she eats all of them instead and will not eat any more bananas during this hour.
+
+Koko likes to eat slowly but still wants to finish eating all the bananas before the guards return.
+
+Return _the minimum integer_ `k` _such that she can eat all the bananas within_ `h` _hours_.
+
+**Example 1:**
+
+    Input: piles = [3,6,7,11], h = 8
+    Output: 4
+    
+
+**Example 2:**
+
+    Input: piles = [30,11,23,4,20], h = 5
+    Output: 30
+    
+
+**Example 3:**
+
+    Input: piles = [30,11,23,4,20], h = 6
+    Output: 23
+    
+
+**Constraints:**
+
+*   `1 <= piles.length <= 104`
+*   `piles.length <= h <= 109`
+*   `1 <= piles[i] <= 109`
+
+https://leetcode.com/problems/koko-eating-bananas

0907_koko-eating-bananas/python3/solution.py

@@ -0,0 +1,49 @@
+class Solution:
+    def minEatingSpeed(self, piles: List[int], h: int) -> int:
+        '''
+        NOTE: Do read the problem carefully!
+        
+        Absolute min speed (k) at which Koko can eat bananas would be 1
+        and max speed would be max(piles). Of course, these might not
+        be correct and might help Koko finish eating before `h` hours.
+        
+        So, we need to check each k from 1:max(piles) and figure out the
+        min k that lets us consume <= h
+        
+        We can iterate over each k value and check or we can do binary
+        search and figure out least k.
+        '''
+        
+        start, end = 1, max(piles)
+        k = end
+        
+        while start <= end:
+            mid = (start + end) // 2
+            
+            total = 0
+            for p in piles:
+                # If pile has 3 bananas and k = 2, then 3 / 2 = 1.5
+                # but we don't want fractional values, we will consider
+                # next greatest integer which'd be ceil(p / mid)
+                total += math.ceil(p / mid)
+            
+            # k is valid
+            if total <= h:
+                # Update k if mid is smaller
+                if mid < k:
+                    k = mid
+                    end = mid - 1
+                # If mid starts to go bigger than k, then
+                # we can't possibly find any better results
+                # so just break
+                else:
+                    break
+            # k is too small 👉 total is large so we need
+            # to move `start`
+            else:
+                start = mid + 1
+        
+        return k
+            
+            
+