add 769 java

Author: yennanliu

README.md

@@ -275,7 +275,8 @@
 747 | [Largest Number At Least Twice of Others](https://leetcode.com/problems/largest-number-at-least-twice-of-others/) | [Python](./leetcode_python/Array/largest-number-at-least-twice-of-others.py) | _O(n)_ | _O(1)_ | Easy |`good basic`, `data structure`| OK* 
 755 | [Pour Water](https://leetcode.com/problems/pour-water/) | [Python](./leetcode_python/Array/pour-water.py) | _O(v * n)_ | _O(1)_ | Medium |`complex`| AGAIN (not start)
 766 | [Toeplitz Matrix](https://leetcode.com/problems/toeplitz-matrix/) | [Python](./leetcode_python/Array/toeplitz-matrix.py)  | _O(m * n)_ | _O(1)_ | Easy |`basic`, `matrix`, `google`| AGAIN* (2)
-769 | [Max Chunks To Make Sorted](https://leetcode.com/problems/max-chunks-to-make-sorted/) | [Python](./leetcode_python/Array/max-chunks-to-make-sorted.py) | _O(n)_ | _O(1)_ | Medium || AGAIN** (not start)
+769 | [Max Chunks To Make Sorted](https://leetcode.com/problems/max-chunks-to-make-sorted/) | [Python](./leetcode_python/Array/max-chunks-to-make-sorted.py), [Java](./leetcode_java/src/main/java/LeetCodeJava/Array/MaxChunksToMakeSorted.java)
+ | _O(n)_ | _O(1)_ | Medium |stack, array, google| AGAIN*** (1)
 792 | [Number of Matching Subsequences](https://leetcode.com/problems/number-of-matching-subsequences/) | [Python](./leetcode_python/Array/number-of-matching-subsequences.py), [Java](./leetcode_java/src/main/java/LeetCodeJava/Array/NumberOfMatchingSubsequences.java) | _O(n + w)_ | _O(1)_ | Medium |basic, hash map, google| AGAIN**** (2)
 794 | [Valid Tic-Tac-Toe State](https://leetcode.com/problems/valid-tic-tac-toe-state/) | [Python](./leetcode_python/Array/valid-tic-tac-toe-state.py) | _O(1)_ | _O(1)_ | Medium |`complex`| AGAIN 
 795 | [Number of Subarrays with Bounded Maximum](https://leetcode.com/problems/number-of-subarrays-with-bounded-maximum/) | [Python](./leetcode_python/Array/number-of-subarrays-with-bounded-maximum.py) | _O(n)_ | _O(1)_ | Medium || AGAIN (not start*)

data/progress.md

@@ -1,5 +1,8 @@
 # Progress
 
+# 2024-12-31
+- https://github.com/yennanliu/CS_basics/blob/master/doc/Leetcode_company_frequency-master/Google%206months-%20LeetCode.pdf
+
 # 2024-12-29
 - https://github.com/yennanliu/CS_basics/blob/master/doc/Leetcode_company_frequency-master/Google%206months-%20LeetCode.pdf
 

data/progress.txt

@@ -1,3 +1,4 @@
+20241231: 769
 20241229: 498(again),934
 20241228: 379,173,855(todo)
 20241227: 079,212(todo),362,849

data/to_review.txt

@@ -1,34 +1,39 @@
+2025-02-24 -> ['769']
 2025-02-22 -> ['498(again),934']
 2025-02-21 -> ['379,173,855(todo)']
 2025-02-20 -> ['079,212(todo),362,849']
 2025-02-15 -> ['369,311']
 2025-02-14 -> ['370']
 2025-02-13 -> ['815,871,593,1109']
 2025-02-07 -> ['560,523']
+2025-02-03 -> ['769']
 2025-02-01 -> ['498(again),934', '304,853,325']
 2025-01-31 -> ['379,173,855(todo)']
 2025-01-30 -> ['079,212(todo),362,849']
 2025-01-26 -> ['370(todo)']
 2025-01-25 -> ['369,311']
 2025-01-24 -> ['370', '34,767']
 2025-01-23 -> ['815,871,593,1109']
+2025-01-21 -> ['769']
 2025-01-20 -> ['722,380']
 2025-01-19 -> ['498(again),934', '33,81']
 2025-01-18 -> ['379,173,855(todo)']
 2025-01-17 -> ['079,212(todo),362,849', '560,523', '253']
 2025-01-16 -> ['776,31']
 2025-01-15 -> ['004(todo),34(todo),162(todo),275(todo)']
 2025-01-14 -> ['986(todo),1229(todo),1868(todo),80(todo),209(todo),283(todo),360(todo),713(todo),532(todo),611(todo)']
+2025-01-13 -> ['769']
 2025-01-12 -> ['369,311']
 2025-01-11 -> ['498(again),934', '370', '304,853,325', '394']
 2025-01-10 -> ['379,173,855(todo)', '815,871,593,1109', '833,950']
 2025-01-09 -> ['079,212(todo),362,849']
+2025-01-08 -> ['769']
 2025-01-06 -> ['498(again),934']
-2025-01-05 -> ['379,173,855(todo)', '370(todo)']
+2025-01-05 -> ['769', '379,173,855(todo)', '370(todo)']
 2025-01-04 -> ['079,212(todo),362,849', '369,311', '560,523', '53,210,207']
-2025-01-03 -> ['498(again),934', '370', '34,767', '444']
-2025-01-02 -> ['379,173,855(todo)', '815,871,593,1109', '1188,130,855(again)']
-2025-01-01 -> ['498(again),934', '079,212(todo),362,849']
+2025-01-03 -> ['769', '498(again),934', '370', '34,767', '444']
+2025-01-02 -> ['769', '379,173,855(todo)', '815,871,593,1109', '1188,130,855(again)']
+2025-01-01 -> ['769', '498(again),934', '079,212(todo),362,849']
 2024-12-31 -> ['498(again),934', '379,173,855(todo)']
 2024-12-30 -> ['498(again),934', '379,173,855(todo)', '079,212(todo),362,849', '369,311', '722,380']
 2024-12-29 -> ['379,173,855(todo)', '079,212(todo),362,849', '370', '304,853,325', '33,81']

leetcode_java/src/main/java/LeetCodeJava/Array/MaxChunksToMakeSorted.java

@@ -0,0 +1,129 @@
+package LeetCodeJava.Array;
+
+// https://leetcode.com/problems/max-chunks-to-make-sorted/description/
+// https://leetcode.cn/problems/max-chunks-to-make-sorted/description/
+
+import java.util.Stack;
+
+/**
+ * 769. Max Chunks To Make Sorted
+ * Medium
+ * Topics
+ * Companies
+ * Hint
+ * You are given an integer array arr of length n that represents a permutation of the integers in the range [0, n - 1].
+ *
+ * We split arr into some number of chunks (i.e., partitions), and individually sort each chunk. After concatenating them, the result should equal the sorted array.
+ *
+ * Return the largest number of chunks we can make to sort the array.
+ *
+ *
+ *
+ * Example 1:
+ *
+ * Input: arr = [4,3,2,1,0]
+ * Output: 1
+ * Explanation:
+ * Splitting into two or more chunks will not return the required result.
+ * For example, splitting into [4, 3], [2, 1, 0] will result in [3, 4, 0, 1, 2], which isn't sorted.
+ * Example 2:
+ *
+ * Input: arr = [1,0,2,3,4]
+ * Output: 4
+ * Explanation:
+ * We can split into two chunks, such as [1, 0], [2, 3, 4].
+ * However, splitting into [1, 0], [2], [3], [4] is the highest number of chunks possible.
+ *
+ *
+ * Constraints:
+ *
+ * n == arr.length
+ * 1 <= n <= 10
+ * 0 <= arr[i] < n
+ * All the elements of arr are unique.
+ *
+ */
+public class MaxChunksToMakeSorted {
+
+    // V0
+//    public int maxChunksToSorted(int[] arr) {
+//
+//    }
+
+    // V1-1
+    // https://leetcode.com/problems/max-chunks-to-make-sorted/editorial/
+    // IDEA: PrefixMax and SuffixMin Arrays
+    public int maxChunksToSorted_1_1(int[] arr) {
+        int n = arr.length;
+        int[] prefixMax = arr.clone();
+        int[] suffixMin = arr.clone();
+
+        // Fill the prefixMax array
+        for (int i = 1; i < n; i++) {
+            prefixMax[i] = Math.max(prefixMax[i - 1], prefixMax[i]);
+        }
+
+        // Fill the suffixMin array in reverse order
+        for (int i = n - 2; i >= 0; i--) {
+            suffixMin[i] = Math.min(suffixMin[i + 1], suffixMin[i]);
+        }
+
+        int chunks = 0;
+        for (int i = 0; i < n; i++) {
+            // A new chunk can be created
+            if (i == 0 || suffixMin[i] > prefixMax[i - 1]) {
+                chunks++;
+            }
+        }
+
+        return chunks;
+    }
+
+    // V1-2
+    // https://leetcode.com/problems/max-chunks-to-make-sorted/editorial/
+    // IDEA: Prefix Sums
+    public int maxChunksToSorted_1_2(int[] arr) {
+        int n = arr.length;
+        int chunks = 0, prefixSum = 0, sortedPrefixSum = 0;
+
+        // Iterate over the array
+        for (int i = 0; i < n; i++) {
+            // Update prefix sum of `arr`
+            prefixSum += arr[i];
+            // Update prefix sum of the sorted array
+            sortedPrefixSum += i;
+
+            // If the two sums are equal, the two prefixes contain the same elements; a chunk can be formed
+            if (prefixSum == sortedPrefixSum) {
+                chunks++;
+            }
+        }
+        return chunks;
+    }
+
+    // V1-3
+    // https://leetcode.com/problems/max-chunks-to-make-sorted/editorial/
+    // IDEA:  Monotonic Increasing Stack
+    public int maxChunksToSorted(int[] arr) {
+        int n = arr.length;
+        // Stack to store the maximum elements of each chunk
+        Stack<Integer> monotonicStack = new Stack<>();
+
+        for (int i = 0; i < n; i++) {
+            // Case 1: Current element is larger, starts a new chunk
+            if (monotonicStack.isEmpty() || arr[i] > monotonicStack.peek()) {
+                monotonicStack.push(arr[i]);
+            } else {
+                // Case 2: Merge chunks
+                int maxElement = monotonicStack.peek();
+                while (!monotonicStack.isEmpty() && arr[i] < monotonicStack.peek()) {
+                    monotonicStack.pop();
+                }
+                monotonicStack.push(maxElement);
+            }
+        }
+        return monotonicStack.size();
+    }
+
+    // V2
+}

leetcode_java/src/main/java/dev/workspace6.java

@@ -1131,4 +1131,82 @@ private List<List<Integer>> getIsland(int[][] grid, int x, int y, List<List<Inte
       return cur; // ?
     }
 
+    // LC 769
+    // https://leetcode.com/problems/max-chunks-to-make-sorted/
+    // 3.02 pm - 3.20 pm
+    /**
+     *
+     * We split arr into some number of chunks (i.e., partitions),
+     * and individually sort each chunk. After concatenating them,
+     * the result should equal the sorted array.
+     *
+     *
+     * Return the largest number of chunks we can make to sort the array.
+     *
+     */
+    /**
+     *  IDEA 1) 2 POINTERS ?
+     *
+     *
+     *  exp 1: arr = [4,3,2,1,0] -> res = 1
+     *
+     *  -> sorted arr = [0,1,2,3,4]
+     *
+     *  -> compare before VS after
+     *  ->  [4,3,2,1,0] VS [0,1,2,3,4]
+     *
+     *  -> [4,3,2,1,0]
+     *      i j j j j
+     *
+     *
+     *  exp 2: arr = [1,0,2,3,4] -> res = 4
+     *
+     *  -> sorted arr = [0,1,2,3,4]
+     *
+     *  -> compare before VS after
+     *
+     *  -> [1,0,2,3,4]
+     *      i j
+     *
+     *
+     *
+     *
+     *
+     *
+     */
+    public int maxChunksToSorted(int[] arr) {
+
+      // edge
+      if (arr.length == 1) {
+          return 1;
+      }
+
+      // copy
+      int[] arr_before = arr; // ??
+      Arrays.sort(arr);
+
+      // 2 pointers
+      int res = 1;
+      List<Integer> tmp = new ArrayList<>();
+      for (int i = 0; i < arr.length-1; i++){
+          for(int j = i+1; j < arr_before.length; j++){
+              tmp.add(arr[j]);
+              // copy
+              List<Integer> tmp_copy = tmp; // ???
+              // sort
+              tmp_copy.sort(Integer::compareTo);
+//              if(tmp_copy  == tmp_copy){
+//
+//              }
+          }
+      }
+
+      String x = "abc";
+      String[] x_ = x.split("");
+
+
+
+      return res;
+    }
+
 }