Improved tasks

Author: javadev

src/main/kotlin/g3401_3500/s3436_find_valid_emails/script.sql

@@ -1,5 +1,5 @@
 # Write your MySQL query statement below
-# #Easy #2025_02_04_Time_451_ms_(70.84%)_Space_0.0_MB_(100.00%)
+# #Easy #Database #2025_02_04_Time_451_ms_(70.84%)_Space_0.0_MB_(100.00%)
 select user_id, email from users
 where email regexp '^[A-Za-z0-9_]+@[A-Za-z][A-Za-z0-9_]*\.com$'
 order by user_id

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

@@ -1,20 +1,22 @@
 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%)
+// #Easy #String #Math #Simulation #Number_Theory #Combinatorics
+// #2025_02_25_Time_3_ms_(100.00%)_Space_35.54_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)
+        val ch = s.toCharArray()
+        var k = ch.size - 1
+        while (k != 1) {
+            for (i in 0..<k) {
+                val a = ch[i].code - 48
+                val b = ch[i + 1].code - 48
+                val d = (a + b) % 10
+                val c = (d + '0'.code).toChar()
+                ch[i] = c
             }
-            n--
-            s = nstr.toString()
+            k--
         }
-        return s[0] == s[1]
+        return ch[0] == ch[1]
     }
 }

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

@@ -1,6 +1,7 @@
 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%)
+// #Medium #Array #Sorting #Greedy #Matrix #Heap_(Priority_Queue)
+// #2025_02_25_Time_197_ms_(86.21%)_Space_106.34_MB_(6.90%)
 
 import java.util.Collections
 import java.util.PriorityQueue
@@ -11,7 +12,7 @@ class Solution {
             return 0
         }
         val pq = PriorityQueue<Int>(Collections.reverseOrder<Int>())
-        var temp: PriorityQueue<Int>?
+        var temp: PriorityQueue<Int>
         for (i in grid.indices) {
             temp = PriorityQueue<Int>(Collections.reverseOrder<Int>())
             for (j in grid[i].indices) {

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

@@ -1,57 +1,76 @@
 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%)
+// #Hard #String #Math #Number_Theory #Combinatorics
+// #2025_02_25_Time_38_ms_(100.00%)_Space_45.90_MB_(11.11%)
 
 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
+    private fun powMod10(a: Int, n: Int): Int {
+        var a = a
+        var n = n
+        var x = 1
+        while (n >= 1) {
+            if (n % 2 == 1) {
+                x = (x * a) % 10
+            }
+            a = (a * a) % 10
+            n /= 2
         }
-        return f0 == f1
+        return x
     }
 
-    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
+    private fun f(n: Int): IntArray {
+        val ns = IntArray(n + 1)
+        val n2 = IntArray(n + 1)
+        val n5 = IntArray(n + 1)
+        ns[0] = 1
+        for (i in 1..n) {
+            var m = i
+            n2[i] = n2[i - 1]
+            n5[i] = n5[i - 1]
+            while (m % 2 == 0) {
+                m /= 2
+                n2[i]++
             }
+            while (m % 5 == 0) {
+                m /= 5
+                n5[i]++
+            }
+            ns[i] = (ns[i - 1] * m) % 10
         }
-        return 0
-    }
-
-    private fun binomMod2(n: Int, k: Int): Int {
-        return if ((n and k) == k) 1 else 0
+        val inv = IntArray(10)
+        for (i in 1..9) {
+            for (j in 0..9) {
+                if (i * j % 10 == 1) {
+                    inv[i] = j
+                }
+            }
+        }
+        val xs = IntArray(n + 1)
+        for (k in 0..n) {
+            var a = 0
+            val s2 = n2[n] - n2[n - k] - n2[k]
+            val s5 = n5[n] - n5[n - k] - n5[k]
+            if (s2 == 0 || s5 == 0) {
+                a = (ns[n] * inv[ns[n - k]] * inv[ns[k]] * powMod10(2, s2) * powMod10(5, s5)) % 10
+            }
+            xs[k] = a
+        }
+        return xs
     }
 
-    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
+    fun hasSameDigits(s: String): Boolean {
+        val n = s.length
+        val xs = f(n - 2)
+        val arr = IntArray(n)
+        for (i in 0..<n) {
+            arr[i] = s.get(i).code - '0'.code
+        }
+        var num1 = 0
+        var num2 = 0
+        for (i in 0..<n - 1) {
+            num1 = (num1 + xs[i] * arr[i]) % 10
+            num2 = (num2 + xs[i] * arr[i + 1]) % 10
         }
-        return res
+        return num1 == num2
     }
 }

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

@@ -1,108 +1,77 @@
 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%)
+// #Hard #Array #Greedy #Binary_Search #2025_02_25_Time_18_ms_(98.51%)_Space_49.78_MB_(46.27%)
 
 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
+    fun maxDistance(side: Int, points: Array<IntArray>, k: Int): Int {
+        val n = points.size
+        val p = LongArray(n)
+        for (i in 0..<n) {
+            val x = points[i][0]
+            val y = points[i][1]
+            val c: Long
+            if (y == 0) {
+                c = x.toLong()
+            } else if (x == side) {
+                c = side + y.toLong()
+            } else if (y == side) {
+                c = 2L * side + (side - x)
             } else {
-                high = mid - 1
+                c = 3L * side + (side - y)
             }
+            p[i] = c
         }
-        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)
+        p.sort()
+        val c = 4L * side
+        val tot = 2 * n
+        val dArr = LongArray(tot)
+        for (i in 0..<n) {
+            dArr[i] = p[i]
+            dArr[i + n] = p[i] + c
         }
-        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
+        var lo = 0
+        var hi = 2 * side
+        var ans = 0
+        while (lo <= hi) {
+            val mid = (lo + hi) ushr 1
+            if (check(mid, dArr, n, k, c)) {
+                ans = mid
+                lo = mid + 1
+            } else {
+                hi = mid - 1
             }
         }
-        return false
+        return ans
     }
 
-    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
+    private fun check(d: Int, dArr: LongArray, n: Int, k: Int, c: Long): Boolean {
+        val len = dArr.size
+        val nxt = IntArray(len)
+        var j = 0
+        for (i in 0..<len) {
+            if (j < i + 1) {
+                j = i + 1
+            }
+            while (j < len && dArr[j] < dArr[i] + d) {
+                j++
             }
-            selectedCount++
-            previousPosition = extendedPositions[nextIndex]
-            currentIndex = nextIndex
+            nxt[i] = if (j < len) j else -1
         }
-        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
+        for (i in 0..<n) {
+            var cnt = 1
+            var cur = i
+            while (cnt < k) {
+                val nx = nxt[cur]
+                if (nx == -1 || nx >= i + n) {
+                    break
+                }
+                cur = nx
+                cnt++
+            }
+            if (cnt == k && (dArr[i] + c - dArr[cur]) >= d) {
+                return true
             }
         }
-        return left
+        return false
     }
 }