Added tasks 3392-3405

Author: javadev

README.md

@@ -43,31 +43,6 @@ public class Solution {
         return false;
     }
 
-    private int noOfDigits(int n) {
-        if (n == 0) {
-            return 1;
-        }
-        return (int) Math.log10(Math.abs(n)) + 1;
-    }
-
-    private boolean check(int num1, int num2) {
-        int[] num = new int[10];
-        while (num1 > 0) {
-            num[num1 % 10]++;
-            num1 /= 10;
-        }
-        while (num2 > 0) {
-            num[num2 % 10]--;
-            num2 /= 10;
-        }
-        for (int i = 0; i < 10; i++) {
-            if (num[i] != 0) {
-                return false;
-            }
-        }
-        return true;
-    }
-
     private int[] countDigits(int num) {
         int[] digitCount = new int[10];
         while (num > 0) {

src/main/java/g0801_0900/s0869_reordered_power_of_2/readme.md

@@ -75,29 +75,93 @@ In this example, there is no need to make any conversions on either day.
 ## Solution
 
 ```java
-import java.util.ArrayDeque;
-
-public class Example {
-    public static void main(String[] args) {
-        ArrayDeque<String> animals = new ArrayDeque<>();
-
-        // "unshift" - Add an element at the beginning of the list
-        animals.addFirst("Cat"); // Adds "Cat" at the front
-        System.out.println("After unshift: " + animals);
-
-        // "push" - Add an element to the end of the list
-        animals.addLast("Dog"); // Adds "Dog" at the end
-        System.out.println("After push: " + animals);
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+@SuppressWarnings("java:S3824")
+public class Solution {
+    private double res;
+    private Map<String, List<Pair>> map1;
+    private Map<String, List<Pair>> map2;
+
+    private static class Pair {
+        String tarcurr;
+        double rate;
+
+        Pair(String t, double r) {
+            tarcurr = t;
+            rate = r;
+        }
+    }
 
-        // "shift" - Remove the first element from the list
-        String shiftedAnimal = animals.removeFirst(); // Removes "Cat"
-        System.out.println("After shift (removed): " + shiftedAnimal);
-        System.out.println("List after shift: " + animals);
+    private void solve(
+            String currCurrency, double value, String targetCurrency, int day, Set<String> used) {
+        if (currCurrency.equals(targetCurrency)) {
+            res = Math.max(res, value);
+            if (day == 2) {
+                return;
+            }
+        }
+        List<Pair> list;
+        if (day == 1) {
+            list = map1.getOrDefault(currCurrency, new ArrayList<>());
+        } else {
+            list = map2.getOrDefault(currCurrency, new ArrayList<>());
+        }
+        for (Pair p : list) {
+            if (used.add(p.tarcurr)) {
+                solve(p.tarcurr, value * p.rate, targetCurrency, day, used);
+                used.remove(p.tarcurr);
+            }
+        }
+        if (day == 1) {
+            solve(currCurrency, value, targetCurrency, day + 1, new HashSet<>());
+        }
+    }
 
-        // "pop" - Remove the last element from the list
-        String poppedAnimal = animals.removeLast(); // Removes "Dog"
-        System.out.println("After pop (removed): " + poppedAnimal);
-        System.out.println("List after pop: " + animals);
+    public double maxAmount(
+            String initialCurrency,
+            List<List<String>> pairs1,
+            double[] rates1,
+            List<List<String>> pairs2,
+            double[] rates2) {
+        map1 = new HashMap<>();
+        map2 = new HashMap<>();
+        int size = pairs1.size();
+        for (int i = 0; i < size; i++) {
+            List<String> curr = pairs1.get(i);
+            String c1 = curr.get(0);
+            String c2 = curr.get(1);
+            if (!map1.containsKey(c1)) {
+                map1.put(c1, new ArrayList<>());
+            }
+            map1.get(c1).add(new Pair(c2, rates1[i]));
+            if (!map1.containsKey(c2)) {
+                map1.put(c2, new ArrayList<>());
+            }
+            map1.get(c2).add(new Pair(c1, 1d / rates1[i]));
+        }
+        size = pairs2.size();
+        for (int i = 0; i < size; i++) {
+            List<String> curr = pairs2.get(i);
+            String c1 = curr.get(0);
+            String c2 = curr.get(1);
+            if (!map2.containsKey(c1)) {
+                map2.put(c1, new ArrayList<>());
+            }
+            map2.get(c1).add(new Pair(c2, rates2[i]));
+            if (!map2.containsKey(c2)) {
+                map2.put(c2, new ArrayList<>());
+            }
+            map2.get(c2).add(new Pair(c1, 1d / rates2[i]));
+        }
+        res = 1d;
+        solve(initialCurrency, 1d, initialCurrency, 1, new HashSet<>());
+        return res;
     }
 }
 ```

src/main/java/g3301_3400/s3387_maximize_amount_after_two_days_of_conversions/readme.md

@@ -0,0 +1,55 @@
+[![](https://img.shields.io/github/stars/javadev/LeetCode-in-Java?label=Stars&style=flat-square)](https://github.com/javadev/LeetCode-in-Java)
+[![](https://img.shields.io/github/forks/javadev/LeetCode-in-Java?label=Fork%20me%20on%20GitHub%20&style=flat-square)](https://github.com/javadev/LeetCode-in-Java/fork)
+
+## 3392\. Count Subarrays of Length Three With a Condition
+
+Easy
+
+Given an integer array `nums`, return the number of subarrays of length 3 such that the sum of the first and third numbers equals _exactly_ half of the second number.
+
+A **subarray** is a contiguous **non-empty** sequence of elements within an array.
+
+**Example 1:**
+
+**Input:** nums = [1,2,1,4,1]
+
+**Output:** 1
+
+**Explanation:**
+
+Only the subarray `[1,4,1]` contains exactly 3 elements where the sum of the first and third numbers equals half the middle number.
+
+**Example 2:**
+
+**Input:** nums = [1,1,1]
+
+**Output:** 0
+
+**Explanation:**
+
+`[1,1,1]` is the only subarray of length 3. However, its first and third numbers do not add to half the middle number.
+
+**Constraints:**
+
+*   `3 <= nums.length <= 100`
+*   `-100 <= nums[i] <= 100`
+
+## Solution
+
+```java
+public class Solution {
+    public int countSubarrays(int[] nums) {
+        int window = 3;
+        int cnt = 0;
+        for (int i = 0; i <= nums.length - window; i++) {
+            float first = nums[i];
+            float second = nums[i + 1];
+            float third = nums[i + 2];
+            if (second / 2 == first + third) {
+                cnt++;
+            }
+        }
+        return cnt;
+    }
+}
+```

src/main/java/g3301_3400/s3392_count_subarrays_of_length_three_with_a_condition/readme.md

@@ -0,0 +1,102 @@
+[![](https://img.shields.io/github/stars/javadev/LeetCode-in-Java?label=Stars&style=flat-square)](https://github.com/javadev/LeetCode-in-Java)
+[![](https://img.shields.io/github/forks/javadev/LeetCode-in-Java?label=Fork%20me%20on%20GitHub%20&style=flat-square)](https://github.com/javadev/LeetCode-in-Java/fork)
+
+## 3393\. Count Paths With the Given XOR Value
+
+Medium
+
+You are given a 2D integer array `grid` with size `m x n`. You are also given an integer `k`.
+
+Your task is to calculate the number of paths you can take from the top-left cell `(0, 0)` to the bottom-right cell `(m - 1, n - 1)` satisfying the following **constraints**:
+
+*   You can either move to the right or down. Formally, from the cell `(i, j)` you may move to the cell `(i, j + 1)` or to the cell `(i + 1, j)` if the target cell _exists_.
+*   The `XOR` of all the numbers on the path must be **equal** to `k`.
+
+Return the total number of such paths.
+
+Since the answer can be very large, return the result **modulo** <code>10<sup>9</sup> + 7</code>.
+
+**Example 1:**
+
+**Input:** grid = \[\[2, 1, 5], [7, 10, 0], [12, 6, 4]], k = 11
+
+**Output:** 3
+
+**Explanation:**
+
+The 3 paths are:
+
+*   `(0, 0) → (1, 0) → (2, 0) → (2, 1) → (2, 2)`
+*   `(0, 0) → (1, 0) → (1, 1) → (1, 2) → (2, 2)`
+*   `(0, 0) → (0, 1) → (1, 1) → (2, 1) → (2, 2)`
+
+**Example 2:**
+
+**Input:** grid = \[\[1, 3, 3, 3], [0, 3, 3, 2], [3, 0, 1, 1]], k = 2
+
+**Output:** 5
+
+**Explanation:**
+
+The 5 paths are:
+
+*   `(0, 0) → (1, 0) → (2, 0) → (2, 1) → (2, 2) → (2, 3)`
+*   `(0, 0) → (1, 0) → (1, 1) → (2, 1) → (2, 2) → (2, 3)`
+*   `(0, 0) → (1, 0) → (1, 1) → (1, 2) → (1, 3) → (2, 3)`
+*   `(0, 0) → (0, 1) → (1, 1) → (1, 2) → (2, 2) → (2, 3)`
+*   `(0, 0) → (0, 1) → (0, 2) → (1, 2) → (2, 2) → (2, 3)`
+
+**Example 3:**
+
+**Input:** grid = \[\[1, 1, 1, 2], [3, 0, 3, 2], [3, 0, 2, 2]], k = 10
+
+**Output:** 0
+
+**Constraints:**
+
+*   `1 <= m == grid.length <= 300`
+*   `1 <= n == grid[r].length <= 300`
+*   `0 <= grid[r][c] < 16`
+*   `0 <= k < 16`
+
+## Solution
+
+```java
+import java.util.Arrays;
+
+public class Solution {
+    private static final int MOD = (int) (1e9 + 7);
+    private int m = -1;
+    private int n = -1;
+    private int[][][] dp;
+
+    public int countPathsWithXorValue(int[][] grid, int k) {
+        m = grid.length;
+        n = grid[0].length;
+        dp = new int[m][n][16];
+        for (int[][] a : dp) {
+            for (int[] b : a) {
+                Arrays.fill(b, -1);
+            }
+        }
+        return dfs(grid, 0, k, 0, 0);
+    }
+
+    private int dfs(int[][] grid, int xorVal, int k, int i, int j) {
+        if (i < 0 || j < 0 || j >= n || i >= m) {
+            return 0;
+        }
+        xorVal ^= grid[i][j];
+        if (dp[i][j][xorVal] != -1) {
+            return dp[i][j][xorVal];
+        }
+        if (i == m - 1 && j == n - 1 && xorVal == k) {
+            return 1;
+        }
+        int down = dfs(grid, xorVal, k, i + 1, j);
+        int right = dfs(grid, xorVal, k, i, j + 1);
+        dp[i][j][xorVal] = (down + right) % MOD;
+        return dp[i][j][xorVal];
+    }
+}
+```