add 498 java

Author: yennanliu

README.md

@@ -251,7 +251,7 @@
 422| [Valid Word Square](https://leetcode.com/problems/valid-word-square/) | [Python](./leetcode_python/Array/valid-word-square.py)  | _O(m * n)_ |  _O(1)_ | Easy |🔒, `basic`, `matrix`| AGAIN*
 442| [Find All Duplicates in an Array](https://leetcode.com/problems/find-all-duplicates-in-an-array/) | [Python](./leetcode_python/Array/find-all-duplicates-in-an-array.py) | _O(n)_ |  _O(1)_ | Medium || OK*
 448| [Find All Numbers Disappeared in an Array](https://leetcode.com/problems/find-all-numbers-disappeared-in-an-array/) | [Python](./leetcode_python/Array/find-all-numbers-disappeared-in-an-array.py)| _O(n)_ |  _O(1)_ | Easy || OK 
-498 | [Diagonal Traverse](https://leetcode.com/problems/diagonal-traverse/) | [Python](./leetcode_python/Array/diagonal_traverse.py) | _O(n)_ | _O(1)_  | Medium |`matrix`,`google`,`fb`| AGAIN*** (3) (not start)
+498 | [Diagonal Traverse](https://leetcode.com/problems/diagonal-traverse/) | [Python](./leetcode_python/Array/diagonal_traverse.py), [Java](./leetcode_java/src/main/java/LeetCodeJava/Array/DiagonalTraverse.java) | _O(n)_ | _O(1)_  | Medium |`matrix`,`google`,`fb`| AGAIN*** (4)
 531 | [Lonely Pixel I](https://leetcode.com/problems/lonely-pixel-i/) |  [Python](./leetcode_python/Array/lonely-pixel-i.py) | _O(m * n)_ | _O(m + n)_ | Medium | 🔒, `matrix`, `basic`| AGAIN*
 533 | [Lonely Pixel II](https://leetcode.com/problems/lonely-pixel-ii/) | [Python](./leetcode_python/Array/lonely-pixel-ii.py)  | _O(m * n)_ | _O(m * n)_ | Medium  |🔒| AGAIN (not start*)
 565 | [Array Nesting](https://leetcode.com/problems/array-nesting/) | [Python](./leetcode_python/Array/array-nesting.py) | _O(n)_ | _O(1)_ | Medium  |`union find`,`dfs`,`apple`| AGAIN**** (1)

data/progress.md

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

data/progress.txt

@@ -1,3 +1,4 @@
+20241229: 498
 20241228: 379,173,855(todo)
 20241227: 079,212(todo),362,849
 20241222: 369,311

data/to_review.txt

@@ -1,36 +1,38 @@
-2025-02-21 -> ['379,173']
-2025-02-20 -> ['079,212(todo),362,849,855(todo)']
+2025-02-22 -> ['498']
+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-01 -> ['304,853,325']
-2025-01-31 -> ['379,173']
-2025-01-30 -> ['079,212(todo),362,849,855(todo)']
+2025-02-01 -> ['498', '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-20 -> ['722,380']
-2025-01-19 -> ['33,81']
-2025-01-18 -> ['379,173']
-2025-01-17 -> ['079,212(todo),362,849,855(todo)', '560,523', '253']
+2025-01-19 -> ['498', '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-12 -> ['369,311']
-2025-01-11 -> ['370', '304,853,325', '394']
-2025-01-10 -> ['379,173', '815,871,593,1109', '833,950']
-2025-01-09 -> ['079,212(todo),362,849,855(todo)']
-2025-01-05 -> ['379,173', '370(todo)']
-2025-01-04 -> ['079,212(todo),362,849,855(todo)', '369,311', '560,523', '53,210,207']
-2025-01-03 -> ['370', '34,767', '444']
-2025-01-02 -> ['379,173', '815,871,593,1109', '1188,130,855(again)']
-2025-01-01 -> ['079,212(todo),362,849,855(todo)']
-2024-12-31 -> ['379,173']
-2024-12-30 -> ['379,173', '079,212(todo),362,849,855(todo)', '369,311', '722,380']
-2024-12-29 -> ['379,173', '079,212(todo),362,849,855(todo)', '370', '304,853,325', '33,81']
-2024-12-28 -> ['079,212(todo),362,849,855(todo)', '815,871,593,1109', '900']
+2025-01-11 -> ['498', '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-06 -> ['498']
+2025-01-05 -> ['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', '370', '34,767', '444']
+2025-01-02 -> ['379,173,855(todo)', '815,871,593,1109', '1188,130,855(again)']
+2025-01-01 -> ['498', '079,212(todo),362,849']
+2024-12-31 -> ['498', '379,173,855(todo)']
+2024-12-30 -> ['498', '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']
+2024-12-28 -> ['079,212(todo),362,849', '815,871,593,1109', '900']
 2024-12-27 -> ['369,311', '560,523', '253', '26,27', '802,1197,26']
 2024-12-26 -> ['370', '776,31']
 2024-12-25 -> ['369,311', '815,871,593,1109', '004(todo),34(todo),162(todo),275(todo)']

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

@@ -0,0 +1,184 @@
+package LeetCodeJava.Array;
+
+// https://leetcode.com/problems/diagonal-traverse/description/
+
+import java.util.ArrayList;
+import java.util.Collections;
+
+/**
+ * 498. Diagonal Traverse
+ * Solved
+ * Medium
+ * Topics
+ * Companies
+ * Given an m x n matrix mat, return an array of all the elements of the array in a diagonal order.
+ *
+ *
+ *
+ * Example 1:
+ *
+ *
+ * Input: mat = [[1,2,3],[4,5,6],[7,8,9]]
+ * Output: [1,2,4,7,5,3,6,8,9]
+ * Example 2:
+ *
+ * Input: mat = [[1,2],[3,4]]
+ * Output: [1,2,3,4]
+ *
+ *
+ * Constraints:
+ *
+ * m == mat.length
+ * n == mat[i].length
+ * 1 <= m, n <= 104
+ * 1 <= m * n <= 104
+ * -105 <= mat[i][j] <= 105
+ * Seen this question in a real interview before?
+ *
+ */
+public class DiagonalTraverse {
+
+    // V0
+    // TODO : implement
+//    public int[] findDiagonalOrder(int[][] mat) {
+//
+//    }
+
+    // V1-1
+    // https://leetcode.com/problems/diagonal-traverse/editorial/
+    // IDEA: Diagonal Iteration and Reversal
+    public int[] findDiagonalOrder_1_1(int[][] matrix) {
+
+        // Check for empty matrices
+        if (matrix == null || matrix.length == 0) {
+            return new int[0];
+        }
+
+        // Variables to track the size of the matrix
+        int N = matrix.length;
+        int M = matrix[0].length;
+
+        // The two arrays as explained in the algorithm
+        int[] result = new int[N * M];
+        int k = 0;
+        ArrayList<Integer> intermediate = new ArrayList<Integer>();
+
+        // We have to go over all the elements in the first
+        // row and the last column to cover all possible diagonals
+        for (int d = 0; d < N + M - 1; d++) {
+
+            // Clear the intermediate array every time we start
+            // to process another diagonal
+            intermediate.clear();
+
+            // We need to figure out the "head" of this diagonal
+            // The elements in the first row and the last column
+            // are the respective heads.
+            int r = d < M ? 0 : d - M + 1;
+            int c = d < M ? d : M - 1;
+
+            // Iterate until one of the indices goes out of scope
+            // Take note of the index math to go down the diagonal
+            while (r < N && c > -1) {
+
+                intermediate.add(matrix[r][c]);
+                ++r;
+                --c;
+            }
+
+            // Reverse even numbered diagonals. The
+            // article says we have to reverse odd
+            // numbered articles but here, the numbering
+            // is starting from 0 :P
+            if (d % 2 == 0) {
+                Collections.reverse(intermediate);
+            }
+
+            for (int i = 0; i < intermediate.size(); i++) {
+                result[k++] = intermediate.get(i);
+            }
+        }
+        return result;
+    }
+
+    // V1-2
+    // https://leetcode.com/problems/diagonal-traverse/editorial/
+    // IDEA: Simulation
+    public int[] findDiagonalOrder_1_2(int[][] matrix) {
+
+        // Check for empty matrices
+        if (matrix == null || matrix.length == 0) {
+            return new int[0];
+        }
+
+        // Variables to track the size of the matrix
+        int N = matrix.length;
+        int M = matrix[0].length;
+
+        // Incides that will help us progress through
+        // the matrix, one element at a time.
+        int row = 0, column = 0;
+
+        // As explained in the article, this is the variable
+        // that helps us keep track of what direction we are
+        // processing the current diaonal
+        int direction = 1;
+
+        // The final result array
+        int[] result = new int[N * M];
+        int r = 0;
+
+        // The uber while loop which will help us iterate over all
+        // the elements in the array.
+        while (row < N && column < M) {
+
+            // First and foremost, add the current element to
+            // the result matrix.
+            result[r++] = matrix[row][column];
+
+            // Move along in the current diagonal depending upon
+            // the current direction.[i, j] -> [i - 1, j + 1] if
+            // going up and [i, j] -> [i + 1][j - 1] if going down.
+            int new_row = row + (direction == 1 ? -1 : 1);
+            int new_column = column + (direction == 1 ? 1 : -1);
+
+            // Checking if the next element in the diagonal is within the
+            // bounds of the matrix or not. If it's not within the bounds,
+            // we have to find the next head.
+            if (new_row < 0 || new_row == N || new_column < 0 || new_column == M) {
+
+                // If the current diagonal was going in the upwards
+                // direction.
+                if (direction == 1) {
+
+                    // For an upwards going diagonal having [i, j] as its tail
+                    // If [i, j + 1] is within bounds, then it becomes
+                    // the next head. Otherwise, the element directly below
+                    // i.e. the element [i + 1, j] becomes the next head
+                    row += (column == M - 1 ? 1 : 0);
+                    column += (column < M - 1 ? 1 : 0);
+
+                } else {
+
+                    // For a downwards going diagonal having [i, j] as its tail
+                    // if [i + 1, j] is within bounds, then it becomes
+                    // the next head. Otherwise, the element directly below
+                    // i.e. the element [i, j + 1] becomes the next head
+                    column += (row == N - 1 ? 1 : 0);
+                    row += (row < N - 1 ? 1 : 0);
+                }
+
+                // Flip the direction
+                direction = 1 - direction;
+
+            } else {
+
+                row = new_row;
+                column = new_column;
+            }
+        }
+        return result;
+    }
+
+    // V2
+}

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

@@ -969,4 +969,55 @@ private void getValues(TreeNode root){
       }
   }
 
+  // LC 498
+  // https://leetcode.com/problems/diagonal-traverse/
+  // 4.26 pm - 4,40 pm
+  /**
+   *
+   * Given an m x n matrix mat,
+   * return an array of all the elements of the array
+   * in a diagonal order.
+   *
+   * Exp 1
+   * Input: mat = [[1,2,3],[4,5,6],[7,8,9]]
+   * Output: [1,2,4,7,5,3,6,8,9]
+   *
+   *
+   * Exp 2
+   * Input: mat = [[1,2],[3,4]]
+   * Output: [1,2,3,4]
+   *
+   */
+  /**
+   *  IDEA : ARRAY OP
+   *
+   *  Input: mat = [[1,2,3],[4,5,6],[7,8,9]]
+   *
+   *  -> (0,0) -> (1,0) -> (0,1) -> (2,0) -> (1,1) -> (2,0)
+   *  -> (2,1)
+   *
+   *  ↖ ↘
+   *
+   *
+   *  ->, ↙.
+   *
+   */
+  public int[] findDiagonalOrder(int[][] mat) {
+      // edge
+      if(mat.length == 1 && mat[0].length == 1){
+          return new int[]{mat[0][0]};
+      }
+
+      int l = mat.length;
+      int w = mat[0].length;
+
+      int[] res = new int[l * w];
+
+      int[][] rightUpMove = new int[][]{{1,1}};
+      int[][] leftDownMove = new int[][]{{-1,1}};
+
+
+      return res;
+  }
+
 }