Added tasks 3461-3464

Author: javadev

src/main/kotlin/g3401_3500/s3461_check_if_digits_are_equal_in_string_after_operations_i/Solution.kt

@@ -0,0 +1,20 @@
+package g3401_3500.s3461_check_if_digits_are_equal_in_string_after_operations_i
+
+// #Easy #2025_02_23_Time_8_ms_(100.00%)_Space_37.90_MB_(100.00%)
+
+class Solution {
+    fun hasSameDigits(s: String): Boolean {
+        var s = s
+        var n = s.length
+        while (n > 2) {
+            val nstr = StringBuilder()
+            for (i in 1..<n) {
+                val next = ((s[i].code - '0'.code) + (s[i - 1].code - '0'.code)) % 10
+                nstr.append(next)
+            }
+            n--
+            s = nstr.toString()
+        }
+        return s[0] == s[1]
+    }
+}

src/main/kotlin/g3401_3500/s3461_check_if_digits_are_equal_in_string_after_operations_i/readme.md

@@ -0,0 +1,49 @@
+3461\. Check If Digits Are Equal in String After Operations I
+
+Easy
+
+You are given a string `s` consisting of digits. Perform the following operation repeatedly until the string has **exactly** two digits:
+
+*   For each pair of consecutive digits in `s`, starting from the first digit, calculate a new digit as the sum of the two digits **modulo** 10.
+*   Replace `s` with the sequence of newly calculated digits, _maintaining the order_ in which they are computed.
+
+Return `true` if the final two digits in `s` are the **same**; otherwise, return `false`.
+
+**Example 1:**
+
+**Input:** s = "3902"
+
+**Output:** true
+
+**Explanation:**
+
+*   Initially, `s = "3902"`
+*   First operation:
+    *   `(s[0] + s[1]) % 10 = (3 + 9) % 10 = 2`
+    *   `(s[1] + s[2]) % 10 = (9 + 0) % 10 = 9`
+    *   `(s[2] + s[3]) % 10 = (0 + 2) % 10 = 2`
+    *   `s` becomes `"292"`
+*   Second operation:
+    *   `(s[0] + s[1]) % 10 = (2 + 9) % 10 = 1`
+    *   `(s[1] + s[2]) % 10 = (9 + 2) % 10 = 1`
+    *   `s` becomes `"11"`
+*   Since the digits in `"11"` are the same, the output is `true`.
+
+**Example 2:**
+
+**Input:** s = "34789"
+
+**Output:** false
+
+**Explanation:**
+
+*   Initially, `s = "34789"`.
+*   After the first operation, `s = "7157"`.
+*   After the second operation, `s = "862"`.
+*   After the third operation, `s = "48"`.
+*   Since `'4' != '8'`, the output is `false`.
+
+**Constraints:**
+
+*   `3 <= s.length <= 100`
+*   `s` consists of only digits.

src/main/kotlin/g3401_3500/s3462_maximum_sum_with_at_most_k_elements/Solution.kt

@@ -0,0 +1,34 @@
+package g3401_3500.s3462_maximum_sum_with_at_most_k_elements
+
+// #Medium #2025_02_23_Time_202_ms_(100.00%)_Space_107.52_MB_(100.00%)
+
+import java.util.Collections
+import java.util.PriorityQueue
+
+class Solution {
+    fun maxSum(grid: Array<IntArray>, limits: IntArray, k: Int): Long {
+        if (grid.isEmpty()) {
+            return 0
+        }
+        val pq = PriorityQueue<Int>(Collections.reverseOrder<Int>())
+        var temp: PriorityQueue<Int>?
+        for (i in grid.indices) {
+            temp = PriorityQueue<Int>(Collections.reverseOrder<Int>())
+            for (j in grid[i].indices) {
+                temp.add(grid[i][j])
+            }
+            var cnt = 0
+            while (temp.isNotEmpty() && cnt < limits[i]) {
+                pq.add(temp.poll())
+                cnt += 1
+            }
+        }
+        var result: Long = 0
+        var count: Long = 0
+        while (pq.isNotEmpty() && count < k) {
+            result += pq.poll()!!.toLong()
+            count += 1
+        }
+        return result
+    }
+}

src/main/kotlin/g3401_3500/s3462_maximum_sum_with_at_most_k_elements/readme.md

@@ -0,0 +1,42 @@
+3462\. Maximum Sum With at Most K Elements
+
+Medium
+
+You are given a 2D integer matrix `grid` of size `n x m`, an integer array `limits` of length `n`, and an integer `k`. The task is to find the **maximum sum** of **at most** `k` elements from the matrix `grid` such that:
+
+*   The number of elements taken from the <code>i<sup>th</sup></code> row of `grid` does not exceed `limits[i]`.
+    
+
+Return the **maximum sum**.
+
+**Example 1:**
+
+**Input:** grid = [[1,2],[3,4]], limits = [1,2], k = 2
+
+**Output:** 7
+
+**Explanation:**
+
+*   From the second row, we can take at most 2 elements. The elements taken are 4 and 3.
+*   The maximum possible sum of at most 2 selected elements is `4 + 3 = 7`.
+
+**Example 2:**
+
+**Input:** grid = [[5,3,7],[8,2,6]], limits = [2,2], k = 3
+
+**Output:** 21
+
+**Explanation:**
+
+*   From the first row, we can take at most 2 elements. The element taken is 7.
+*   From the second row, we can take at most 2 elements. The elements taken are 8 and 6.
+*   The maximum possible sum of at most 3 selected elements is `7 + 8 + 6 = 21`.
+
+**Constraints:**
+
+*   `n == grid.length == limits.length`
+*   `m == grid[i].length`
+*   `1 <= n, m <= 500`
+*   <code>0 <= grid[i][j] <= 10<sup>5</sup></code>
+*   `0 <= limits[i] <= m`
+*   `0 <= k <= min(n * m, sum(limits))`

src/main/kotlin/g3401_3500/s3463_check_if_digits_are_equal_in_string_after_operations_ii/Solution.kt

@@ -0,0 +1,57 @@
+package g3401_3500.s3463_check_if_digits_are_equal_in_string_after_operations_ii
+
+// #Hard #2025_02_23_Time_63_ms_(100.00%)_Space_44.31_MB_(100.00%)
+
+class Solution {
+    fun hasSameDigits(s: String): Boolean {
+        val n = s.length
+        val nMunus2 = n - 2
+        var f0 = 0
+        var f1 = 0
+        for (j in 0..nMunus2) {
+            val c = binomMod10(nMunus2, j)
+            f0 = (f0 + c * (s[j].code - '0'.code)) % 10
+            f1 = (f1 + c * (s[j + 1].code - '0'.code)) % 10
+        }
+        return f0 == f1
+    }
+
+    private fun binomMod10(n: Int, k: Int): Int {
+        val r2 = binomMod2(n, k)
+        val r5 = binomMod5(n, k)
+        for (x in 0..9) {
+            if (x % 2 == r2 && x % 5 == r5) {
+                return x
+            }
+        }
+        return 0
+    }
+
+    private fun binomMod2(n: Int, k: Int): Int {
+        return if ((n and k) == k) 1 else 0
+    }
+
+    private fun binomMod5(n: Int, k: Int): Int {
+        var n = n
+        var k = k
+        val t = arrayOf<IntArray?>(
+            intArrayOf(1),
+            intArrayOf(1, 1),
+            intArrayOf(1, 2, 1),
+            intArrayOf(1, 3, 3, 1),
+            intArrayOf(1, 4, 1, 4, 1),
+        )
+        var res = 1
+        while (n > 0 || k > 0) {
+            val nd = n % 5
+            val kd = k % 5
+            if (kd > nd) {
+                return 0
+            }
+            res = (res * t[nd]!![kd]) % 5
+            n /= 5
+            k /= 5
+        }
+        return res
+    }
+}

src/main/kotlin/g3401_3500/s3463_check_if_digits_are_equal_in_string_after_operations_ii/readme.md

@@ -0,0 +1,49 @@
+3463\. Check If Digits Are Equal in String After Operations II
+
+Hard
+
+You are given a string `s` consisting of digits. Perform the following operation repeatedly until the string has **exactly** two digits:
+
+*   For each pair of consecutive digits in `s`, starting from the first digit, calculate a new digit as the sum of the two digits **modulo** 10.
+*   Replace `s` with the sequence of newly calculated digits, _maintaining the order_ in which they are computed.
+
+Return `true` if the final two digits in `s` are the **same**; otherwise, return `false`.
+
+**Example 1:**
+
+**Input:** s = "3902"
+
+**Output:** true
+
+**Explanation:**
+
+*   Initially, `s = "3902"`
+*   First operation:
+    *   `(s[0] + s[1]) % 10 = (3 + 9) % 10 = 2`
+    *   `(s[1] + s[2]) % 10 = (9 + 0) % 10 = 9`
+    *   `(s[2] + s[3]) % 10 = (0 + 2) % 10 = 2`
+    *   `s` becomes `"292"`
+*   Second operation:
+    *   `(s[0] + s[1]) % 10 = (2 + 9) % 10 = 1`
+    *   `(s[1] + s[2]) % 10 = (9 + 2) % 10 = 1`
+    *   `s` becomes `"11"`
+*   Since the digits in `"11"` are the same, the output is `true`.
+
+**Example 2:**
+
+**Input:** s = "34789"
+
+**Output:** false
+
+**Explanation:**
+
+*   Initially, `s = "34789"`.
+*   After the first operation, `s = "7157"`.
+*   After the second operation, `s = "862"`.
+*   After the third operation, `s = "48"`.
+*   Since `'4' != '8'`, the output is `false`.
+
+**Constraints:**
+
+*   <code>3 <= s.length <= 10<sup>5</sup></code>
+*   `s` consists of only digits.

src/main/kotlin/g3401_3500/s3464_maximize_the_distance_between_points_on_a_square/Solution.kt

@@ -0,0 +1,108 @@
+package g3401_3500.s3464_maximize_the_distance_between_points_on_a_square
+
+// #Hard #2025_02_23_Time_159_ms_(100.00%)_Space_67.20_MB_(100.00%)
+
+class Solution {
+    fun maxDistance(sideLength: Int, points: Array<IntArray>, requiredPoints: Int): Int {
+        val perimeter = 4L * sideLength
+        val numPoints = points.size
+        val mappedPositions = LongArray(numPoints)
+        for (i in 0..<numPoints) {
+            mappedPositions[i] = mapToPerimeter(sideLength, points[i][0], points[i][1])
+        }
+        mappedPositions.sort()
+        var low: Long = 0
+        var high = perimeter
+        while (low < high) {
+            val mid = (low + high + 1) / 2
+            if (isValidDistance(mid, requiredPoints, mappedPositions, perimeter)) {
+                low = mid
+            } else {
+                high = mid - 1
+            }
+        }
+        return low.toInt()
+    }
+
+    private fun mapToPerimeter(sideLength: Int, x: Int, y: Int): Long {
+        if (y == sideLength) {
+            return x.toLong()
+        }
+        if (x == sideLength) {
+            return sideLength + (sideLength - y).toLong()
+        }
+        if (y == 0) {
+            return 2L * sideLength + (sideLength - x)
+        }
+        return 3L * sideLength + y
+    }
+
+    private fun isValidDistance(
+        minDistance: Long,
+        requiredPoints: Int,
+        mappedPositions: LongArray,
+        perimeter: Long,
+    ): Boolean {
+        val numPoints = mappedPositions.size
+        val extendedPositions = LongArray(2 * numPoints)
+        for (i in 0..<numPoints) {
+            extendedPositions[i] = mappedPositions[i]
+            extendedPositions[i + numPoints] = mappedPositions[i] + perimeter
+        }
+        for (i in 0..<numPoints) {
+            if (canSelectRequiredPoints(
+                    i,
+                    minDistance,
+                    requiredPoints,
+                    mappedPositions,
+                    extendedPositions,
+                    perimeter,
+                )
+            ) {
+                return true
+            }
+        }
+        return false
+    }
+
+    private fun canSelectRequiredPoints(
+        startIndex: Int,
+        minDistance: Long,
+        requiredPoints: Int,
+        mappedPositions: LongArray,
+        extendedPositions: LongArray,
+        perimeter: Long,
+    ): Boolean {
+        var selectedCount = 1
+        var previousPosition = mappedPositions[startIndex]
+        var currentIndex = startIndex
+        for (i in 1..<requiredPoints) {
+            val targetPosition = previousPosition + minDistance
+            val left = currentIndex + 1
+            val right = startIndex + mappedPositions.size
+            val nextIndex = lowerBound(extendedPositions, left, right, targetPosition)
+            if (nextIndex >= right) {
+                return false
+            }
+            selectedCount++
+            previousPosition = extendedPositions[nextIndex]
+            currentIndex = nextIndex
+        }
+        return selectedCount == requiredPoints &&
+            (previousPosition - mappedPositions[startIndex] <= perimeter - minDistance)
+    }
+
+    private fun lowerBound(arr: LongArray, left: Int, right: Int, target: Long): Int {
+        var left = left
+        var right = right
+        while (left < right) {
+            val mid = left + (right - left) / 2
+            if (arr[mid] >= target) {
+                right = mid
+            } else {
+                left = mid + 1
+            }
+        }
+        return left
+    }
+}