Added tasks 3461-3464

Author: javadev

README.md

@@ -2088,6 +2088,10 @@
 
 | #    |      Title     | Difficulty  | Tag         | Time, ms | Time, %
 |------|----------------|-------------|-------------|----------|--------
+| 3464 |[Maximize the Distance Between Points on a Square](src/main/kotlin/g3401_3500/s3464_maximize_the_distance_between_points_on_a_square)| Hard | Array, Greedy, Binary_Search | 18 | 98.51
+| 3463 |[Check If Digits Are Equal in String After Operations II](src/main/kotlin/g3401_3500/s3463_check_if_digits_are_equal_in_string_after_operations_ii)| Hard | String, Math, Number_Theory, Combinatorics | 38 | 100.00
+| 3462 |[Maximum Sum With at Most K Elements](src/main/kotlin/g3401_3500/s3462_maximum_sum_with_at_most_k_elements)| Medium | Array, Sorting, Greedy, Matrix, Heap_(Priority_Queue) | 139 | 100.00
+| 3461 |[Check If Digits Are Equal in String After Operations I](src/main/kotlin/g3401_3500/s3461_check_if_digits_are_equal_in_string_after_operations_i)| Easy | String, Math, Simulation, Number_Theory, Combinatorics | 3 | 100.00
 | 3459 |[Length of Longest V-Shaped Diagonal Segment](src/main/kotlin/g3401_3500/s3459_length_of_longest_v_shaped_diagonal_segment)| Hard | Array, Dynamic_Programming, Matrix, Memoization | 287 | 100.00
 | 3458 |[Select K Disjoint Special Substrings](src/main/kotlin/g3401_3500/s3458_select_k_disjoint_special_substrings)| Medium | String, Hash_Table, Dynamic_Programming, Sorting, Greedy | 24 | 100.00
 | 3457 |[Eat Pizzas!](src/main/kotlin/g3401_3500/s3457_eat_pizzas)| Medium | Array, Sorting, Greedy | 101 | 90.91
@@ -2109,7 +2113,7 @@
 | 3440 |[Reschedule Meetings for Maximum Free Time II](src/main/kotlin/g3401_3500/s3440_reschedule_meetings_for_maximum_free_time_ii)| Medium | Array, Greedy, Enumeration | 8 | 100.00
 | 3439 |[Reschedule Meetings for Maximum Free Time I](src/main/kotlin/g3401_3500/s3439_reschedule_meetings_for_maximum_free_time_i)| Medium | Array, Greedy, Sliding_Window | 5 | 80.00
 | 3438 |[Find Valid Pair of Adjacent Digits in String](src/main/kotlin/g3401_3500/s3438_find_valid_pair_of_adjacent_digits_in_string)| Easy | String, Hash_Table, Counting | 2 | 93.18
-| 3436 |[Find Valid Emails](src/main/kotlin/g3401_3500/s3436_find_valid_emails)| Easy || 451 | 70.84
+| 3436 |[Find Valid Emails](src/main/kotlin/g3401_3500/s3436_find_valid_emails)| Easy | Database | 451 | 70.84
 | 3435 |[Frequencies of Shortest Supersequences](src/main/kotlin/g3401_3500/s3435_frequencies_of_shortest_supersequences)| Hard | Array, String, Bit_Manipulation, Graph, Enumeration, Topological_Sort | 35 | 100.00
 | 3434 |[Maximum Frequency After Subarray Operation](src/main/kotlin/g3401_3500/s3434_maximum_frequency_after_subarray_operation)| Medium | Array, Hash_Table, Dynamic_Programming, Greedy, Prefix_Sum | 51 | 100.00
 | 3433 |[Count Mentions Per User](src/main/kotlin/g3401_3500/s3433_count_mentions_per_user)| Medium | Array, Math, Sorting, Simulation | 52 | 100.00

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

@@ -0,0 +1,74 @@
+[![](https://img.shields.io/github/stars/javadev/LeetCode-in-Kotlin?label=Stars&style=flat-square)](https://github.com/javadev/LeetCode-in-Kotlin)
+[![](https://img.shields.io/github/forks/javadev/LeetCode-in-Kotlin?label=Fork%20me%20on%20GitHub%20&style=flat-square)](https://github.com/javadev/LeetCode-in-Kotlin/fork)
+
+## 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.
+
+## Solution
+
+```kotlin
+class Solution {
+    fun hasSameDigits(s: String): Boolean {
+        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
+            }
+            k--
+        }
+        return ch[0] == ch[1]
+    }
+}
+```

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

@@ -0,0 +1,74 @@
+[![](https://img.shields.io/github/stars/javadev/LeetCode-in-Kotlin?label=Stars&style=flat-square)](https://github.com/javadev/LeetCode-in-Kotlin)
+[![](https://img.shields.io/github/forks/javadev/LeetCode-in-Kotlin?label=Fork%20me%20on%20GitHub%20&style=flat-square)](https://github.com/javadev/LeetCode-in-Kotlin/fork)
+
+## 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))`
+
+## Solution
+
+```kotlin
+class Solution {
+    fun maxSum(grid: Array<IntArray>, limits: IntArray, k: Int): Long {
+        var l = 0
+        for (i in limits.indices) {
+            l += limits[i]
+        }
+        val dp = IntArray(l)
+        var a = 0
+        for (i in grid.indices) {
+            val lim = limits[i]
+            grid[i].sort()
+            for (j in grid[i].size - lim..<grid[i].size) {
+                dp[a] = grid[i][j]
+                a++
+            }
+        }
+        dp.sort()
+        var sum = 0L
+        for (i in l - 1 downTo l - k) {
+            sum += dp[i].toLong()
+        }
+        return sum
+    }
+}
+```

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

@@ -0,0 +1,128 @@
+[![](https://img.shields.io/github/stars/javadev/LeetCode-in-Kotlin?label=Stars&style=flat-square)](https://github.com/javadev/LeetCode-in-Kotlin)
+[![](https://img.shields.io/github/forks/javadev/LeetCode-in-Kotlin?label=Fork%20me%20on%20GitHub%20&style=flat-square)](https://github.com/javadev/LeetCode-in-Kotlin/fork)
+
+## 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.
+
+## Solution
+
+```kotlin
+class Solution {
+    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 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
+        }
+        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
+    }
+
+    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[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 num1 == num2
+    }
+}
+```