add 826

Author: fishercoder1534

Diff for: paginated_contents/algorithms/1st_thousand/README.md

@@ -86,6 +86,7 @@
 | 836 | [Rectangle Overlap](https://leetcode.com/problems/rectangle-overlap/)                                                                                                                         | [Solution](https://github.com/fishercoder1534/Leetcode/blob/master/src/main/java/com/fishercoder/solutions/firstthousand/_836.java)                                                                  | [:tv:](https://youtu.be/o6hHUk4DOW0)                                          | Easy                             |
 | 832 | [Flipping an Image](https://leetcode.com/problems/flipping-an-image/)                                                                                                                         | [Solution](https://github.com/fishercoder1534/Leetcode/blob/master/src/main/java/com/fishercoder/solutions/firstthousand/_832.java)                                                                  |                                                                               | Easy                             |
 | 830 | [Positions of Large Groups](https://leetcode.com/problems/positions-of-large-groups/)                                                                                                         | [Solution](https://github.com/fishercoder1534/Leetcode/blob/master/src/main/java/com/fishercoder/solutions/firstthousand/_830.java)                                                                  |                                                                               | Easy                             |
+| 826 | [Most Profit Assigning Work](https://leetcode.com/problems/most-profit-assigning-work/)                                                                                                                                       | [Solution](https://github.com/fishercoder1534/Leetcode/blob/master/src/main/java/com/fishercoder/solutions/firstthousand/_826.java)                                                                  |                                                                               | Medium                           |Binary Search, Greedy, Sorting
 | 824 | [Goat Latin](https://leetcode.com/problems/goat-latin/)                                                                                                                                       | [Solution](https://github.com/fishercoder1534/Leetcode/blob/master/src/main/java/com/fishercoder/solutions/firstthousand/_824.java)                                                                  |                                                                               | Easy                             |
 | 823 | [Binary Trees With Factors](https://leetcode.com/problems/binary-trees-with-factors/)                                                                                                         | [Solution](https://github.com/fishercoder1534/Leetcode/blob/master/src/main/java/com/fishercoder/solutions/firstthousand/_823.java)                                                                  |                                                                               | Medium                           |
 | 821 | [Shortest Distance to a Character](https://leetcode.com/problems/shortest-distance-to-a-character/)                                                                                           | [Solution](https://github.com/fishercoder1534/Leetcode/blob/master/src/main/java/com/fishercoder/solutions/firstthousand/_821.java)                                                                  |                                                                               | Easy                             |

Diff for: src/main/java/com/fishercoder/solutions/firstthousand/_826.java

@@ -0,0 +1,47 @@
+package com.fishercoder.solutions.firstthousand;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+public class _826 {
+    public static class Solution1 {
+        public int maxProfitAssignment(int[] difficulty, int[] profit, int[] worker) {
+            List<int[]> jobs = new ArrayList<>();
+            for (int i = 0; i < difficulty.length; i++) {
+                jobs.add(new int[]{difficulty[i], profit[i]});
+            }
+            //sort by difficulty level
+            Collections.sort(jobs, (a, b) -> a[0] - b[0]);
+
+            //update the profit values: because a later (with more difficult) job must be able to handle a prior job, so we take the more profitable one
+            for (int i = 0; i < jobs.size() - 1; i++) {
+                jobs.get(i + 1)[1] = Math.max(jobs.get(i)[1], jobs.get(i + 1)[1]);
+            }
+
+            int maxProfit = 0;
+            for (int ability : worker) {
+                maxProfit += binarySearch(ability, jobs);
+            }
+            return maxProfit;
+        }
+
+        private int binarySearch(int ability, List<int[]> jobs) {
+            int left = 0;
+            int right = jobs.size() - 1;
+            int maxProfit = 0;
+            //it's important to use <= here so we don't miss a possible element
+            while (left <= right) {
+                int mid = left + (right - left) / 2;
+                if (ability >= jobs.get(mid)[0]) {
+                    maxProfit = Math.max(jobs.get(mid)[1], maxProfit);
+                    left = mid + 1;
+                } else {
+                    right = mid - 1;
+                }
+            }
+            return maxProfit;
+        }
+
+    }
+}

Diff for: src/test/java/com/fishercoder/firstthousand/_826Test.java

@@ -0,0 +1,31 @@
+package com.fishercoder.firstthousand;
+
+import com.fishercoder.solutions.firstthousand._826;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+public class _826Test {
+    private static _826.Solution1 solution1;
+
+    @BeforeEach
+    public void setup() {
+        solution1 = new _826.Solution1();
+    }
+
+    @Test
+    public void test1() {
+        assertEquals(100, solution1.maxProfitAssignment(new int[]{2, 4, 6, 8, 10}, new int[]{10, 20, 30, 40, 50}, new int[]{4, 5, 6, 7}));
+    }
+
+    @Test
+    public void test2() {
+        assertEquals(324, solution1.maxProfitAssignment(new int[]{68, 35, 52, 47, 86}, new int[]{67, 17, 1, 81, 3}, new int[]{92, 10, 85, 84, 82}));
+    }
+
+    @Test
+    public void test3() {
+        assertEquals(190, solution1.maxProfitAssignment(new int[]{13, 37, 58}, new int[]{4, 90, 96}, new int[]{34, 73, 45}));
+    }
+}