fix cheatsheet Liquid templating error for Jekyll deploy

Author: yennanliu

doc/cheatsheet/backtrack.md

@@ -100,7 +100,7 @@ These are often **permutation problems**, where:
 - You **should revisit** earlier choices (sometimes)
 
 
--> Don’t use `start_idx` when:
+-> Don't use `start_idx` when:
 - You're generating **permutations**
 - You need **all orderings**
 - Choices are not sequential (e.g., trying all positions)
@@ -789,10 +789,10 @@ if (i > 0 && nums[i] == nums[i - 1] && !used[i - 1])
 
 // dfsFind(board, word, x+1, y, visited, start_idx + 1)
 
-//  1) You’re passing a copy of start_idx + 1 to the recursive function. So, inside the recursive call, start_idx is a new variable, and changes to it won’t affect the start_idx in the calling function.
+//  1) You're passing a copy of start_idx + 1 to the recursive function. So, inside the recursive call, start_idx is a new variable, and changes to it won't affect the start_idx in the calling function.
 
 
-// 2) We don’t need start_idx -= 1; because start_idx is passed by value, not by reference. So modifying it in the recursive call doesn’t affect the caller’s start_idx. We’re already handling the correct index in each recursive call by passing start_idx + 1.
+// 2) We don't need start_idx -= 1; because start_idx is passed by value, not by reference. So modifying it in the recursive call doesn't affect the caller's start_idx. We're already handling the correct index in each recursive call by passing start_idx + 1.
 
 ```
 
@@ -1092,7 +1092,7 @@ private boolean dfs_(char[][] board, int y, int x, int idx, String word, boolean
     /** NOTE !!! we update visited on x, y here */
     visited[y][x] = true;
 
-    int[][] dirs = {{0, 1}, {0, -1}, {1, 0}, {-1, 0}};
+    int[][] dirs = { {0, 1}, {0, -1}, {1, 0}, {-1, 0} };
     /**
      *  NOTE !!!
      *
@@ -1198,13 +1198,13 @@ class Solution(object):
 // V0'
 // IDEA : Backtracking
 // https://leetcode.com/problems/subsets/editorial/
-    List<List<Integer>> output = new ArrayList();
+    List<List<Integer>> output = new ArrayList<>();
     int n, k;
 
     public void backtrack(int first, ArrayList<Integer> curr, int[] nums) {
         // if the combination is done
         if (curr.size() == k) {
-            output.add(new ArrayList(curr));
+            output.add(new ArrayList<>(curr));
             return;
         }
         /** NOTE HERE !!!
@@ -1701,9 +1701,9 @@ private void backtrack(String s, int start, List<String> currentList) {
  *
  *  •   This is the base case of the recursion.
  *
- *  •   It means: “If we’ve reached the end of the string,
+ *  •   It means: "If we've reached the end of the string,
  *       then the current list of substrings (currentList)
- *       forms a valid full partition of s into palindromes.”
+ *       forms a valid full partition of s into palindromes."
  *
  *  •   -> So we add a copy of currentList into
  *         the final result list partitionRes.
@@ -1712,9 +1712,9 @@ private void backtrack(String s, int start, List<String> currentList) {
  *  - Why start == s.length()?
  *
  *  •   Because start is the index from which
- *      we’re currently trying to partition.
+ *      we're currently trying to partition.
  *
- *  •   If start == s.length(), it means we’ve
+ *  •   If start == s.length(), it means we've
  *       used up all characters in s, and currentList is now a full,
  *       valid partition.
  */
@@ -2039,5 +2039,4 @@ private boolean dfs(int crs, Map<Integer, List<Integer>> preMap, Set<Integer> vi
     visiting.remove(crs);
     preMap.get(crs).clear(); // Clear prerequisites as the course is confirmed to be processed
     return true;
-}
-```
+}

doc/cheatsheet/bfs.md

@@ -437,8 +437,8 @@ class Solution:
         for x, y in q:
             # get the distance from a gate
             distance = rooms[x][y]+1
-            directions = [(-1,0), (1,0), (0,-1), (0,1)]
-            for dx, dy in directions:
+            dirs = { {1, 0}, {-1, 0}, {0, 1}, {0, -1} }
+            for dx, dy in dirs:
                 # find the INF around the gate
                 new_x, new_y = x+dx, y+dy
                 if 0 <= new_x < row and 0 <= new_y < col and rooms[new_x][new_y] == 2147483647:
@@ -484,7 +484,7 @@ class Solution:
 
         int space_cnt = 0;
         int gete_cnt = 0;
-        int[][] dirs = {{1, 0}, {-1, 0}, {0, 1}, {0, -1}};
+        int[][] dirs = { {1, 0}, {-1, 0}, {0, 1}, {0, -1} };
 
         int len = rooms.length;
         int width = rooms[0].length;
@@ -1033,7 +1033,7 @@ public int[][] updateMatrix_0_1(int[][] mat) {
              *
              * * You perform a **BFS for every 1** in the matrix.
              * * In worst case, you scan the whole matrix **once per 1**.
-             * * That’s **O(N × M × (N + M))** — very slow for large inputs.
+             * * That's **O(N × M × (N + M))** — very slow for large inputs.
              *
              * ---
              *
@@ -1043,7 +1043,7 @@ public int[][] updateMatrix_0_1(int[][] mat) {
              *
              * #### Why this works:
              *
-             * * You flip the problem: instead of asking *“how far is this 1 from a 0?”*, you ask *“how far can each 0 reach a 1?”*
+             * * You flip the problem: instead of asking *"how far is this 1 from a 0?"*, you ask *"how far can each 0 reach a 1?"*
              * * When you expand from all 0s **at the same time**, you ensure that **each 1 gets the shortest path to a 0**, because BFS guarantees minimum-distance traversal.
              * * Time complexity is **O(N × M)** — each cell is visited only once.
              *
@@ -1057,7 +1057,7 @@ public int[][] updateMatrix_0_1(int[][] mat) {
         }
     }
 
-    int[][] dirs = { { 0, 1 }, { 1, 0 }, { 0, -1 }, { -1, 0 } };
+    int[][] dirs = { {1, 0}, {-1, 0}, {0, 1}, {0, -1} };
 
     // 2️⃣ BFS from all 0s
     while (!queue.isEmpty()) {

doc/cheatsheet/dfs.md

@@ -284,7 +284,7 @@ _is_island(grid, x, y-1, seen);
 // V2
 // private boolean _is_island_2(char[][] grid, int x, int y, boolean[][] seen) {}
 
-int[][] directions = {{1, 0}, {-1, 0}, {0, 1}, {0, -1}};
+int[][] directions = { {1, 0}, {-1, 0}, {0, 1}, {0, -1} };
 
 for (int[] dir : directions) {
     int newX = x + dir[0];
@@ -1771,7 +1771,7 @@ private void reveal_1(char[][] board, int x, int y) {
  *         and avoid unnecessary recursion.
  *
  *   - 3) board[x][y] != 'E'
- *   •  Avoids re-processing non-‘E’ cells
+ *   •  Avoids re-processing non-‘E' cells
  *   •  The board can have:
  *      •   'M' → Mine (already handled separately)
  *      •   'X' → Clicked mine (game over case)
@@ -1795,7 +1795,7 @@ private void reveal_1(char[][] board, int x, int y) {
  *          •   Counts 1 mine nearby → Updates board[0][0] = '1'
  *          •   Does NOT recurse further, avoiding unnecessary work.
  *
- *      What If We Didn’t Check board[x][y] != 'E'?
+ *      What If We Didn't Check board[x][y] != 'E'?
  *          •   It might try to expand into already processed cells, leading to redundant computations or infinite recursion.
  *
  */

doc/cheatsheet/java_trick.md

@@ -325,7 +325,7 @@ public List<List<Integer>> levelOrder(TreeNode root) {
 *
 *    •   res is a List<List<Integer>>, where each inner list represents a level of the tree.
 *    •   res.get(depth) retrieves the list at the given depth.
-*    •   .add(curRoot.val) adds the current node’s value to the corresponding depth level.
+*    •   .add(curRoot.val) adds the current node's value to the corresponding depth level.
 *
 */
 
@@ -1254,7 +1254,7 @@ return true;
 ```java
 // java
 // LC 417
-public int[][] DIRECTIONS = new int[][]{{0, 1}, {1, 0}, {-1, 0}, {0, -1}};
+public int[][] DIRECTIONS = new int[][]{ {0, 1}, {1, 0}, {-1, 0}, {0, -1} };
 ```
 
 ### 1-18) Arrays.fill (1 D)
@@ -1640,7 +1640,7 @@ orderMap[order.charAt(i) - 'a'] = i;
 
 ### 🔍 What's happening?
 
-Let’s say:
+Let's say:
 ```java
 order = "hlabcdefgijkmnopqrstuvwxyz";
 ```

doc/cheatsheet/matrix.md

@@ -466,15 +466,15 @@ class Solution(object):
 *   -> so we have 3 layer loop as below:
 *    - i : Iterates over the rows of  A  (outer loop).
 *    - j : Iterates over the columns of  B  (second loop).
-*    - k : Iterates over the “shared dimension” (columns of  A  or rows of  B ) to compute the dot product (inner loop).
+*    - k : Iterates over the "shared dimension" (columns of  A  or rows of  B ) to compute the dot product (inner loop).
 *
 *
 *  ->
 *
 *  The Role of the Loops
 *    1.  Outer loop ( i ): Iterates over the rows of mat1 to calculate each row of the result matrix.
 *    2.  Middle loop ( j ): Iterates over the columns of mat2 to compute each element in a row of the result matrix.
-*    3.  Inner loop ( k ): Iterates over the “shared dimension” to compute the dot product of the  i^{th}  row of mat1 and the  j^{th}  column of mat2.
+*    3.  Inner loop ( k ): Iterates over the "shared dimension" to compute the dot product of the  i^{th}  row of mat1 and the  j^{th}  column of mat2.
 *
 *
 * ->  Why the Inner Loop ( k ) Exists ?
@@ -488,7 +488,7 @@ class Solution(object):
 public static int[][] multiply(int[][] mat1, int[][] mat2) {
     // Edge case: Single element matrices
     if (mat1.length == 1 && mat1[0].length == 1 && mat2.length == 1 && mat2[0].length == 1) {
-        return new int[][]{{mat1[0][0] * mat2[0][0]}};
+        return new int[][]{ {mat1[0][0] * mat2[0][0]} };
     }
 
     int l_1 = mat1.length;    // Number of rows in mat1

ref_code/CtCI-6th-Edition-master/.project

@@ -14,4 +14,15 @@
 	<natures>
 		<nature>org.eclipse.jdt.core.javanature</nature>
 	</natures>
+	<filteredResources>
+		<filter>
+			<id>1751452257593</id>
+			<name></name>
+			<type>30</type>
+			<matcher>
+				<id>org.eclipse.core.resources.regexFilterMatcher</id>
+				<arguments>node_modules|\.git|__CREATED_BY_JAVA_LANGUAGE_SERVER__</arguments>
+			</matcher>
+		</filter>
+	</filteredResources>
 </projectDescription>

ref_code/crack_code/Cracking-the-Coding-Interview_solutions-master/.project

@@ -14,4 +14,15 @@
 	<natures>
 		<nature>org.eclipse.jdt.core.javanature</nature>
 	</natures>
+	<filteredResources>
+		<filter>
+			<id>1751452257582</id>
+			<name></name>
+			<type>30</type>
+			<matcher>
+				<id>org.eclipse.core.resources.regexFilterMatcher</id>
+				<arguments>node_modules|\.git|__CREATED_BY_JAVA_LANGUAGE_SERVER__</arguments>
+			</matcher>
+		</filter>
+	</filteredResources>
 </projectDescription>

ref_code/crack_code/CtCI-6th-Edition-master/.project

@@ -14,4 +14,15 @@
 	<natures>
 		<nature>org.eclipse.jdt.core.javanature</nature>
 	</natures>
+	<filteredResources>
+		<filter>
+			<id>1751452257597</id>
+			<name></name>
+			<type>30</type>
+			<matcher>
+				<id>org.eclipse.core.resources.regexFilterMatcher</id>
+				<arguments>node_modules|\.git|__CREATED_BY_JAVA_LANGUAGE_SERVER__</arguments>
+			</matcher>
+		</filter>
+	</filteredResources>
 </projectDescription>