Added tasks 3663-3671

Author: javadev

src/main/java/g3601_3700/s3663_find_the_least_frequent_digit/Solution.java

@@ -0,0 +1,29 @@
+package g3601_3700.s3663_find_the_least_frequent_digit;
+
+// #Easy #Biweekly_Contest_164 #2025_08_31_Time_4_ms_(100.00%)_Space_41.21_MB_(100.00%)
+
+import java.util.HashMap;
+import java.util.Map;
+
+public class Solution {
+    public int getLeastFrequentDigit(int n) {
+        String s = String.valueOf(n);
+        int k = s.length();
+        Map<Integer, Integer> freq = new HashMap<>();
+        for (int i = 0; i < k; i++) {
+            int digit = s.charAt(i) - '0';
+            freq.put(digit, freq.getOrDefault(digit, 0) + 1);
+        }
+        int minfreq = Integer.MAX_VALUE;
+        for (Map.Entry<Integer, Integer> it : freq.entrySet()) {
+            minfreq = Math.min(minfreq, it.getValue());
+        }
+        int result = 10;
+        for (Map.Entry<Integer, Integer> it : freq.entrySet()) {
+            if (it.getValue() == minfreq) {
+                result = Math.min(result, it.getKey());
+            }
+        }
+        return result;
+    }
+}

src/main/java/g3601_3700/s3663_find_the_least_frequent_digit/readme.md

@@ -0,0 +1,33 @@
+3663\. Find The Least Frequent Digit
+
+Easy
+
+Given an integer `n`, find the digit that occurs **least** frequently in its decimal representation. If multiple digits have the same frequency, choose the **smallest** digit.
+
+Return the chosen digit as an integer.
+
+The **frequency** of a digit `x` is the number of times it appears in the decimal representation of `n`.
+
+**Example 1:**
+
+**Input:** n = 1553322
+
+**Output:** 1
+
+**Explanation:**
+
+The least frequent digit in `n` is 1, which appears only once. All other digits appear twice.
+
+**Example 2:**
+
+**Input:** n = 723344511
+
+**Output:** 2
+
+**Explanation:**
+
+The least frequent digits in `n` are 7, 2, and 5; each appears only once.
+
+**Constraints:**
+
+*   <code>1 <= n <= 2<sup>31</sup> - 1</code>

src/main/java/g3601_3700/s3664_two_letter_card_game/Solution.java

@@ -0,0 +1,55 @@
+package g3601_3700.s3664_two_letter_card_game;
+
+// #Medium #Biweekly_Contest_164 #2025_08_31_Time_8_ms_(99.42%)_Space_60.09_MB_(52.34%)
+
+public class Solution {
+    public int score(String[] cards, char x) {
+        // store input midway as required
+        // counts for "x?" group by second char and "?x" group by first char
+        int[] left = new int[10];
+        int[] right = new int[10];
+        int xx = 0;
+        for (String c : cards) {
+            char a = c.charAt(0);
+            char b = c.charAt(1);
+            if (a == x && b == x) {
+                xx++;
+            } else if (a == x) {
+                left[b - 'a']++;
+            } else if (b == x) {
+                right[a - 'a']++;
+            }
+        }
+        // max pairs inside a group where pairs must come from different buckets:
+        // pairs = min(total/2, total - maxBucket)
+        int l = 0;
+        int maxL = 0;
+        for (int v : left) {
+            l += v;
+            if (v > maxL) {
+                maxL = v;
+            }
+        }
+        int r = 0;
+        int maxR = 0;
+        for (int v : right) {
+            r += v;
+            if (v > maxR) {
+                maxR = v;
+            }
+        }
+        int pairsLeft = Math.min(l / 2, l - maxL);
+        int pairsRight = Math.min(r / 2, r - maxR);
+        // leftovers after internal pairing
+        int leftoverL = l - 2 * pairsLeft;
+        int leftoverR = r - 2 * pairsRight;
+        int leftovers = leftoverL + leftoverR;
+        // First, use "xx" to pair with any leftovers
+        int useWithXX = Math.min(xx, leftovers);
+        int xxLeft = xx - useWithXX;
+        // If "xx" still remain, we can break existing internal pairs:
+        // breaking 1 internal pair frees 2 cards, which can pair with 2 "xx" to gain +1 net point
+        int extraByBreaking = Math.min(xxLeft / 2, pairsLeft + pairsRight);
+        return pairsLeft + pairsRight + useWithXX + extraByBreaking;
+    }
+}

src/main/java/g3601_3700/s3664_two_letter_card_game/readme.md

@@ -0,0 +1,58 @@
+3664\. Two-Letter Card Game
+
+Medium
+
+You are given a deck of cards represented by a string array `cards`, and each card displays two lowercase letters.
+
+You are also given a letter `x`. You play a game with the following rules:
+
+*   Start with 0 points.
+*   On each turn, you must find two **compatible** cards from the deck that both contain the letter `x` in any position.
+*   Remove the pair of cards and earn **1 point**.
+*   The game ends when you can no longer find a pair of compatible cards.
+
+Return the **maximum** number of points you can gain with optimal play.
+
+Two cards are **compatible** if the strings differ in **exactly** 1 position.
+
+**Example 1:**
+
+**Input:** cards = ["aa","ab","ba","ac"], x = "a"
+
+**Output:** 2
+
+**Explanation:**
+
+*   On the first turn, select and remove cards `"ab"` and `"ac"`, which are compatible because they differ at only index 1.
+*   On the second turn, select and remove cards `"aa"` and `"ba"`, which are compatible because they differ at only index 0.
+
+Because there are no more compatible pairs, the total score is 2.
+
+**Example 2:**
+
+**Input:** cards = ["aa","ab","ba"], x = "a"
+
+**Output:** 1
+
+**Explanation:**
+
+*   On the first turn, select and remove cards `"aa"` and `"ba"`.
+
+Because there are no more compatible pairs, the total score is 1.
+
+**Example 3:**
+
+**Input:** cards = ["aa","ab","ba","ac"], x = "b"
+
+**Output:** 0
+
+**Explanation:**
+
+The only cards that contain the character `'b'` are `"ab"` and `"ba"`. However, they differ in both indices, so they are not compatible. Thus, the output is 0.
+
+**Constraints:**
+
+*   <code>2 <= cards.length <= 10<sup>5</sup></code>
+*   `cards[i].length == 2`
+*   Each `cards[i]` is composed of only lowercase English letters between `'a'` and `'j'`.
+*   `x` is a lowercase English letter between `'a'` and `'j'`.

src/main/java/g3601_3700/s3665_twisted_mirror_path_count/Solution.java

@@ -0,0 +1,45 @@
+package g3601_3700.s3665_twisted_mirror_path_count;
+
+// #Medium #Biweekly_Contest_164 #2025_08_31_Time_204_ms_(100.00%)_Space_86.33_MB_(100.00%)
+
+import java.util.Arrays;
+
+public class Solution {
+    private static final int MOD = 1000000007;
+
+    public int uniquePaths(int[][] grid) {
+        int n = grid.length;
+        int m = grid[0].length;
+        int[][][] dp = new int[n][m][2];
+        for (int i = 0; i < n; i++) {
+            for (int j = 0; j < m; j++) {
+                Arrays.fill(dp[i][j], -1);
+            }
+        }
+        return f(0, 0, 0, grid, n, m, dp);
+    }
+
+    private int f(int i, int j, int dir, int[][] grid, int n, int m, int[][][] dp) {
+        if (i == n - 1 && j == m - 1) {
+            return 1;
+        }
+        if (i >= n || j >= m) {
+            return 0;
+        }
+        if (dp[i][j][dir] != -1) {
+            return dp[i][j][dir];
+        }
+        long ways = 0;
+        if (grid[i][j] == 1) {
+            if (dir == 0) {
+                ways = f(i + 1, j, 1, grid, n, m, dp);
+            } else {
+                ways = f(i, j + 1, 0, grid, n, m, dp);
+            }
+        } else {
+            ways += f(i + 1, j, 1, grid, n, m, dp);
+            ways += f(i, j + 1, 0, grid, n, m, dp);
+        }
+        return dp[i][j][dir] = (int) ways % MOD;
+    }
+}

src/main/java/g3601_3700/s3665_twisted_mirror_path_count/readme.md

@@ -0,0 +1,75 @@
+3665\. Twisted Mirror Path Count
+
+Medium
+
+Given an `m x n` binary grid `grid` where:
+
+*   `grid[i][j] == 0` represents an empty cell, and
+*   `grid[i][j] == 1` represents a mirror.
+
+A robot starts at the top-left corner of the grid `(0, 0)` and wants to reach the bottom-right corner `(m - 1, n - 1)`. It can move only **right** or **down**. If the robot attempts to move into a mirror cell, it is **reflected** before entering that cell:
+
+*   If it tries to move **right** into a mirror, it is turned **down** and moved into the cell directly below the mirror.
+*   If it tries to move **down** into a mirror, it is turned **right** and moved into the cell directly to the right of the mirror.
+
+If this reflection would cause the robot to move outside the `grid` boundaries, the path is considered invalid and should not be counted.
+
+Return the number of unique valid paths from `(0, 0)` to `(m - 1, n - 1)`.
+
+Since the answer may be very large, return it **modulo** <code>10<sup>9</sup> + 7</code>.
+
+**Note**: If a reflection moves the robot into a mirror cell, the robot is immediately reflected again based on the direction it used to enter that mirror: if it entered while moving right, it will be turned down; if it entered while moving down, it will be turned right. This process will continue until either the last cell is reached, the robot moves out of bounds or the robot moves to a non-mirror cell.
+
+**Example 1:**
+
+**Input:** grid = [[0,1,0],[0,0,1],[1,0,0]]
+
+**Output:** 5
+
+**Explanation:**
+
+| Number | Full Path                                                           |
+|--------|---------------------------------------------------------------------|
+| 1      | (0, 0) → (0, 1) [M] → (1, 1) → (1, 2) [M] → (2, 2)                  |
+| 2      | (0, 0) → (0, 1) [M] → (1, 1) → (2, 1) → (2, 2)                      |
+| 3      | (0, 0) → (1, 0) → (1, 1) → (1, 2) [M] → (2, 2)                      |
+| 4      | (0, 0) → (1, 0) → (1, 1) → (2, 1) → (2, 2)                          |
+| 5      | (0, 0) → (1, 0) → (2, 0) [M] → (2, 1) → (2, 2)                      |
+
+*   `[M]` indicates the robot attempted to enter a mirror cell and instead reflected.
+    
+
+**Example 2:**
+
+**Input:** grid = [[0,0],[0,0]]
+
+**Output:** 2
+
+**Explanation:**
+
+| Number | Full Path                  |
+|--------|-----------------------------|
+| 1      | (0, 0) → (0, 1) → (1, 1)   |
+| 2      | (0, 0) → (1, 0) → (1, 1)   |
+
+**Example 3:**
+
+**Input:** grid = [[0,1,1],[1,1,0]]
+
+**Output:** 1
+
+**Explanation:**
+
+| Number | Full Path                                 |
+|--------|-------------------------------------------|
+| 1      | (0, 0) → (0, 1) [M] → (1, 1) [M] → (1, 2) |
+
+`(0, 0) → (1, 0) [M] → (1, 1) [M] → (2, 1)` goes out of bounds, so it is invalid.
+
+**Constraints:**
+
+*   `m == grid.length`
+*   `n == grid[i].length`
+*   `2 <= m, n <= 500`
+*   `grid[i][j]` is either `0` or `1`.
+*   `grid[0][0] == grid[m - 1][n - 1] == 0`

src/main/java/g3601_3700/s3666_minimum_operations_to_equalize_binary_string/Solution.java

@@ -0,0 +1,63 @@
+package g3601_3700.s3666_minimum_operations_to_equalize_binary_string;
+
+// #Hard #Biweekly_Contest_164 #2025_08_31_Time_22_ms_(100.00%)_Space_45.62_MB_(100.00%)
+
+import java.util.ArrayDeque;
+import java.util.Queue;
+
+public class Solution {
+    public int minOperations(String s, int k) {
+        int zeros = s.chars().map(x -> x == '0' ? 1 : 0).sum();
+        if ((zeros % k) == 0) {
+            return zeros / k;
+        }
+        int n = s.length();
+        Queue<Integer> q = new ArrayDeque<>();
+        q.add(zeros);
+        int res = 1;
+        // use bounds for optimization
+        int[][] bounds = new int[2][2];
+        bounds[zeros & 1][0] = bounds[zeros & 1][1] = zeros;
+        bounds[1 - (zeros & 1)][0] = Integer.MAX_VALUE;
+        bounds[1 - (zeros & 1)][1] = Integer.MIN_VALUE;
+        while (!q.isEmpty()) {
+            // find min number of zeros and max number of zeros in this round
+            int minv = Integer.MAX_VALUE;
+            int maxv = Integer.MIN_VALUE;
+            for (int len = q.size(); len > 0; len--) {
+                int h = q.poll();
+                int t = n - h;
+                int x = Math.min(h, k);
+                if (t >= k - x) {
+                    int fst = h - x + (k - x);
+                    minv = Math.min(minv, fst);
+                    maxv = Math.max(maxv, fst);
+                }
+                x = Math.min(t, k);
+                if (h >= k - x) {
+                    int snd = h - (k - x) + x;
+                    minv = Math.min(minv, snd);
+                    maxv = Math.max(maxv, snd);
+                }
+            }
+            // possible children are sequence of equal difference 2
+            int ind = minv & 1;
+            int temp = minv;
+            while (temp <= maxv) {
+                if ((temp % k) == 0) {
+                    return res + temp / k;
+                }
+                if (temp < bounds[ind][0] || temp > bounds[ind][1]) {
+                    q.add(temp);
+                    temp += 2;
+                } else {
+                    temp = bounds[ind][1] + 2;
+                }
+            }
+            bounds[ind][0] = Math.min(bounds[ind][0], minv);
+            bounds[ind][1] = Math.max(bounds[ind][1], maxv);
+            res++;
+        }
+        return -1;
+    }
+}