add 875

Author: fishercoder1534

paginated_contents/algorithms/1st_thousand/README.md

@@ -66,6 +66,7 @@
 | 880 | [Decoded String at Index](https://leetcode.com/problems/decoded-string-at-index/)                                                                                                             | [Solution](https://github.com/fishercoder1534/Leetcode/blob/master/src/main/java/com/fishercoder/solutions/firstthousand/_880.java)                                                                  |                                                                               | Medium                           | Stack                                                                
 | 877 | [Stone Game](https://leetcode.com/problems/stone-game/)                                                                                                                                       | [Solution](https://github.com/fishercoder1534/Leetcode/blob/master/src/main/java/com/fishercoder/solutions/firstthousand/_877.java)                                                                  |                                                                               | Medium                           | Math, DP, Minimax                                                    
 | 876 | [Middle of the Linked List](https://leetcode.com/problems/middle-of-the-linked-list/)                                                                                                         | [Solution](https://github.com/fishercoder1534/Leetcode/blob/master/src/main/java/com/fishercoder/solutions/firstthousand/_876.java)                                                                  |                                                                               | Easy                             |
+| 875 | [Koko Eating Bananas](https://leetcode.com/problems/koko-eating-bananas/)                                                                                                                       | [Solution](https://github.com/fishercoder1534/Leetcode/blob/master/src/main/java/com/fishercoder/solutions/firstthousand/_875.java)                                                                  |                                                                               | Medium                           | Binary Search
 | 872 | [Leaf-Similar Trees](https://leetcode.com/problems/leaf-similar-trees/)                                                                                                                       | [Solution](https://github.com/fishercoder1534/Leetcode/blob/master/src/main/java/com/fishercoder/solutions/firstthousand/_872.java)                                                                  |                                                                               | Easy                             | DFS, recursion                                                       
 | 870 | [Advantage Shuffle](https://leetcode.com/problems/advantage-shuffle/)                                                                                                                         | [Solution](https://github.com/fishercoder1534/Leetcode/blob/master/src/main/java/com/fishercoder/solutions/firstthousand/_870.java)                                                                  |                                                                               | Medium                           | Array, Greedy                                                        
 | 868 | [Binary Gap](https://leetcode.com/problems/binary-gap/)                                                                                                                                       | [Solution](https://github.com/fishercoder1534/Leetcode/blob/master/src/main/java/com/fishercoder/solutions/firstthousand/_868.java)                                                                  |                                                                               | Easy                             |

src/main/java/com/fishercoder/solutions/firstthousand/_875.java

@@ -0,0 +1,41 @@
+package com.fishercoder.solutions.firstthousand;
+
+public class _875 {
+    public static class Solution1 {
+        public int minEatingSpeed(int[] piles, int h) {
+            long left = Long.MAX_VALUE;
+            long right = Long.MIN_VALUE;
+            for (int pile : piles) {
+                left = Math.min(left, pile);
+                right = Math.max(right, pile);
+            }
+            left /= h;
+            while (left + 1 < right) {
+                long mid = left + (right - left) / 2;
+                if (possibleSpeed((int) mid, piles, h)) {
+                    right = mid;
+                } else {
+                    left = mid;
+                }
+            }
+            return possibleSpeed((int) left, piles, h) ? (int) left : (int) (left + 1);
+        }
+
+        private boolean possibleSpeed(int speed, int[] piles, int hour) {
+            if (speed <= 0) {
+                return false;
+            }
+            long usedHours = 0;
+            for (int pile : piles) {
+                if (pile <= speed) {
+                    usedHours++;
+                } else {
+                    usedHours += pile / speed;
+                    pile %= speed;
+                    usedHours += pile > 0 ? 1 : 0;
+                }
+            }
+            return usedHours <= hour;
+        }
+    }
+}

src/test/java/com/fishercoder/firstthousand/_875Test.java

@@ -0,0 +1,57 @@
+package com.fishercoder.firstthousand;
+
+import com.fishercoder.solutions.firstthousand._875;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+public class _875Test {
+    private static _875.Solution1 solution1;
+
+    @BeforeEach
+    public void setup() {
+        solution1 = new _875.Solution1();
+    }
+
+    @Test
+    public void test1() {
+        assertEquals(4, solution1.minEatingSpeed(new int[]{3, 6, 7, 11}, 8));
+    }
+
+    @Test
+    public void test2() {
+        assertEquals(30, solution1.minEatingSpeed(new int[]{30, 11, 23, 4, 20}, 5));
+    }
+
+    @Test
+    public void test3() {
+        assertEquals(23, solution1.minEatingSpeed(new int[]{30, 11, 23, 4, 20}, 6));
+    }
+
+    @Test
+    public void test4() {
+        assertEquals(2, solution1.minEatingSpeed(new int[]{2, 2}, 2));
+    }
+
+    @Test
+    public void test5() {
+        assertEquals(2, solution1.minEatingSpeed(new int[]{312884470}, 312884469));
+    }
+
+    @Test
+    public void test6() {
+        assertEquals(500000000, solution1.minEatingSpeed(new int[]{1000000000}, 2));
+    }
+
+    @Test
+    public void test7() {
+        assertEquals(1, solution1.minEatingSpeed(new int[]{312884470}, 968709470));
+    }
+
+    @Test
+    public void test8() {
+        assertEquals(3, solution1.minEatingSpeed(new int[]{805306368, 805306368, 805306368}, 1000000000));
+    }
+
+}