Added tasks 3663-3671

Author: javadev

src/main/kotlin/g3601_3700/s3663_find_the_least_frequent_digit/Solution.kt

@@ -0,0 +1,28 @@
+package g3601_3700.s3663_find_the_least_frequent_digit
+
+// #Easy #Biweekly_Contest_164 #2025_08_31_Time_3_ms_(100.00%)_Space_41.13_MB_(100.00%)
+
+import kotlin.math.min
+
+class Solution {
+    fun getLeastFrequentDigit(n: Int): Int {
+        val s = n.toString()
+        val k = s.length
+        val freq: MutableMap<Int, Int> = HashMap<Int, Int>()
+        for (i in 0..<k) {
+            val digit = s.get(i).code - '0'.code
+            freq.put(digit, freq.getOrDefault(digit, 0) + 1)
+        }
+        var minfreq = Int.Companion.MAX_VALUE
+        for (it in freq.entries) {
+            minfreq = min(minfreq, it.value)
+        }
+        var result = 10
+        for (it in freq.entries) {
+            if (it.value == minfreq) {
+                result = min(result, it.key)
+            }
+        }
+        return result
+    }
+}

src/main/kotlin/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/kotlin/g3601_3700/s3664_two_letter_card_game/Solution.kt

@@ -0,0 +1,57 @@
+package g3601_3700.s3664_two_letter_card_game
+
+// #Medium #Biweekly_Contest_164 #2025_08_31_Time_11_ms_(100.00%)_Space_82.34_MB_(_%)
+
+import kotlin.math.min
+
+class Solution {
+    fun score(cards: Array<String>, x: Char): Int {
+        // store input midway as required
+        // counts for "x?" group by second char and "?x" group by first char
+        val left = IntArray(10)
+        val right = IntArray(10)
+        var xx = 0
+        for (c in cards) {
+            val a = c[0]
+            val b = c[1]
+            if (a == x && b == x) {
+                xx++
+            } else if (a == x) {
+                left[b.code - 'a'.code]++
+            } else if (b == x) {
+                right[a.code - 'a'.code]++
+            }
+        }
+        // max pairs inside a group where pairs must come from different buckets:
+        // pairs = min(total/2, total - maxBucket)
+        var l = 0
+        var maxL = 0
+        for (v in left) {
+            l += v
+            if (v > maxL) {
+                maxL = v
+            }
+        }
+        var r = 0
+        var maxR = 0
+        for (v in right) {
+            r += v
+            if (v > maxR) {
+                maxR = v
+            }
+        }
+        val pairsLeft = min(l / 2, l - maxL)
+        val pairsRight = min(r / 2, r - maxR)
+        // leftovers after internal pairing
+        val leftoverL = l - 2 * pairsLeft
+        val leftoverR = r - 2 * pairsRight
+        val leftovers = leftoverL + leftoverR
+        // First, use "xx" to pair with any leftovers
+        val useWithXX = min(xx, leftovers)
+        val 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
+        val extraByBreaking = min(xxLeft / 2, pairsLeft + pairsRight)
+        return pairsLeft + pairsRight + useWithXX + extraByBreaking
+    }
+}

src/main/kotlin/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/kotlin/g3601_3700/s3665_twisted_mirror_path_count/Solution.kt

@@ -0,0 +1,46 @@
+package g3601_3700.s3665_twisted_mirror_path_count
+
+// #Medium #Biweekly_Contest_164 #2025_08_31_Time_114_ms_(100.00%)_Space_120.02_MB_(100.00%)
+
+class Solution {
+    fun uniquePaths(grid: Array<IntArray>): Int {
+        val n = grid.size
+        val m = grid[0].size
+        val dp = Array<Array<IntArray>>(n) { Array<IntArray>(m) { IntArray(2) } }
+        for (i in 0..<n) {
+            for (j in 0..<m) {
+                dp[i][j].fill(-1)
+            }
+        }
+        return f(0, 0, 0, grid, n, m, dp)
+    }
+
+    private fun f(i: Int, j: Int, dir: Int, grid: Array<IntArray>, n: Int, m: Int, dp: Array<Array<IntArray>>): Int {
+        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]
+        }
+        var ways: Long = 0
+        if (grid[i][j] == 1) {
+            ways = if (dir == 0) {
+                f(i + 1, j, 1, grid, n, m, dp).toLong()
+            } else {
+                f(i, j + 1, 0, grid, n, m, dp).toLong()
+            }
+        } else {
+            ways += f(i + 1, j, 1, grid, n, m, dp).toLong()
+            ways += f(i, j + 1, 0, grid, n, m, dp).toLong()
+        }
+        dp[i][j][dir] = ways.toInt() % MOD
+        return dp[i][j][dir]
+    }
+
+    companion object {
+        private const val MOD = 1000000007
+    }
+}

src/main/kotlin/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/kotlin/g3601_3700/s3666_minimum_operations_to_equalize_binary_string/Solution.kt

@@ -0,0 +1,66 @@
+package g3601_3700.s3666_minimum_operations_to_equalize_binary_string
+
+// #Hard #Biweekly_Contest_164 #2025_08_31_Time_29_ms_(100.00%)_Space_48.47_MB_(100.00%)
+
+import java.util.ArrayDeque
+import java.util.Queue
+import kotlin.math.max
+import kotlin.math.min
+
+class Solution {
+    fun minOperations(s: String, k: Int): Int {
+        val zeros = s.chars().map { x: Int -> if (x == '0'.code) 1 else 0 }.sum()
+        if ((zeros % k) == 0) {
+            return zeros / k
+        }
+        val n = s.length
+        val q: Queue<Int> = ArrayDeque<Int>()
+        q.add(zeros)
+        var res = 1
+        // use bounds for optimization
+        val bounds = Array<IntArray>(2) { IntArray(2) }
+        bounds[zeros and 1][1] = zeros
+        bounds[zeros and 1][0] = bounds[zeros and 1][1]
+        bounds[1 - (zeros and 1)][0] = Int.Companion.MAX_VALUE
+        bounds[1 - (zeros and 1)][1] = Int.Companion.MIN_VALUE
+        while (!q.isEmpty()) {
+            // find min number of zeros and max number of zeros in this round
+            var minv = Int.Companion.MAX_VALUE
+            var maxv = Int.Companion.MIN_VALUE
+            for (len in q.size downTo 1) {
+                val h: Int = q.poll()
+                val t = n - h
+                var x = min(h, k)
+                if (t >= k - x) {
+                    val fst = h - x + (k - x)
+                    minv = min(minv, fst)
+                    maxv = max(maxv, fst)
+                }
+                x = min(t, k)
+                if (h >= k - x) {
+                    val snd = h - (k - x) + x
+                    minv = min(minv, snd)
+                    maxv = max(maxv, snd)
+                }
+            }
+            // possible children are sequence of equal difference 2
+            val ind = minv and 1
+            var 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] = min(bounds[ind][0], minv)
+            bounds[ind][1] = max(bounds[ind][1], maxv)
+            res++
+        }
+        return -1
+    }
+}