add 932 java

Author: yennanliu

README.md

@@ -299,7 +299,7 @@
 921 | [Minimum Add to Make Parentheses Valid](https://leetcode.com/problems/minimum-add-to-make-parentheses-valid/) | [Python](./leetcode_python/Array/minimum-add-to-make-parentheses-valid.py) | _O(n)_ | _O(1)_  | Medium |`basic`, `trick`| AGAIN** 
 922 | [Sort Array By Parity II](https://leetcode.com/problems/sort-array-by-parity-ii/) | [Python](./leetcode_python/Array/sort-array-by-parity-ii.py) | _O(n)_ | _O(1)_  | Easy |`basic`| AGAIN* 
 923 | [3Sum With Multiplicity](https://leetcode.com/problems/3sum-with-multiplicity/) | [Python](./leetcode_python/Array/3sum-with-multiplicity.py)  | _O(n^2)_ | _O(n)_  | Medium  || AGAIN (not start)
-932 | [Beautiful Array](https://leetcode.com/problems/beautiful-array/) | [Python](./leetcode_python/Array/beautiful-array.py) | _O(n)_ | _O(n)_  | Medium |`basic`, `trick`| AGAIN (not start)
+932 | [Beautiful Array](https://leetcode.com/problems/beautiful-array/) | [Python](./leetcode_python/Array/beautiful-array.py), [Java](./leetcode_java/src/main/java/LeetCodeJava/Array/BeautifulArray.java) | _O(n)_ | _O(n)_  | Medium |`basic`, `trick`, google| AGAIN** (not start) (1)
 941 | [Valid Mountain Array](https://leetcode.com/problems/valid-mountain-array/) | [Python](./leetcode_python/Array/valid-mountain-array.py)  | _O(n)_ | _O(1)_  | Easy  |`basic`, `good basic`| AGAIN* 
 945 | [Minimum Increment to Make Array Unique](https://leetcode.com/problems/minimum-increment-to-make-array-unique/) | [Python](./leetcode_python/Array/minimum-increment-to-make-array-unique.py) | _O(nlogn)_ | _O(n)_    | Medium |`trick`, `good`| AGAIN** 
 947 | [Most Stones Removed with Same Row or Column](https://leetcode.com/problems/most-stones-removed-with-same-row-or-column/) | [Python](./leetcode_python/Array/most-stones-removed-with-same-row-or-column.py), [Java](./leetcode_java/src/main/java/LeetCodeJava/Array/MostStonesRemovedWithSameRowOrColumn.java) | _O(n)_ | _O(n)_   | Medium   | Union Find , dfs, trick,google| AGAIN** (1) (not start)

data/progress.md

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

data/progress.txt

@@ -1,3 +1,4 @@
+20241026: 932
 20241024: 951,792
 20241020: 163,1048
 20241019: 298,729

data/to_review.txt

@@ -1,3 +1,4 @@
+2024-12-20 -> ['932']
 2024-12-18 -> ['951,792']
 2024-12-14 -> ['163,1048']
 2024-12-13 -> ['298,729']
@@ -8,6 +9,7 @@
 2024-12-05 -> ['528,334']
 2024-12-03 -> ['1145']
 2024-11-30 -> ['1145,1219']
+2024-11-29 -> ['932']
 2024-11-27 -> ['951,792', '524,221,889']
 2024-11-26 -> ['743,889']
 2024-11-25 -> ['837']
@@ -17,25 +19,25 @@
 2024-11-20 -> ['939']
 2024-11-18 -> ['430']
 2024-11-17 -> ['737', '363']
-2024-11-16 -> ['686,734,737', '1032,844,1011']
+2024-11-16 -> ['932', '686,734,737', '1032,844,1011']
 2024-11-15 -> ['353', '947']
 2024-11-14 -> ['951,792', '528,334']
 2024-11-12 -> ['1145', '753']
 2024-11-11 -> ['727']
 2024-11-10 -> ['163,1048']
 2024-11-09 -> ['298,729', '1145,1219']
-2024-11-08 -> ['1146']
+2024-11-08 -> ['932', '1146']
 2024-11-06 -> ['951,792', '524,221,889']
 2024-11-05 -> ['743,889']
 2024-11-04 -> ['737', '837', '659']
-2024-11-03 -> ['686,734,737', '801,552']
+2024-11-03 -> ['932', '686,734,737', '801,552']
 2024-11-02 -> ['163,1048', '353', '981', '1057,1066,1110']
 2024-11-01 -> ['951,792', '298,729', '528,334', '1087']
-2024-10-31 -> ['1146']
+2024-10-31 -> ['932', '1146']
 2024-10-30 -> ['1145', '939']
-2024-10-29 -> ['951,792']
-2024-10-28 -> ['163,1048', '430']
-2024-10-27 -> ['951,792', '298,729', '737', '1145,1219', '363']
+2024-10-29 -> ['932', '951,792']
+2024-10-28 -> ['932', '163,1048', '430']
+2024-10-27 -> ['932', '951,792', '298,729', '737', '1145,1219', '363']
 2024-10-26 -> ['951,792', '1146', '686,734,737', '1032,844,1011']
 2024-10-25 -> ['951,792', '163,1048', '353', '947', '1110, 1055']
 2024-10-24 -> ['298,729', '528,334', '524,221,889']

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

@@ -0,0 +1,151 @@
+package LeetCodeJava.Array;
+
+// https://leetcode.com/problems/beautiful-array/description/
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.Map;
+
+/**
+ * 932. Beautiful Array
+ * Medium
+ * Topics
+ * Companies
+ * An array nums of length n is beautiful if:
+ *
+ * nums is a permutation of the integers in the range [1, n].
+ * For every 0 <= i < j < n, there is no index k with i < k < j where 2 * nums[k] == nums[i] + nums[j].
+ * Given the integer n, return any beautiful array nums of length n. There will be at least one valid answer for the given n.
+ *
+ *
+ * Example 1:
+ *
+ * Input: n = 4
+ * Output: [2,1,4,3]
+ * Example 2:
+ *
+ * Input: n = 5
+ * Output: [3,1,2,5,4]
+ *
+ *
+ * Constraints:
+ *
+ * 1 <= n <= 1000
+ *
+ */
+public class BeautifulArray {
+
+    // V0
+//    public int[] beautifulArray(int n) {
+//
+//    }
+
+    // V1
+    // IDEA : Divide and Conquer
+    // https://leetcode.com/problems/beautiful-array/editorial/
+    Map<Integer, int[]> memo;
+    public int[] beautifulArray_1(int N) {
+        memo = new HashMap();
+        return f(N);
+    }
+
+    public int[] f(int N) {
+        if (memo.containsKey(N))
+            return memo.get(N);
+
+        int[] ans = new int[N];
+        if (N == 1) {
+            ans[0] = 1;
+        } else {
+            int t = 0;
+            for (int x: f((N+1)/2))  // odds
+                ans[t++] = 2*x - 1;
+            for (int x: f(N/2))  // evens
+                ans[t++] = 2*x;
+        }
+        memo.put(N, ans);
+        return ans;
+    }
+
+
+    // V2
+    // IDEA : Divide and Conquer
+    // https://leetcode.com/problems/beautiful-array/solutions/1373064/java-clear-thinking-process-divide-and-conquer/
+    public int[] beautifulArray(int n) {
+        int[] ans = new int[n];
+        for(int i = 0; i  < n; i++){
+            ans[i] = i+1;
+        }
+        recursion(ans, 0, n-1);
+        return ans;
+    }
+
+    public void recursion(int[] arr, int left, int right){
+        if(left >= right)
+            return;
+        ArrayList<Integer> l = new ArrayList<>();
+        ArrayList<Integer> r = new ArrayList<>();
+
+        boolean alt = true;// Not worry about whether the factor of the interval is even or odd too much, they can be grouped by
+        // just picking one and skip one
+
+        for(int i = left; i <= right; i++){ // picking the elements and put them into the two groups
+            if(alt)
+                l.add(arr[i]);
+            else
+                r.add(arr[i]);
+            alt = !alt;
+        }
+
+        for(int i = left; i <= right; i++){ // merging them into the final array
+            if(!l.isEmpty())
+                arr[i] = l.remove(0);
+            else
+                arr[i] = r.remove(0);
+        }
+        recursion(arr, left, (right+left)/2);
+        recursion(arr, (left+right)/2+1, right);
+    }
+
+    // V3-1
+    // https://leetcode.com/problems/beautiful-array/solutions/1368607/java-0-ms-100-00-fast-explained-2-solutions/
+    public int[] beautifulArray_3_1(int n) {
+        int[] answer = new int[n];
+        if(n == 1) {
+            answer[0] = 1;
+            return answer;
+        }
+        int[] right =beautifulArray(n/2);
+        int[] left = beautifulArray((n+1)/2);
+
+        for(int i=left.length; i<n; i++) {      //This loop adds all even elements at end
+            answer[i] = right[i-left.length] * 2;
+        }
+        for(int i=0; i<left.length; i++) {      //This loop adds all odd elements at start
+            answer[i] = left[i] * 2 - 1;
+        }
+        return answer;
+    }
+
+    // V3-2
+    // https://leetcode.com/problems/beautiful-array/solutions/1368607/java-0-ms-100-00-fast-explained-2-solutions/
+    public int[] beautifulArray_3_2(int n) {
+        ArrayList<Integer> answer=new ArrayList<>();
+        answer.add(1);
+        while(answer.size()<n){
+            ArrayList<Integer> temp=new ArrayList<>();
+            for(int element:answer)
+                if(2*element-1<=n)
+                    temp.add(element*2-1);
+
+            for(int element:answer)
+                if(2*element<=n)
+                    temp.add(element*2);
+
+            //in different loops because we want to maintain order
+            answer=temp;
+        }
+        return answer.stream().mapToInt(i -> i).toArray();
+    }
+
+}

leetcode_java/src/main/java/dev/workspace5.java

@@ -2065,6 +2065,20 @@ private boolean isSubsequences(String word, String s) {
 //        return i == word.length() - 1;
 //    }
 
+    // LC 932
+    // https://leetcode.com/problems/beautiful-array/
+    /**
+     *
+     * For every 0 <= i < j < n,
+     * there is no index k with i < k < j
+     * where 2 * nums[k] == nums[i] + nums[j].
+     *
+     */
+    public int[] beautifulArray(int n) {
+
+        return null;
+    }
+
 }