Added tasks 3516-3519

Author: javadev

src/main/kotlin/g3501_3600/s3516_find_closest_person/Solution.kt

@@ -0,0 +1,19 @@
+package g3501_3600.s3516_find_closest_person
+
+// #Easy #Math #2025_04_14_Time_1_ms_(100.00%)_Space_41.06_MB_(100.00%)
+
+import kotlin.math.abs
+
+class Solution {
+    fun findClosest(x: Int, y: Int, z: Int): Int {
+        val d1 = abs(z - x)
+        val d2 = abs(z - y)
+        if (d1 == d2) {
+            return 0
+        } else if (d1 < d2) {
+            return 1
+        } else {
+            return 2
+        }
+    }
+}

src/main/kotlin/g3501_3600/s3516_find_closest_person/readme.md

@@ -0,0 +1,62 @@
+3516\. Find Closest Person
+
+Easy
+
+You are given three integers `x`, `y`, and `z`, representing the positions of three people on a number line:
+
+*   `x` is the position of Person 1.
+*   `y` is the position of Person 2.
+*   `z` is the position of Person 3, who does **not** move.
+
+Both Person 1 and Person 2 move toward Person 3 at the **same** speed.
+
+Determine which person reaches Person 3 **first**:
+
+*   Return 1 if Person 1 arrives first.
+*   Return 2 if Person 2 arrives first.
+*   Return 0 if both arrive at the **same** time.
+
+Return the result accordingly.
+
+**Example 1:**
+
+**Input:** x = 2, y = 7, z = 4
+
+**Output:** 1
+
+**Explanation:**
+
+*   Person 1 is at position 2 and can reach Person 3 (at position 4) in 2 steps.
+*   Person 2 is at position 7 and can reach Person 3 in 3 steps.
+
+Since Person 1 reaches Person 3 first, the output is 1.
+
+**Example 2:**
+
+**Input:** x = 2, y = 5, z = 6
+
+**Output:** 2
+
+**Explanation:**
+
+*   Person 1 is at position 2 and can reach Person 3 (at position 6) in 4 steps.
+*   Person 2 is at position 5 and can reach Person 3 in 1 step.
+
+Since Person 2 reaches Person 3 first, the output is 2.
+
+**Example 3:**
+
+**Input:** x = 1, y = 5, z = 3
+
+**Output:** 0
+
+**Explanation:**
+
+*   Person 1 is at position 1 and can reach Person 3 (at position 3) in 2 steps.
+*   Person 2 is at position 5 and can reach Person 3 in 2 steps.
+
+Since both Person 1 and Person 2 reach Person 3 at the same time, the output is 0.
+
+**Constraints:**
+
+*   `1 <= x, y, z <= 100`

src/main/kotlin/g3501_3600/s3517_smallest_palindromic_rearrangement_i/Solution.kt

@@ -0,0 +1,21 @@
+package g3501_3600.s3517_smallest_palindromic_rearrangement_i
+
+// #Medium #String #Sorting #Counting_Sort #2025_04_14_Time_49_ms_(100.00%)_Space_52.03_MB_(100.00%)
+
+class Solution {
+    fun smallestPalindrome(s: String): String {
+        val n = s.length
+        val m = n / 2
+        if (n == 1 || n == 2) {
+            return s
+        }
+        val fArr = s.substring(0, m).toCharArray()
+        fArr.sort()
+        var f = String(fArr)
+        val rev = StringBuilder(f).reverse()
+        if (n % 2 == 1) {
+            f += s[m]
+        }
+        return f + rev
+    }
+}

src/main/kotlin/g3501_3600/s3517_smallest_palindromic_rearrangement_i/readme.md

@@ -0,0 +1,43 @@
+3517\. Smallest Palindromic Rearrangement I
+
+Medium
+
+You are given a **palindromic** string `s`.
+
+Return the **lexicographically smallest** palindromic permutation of `s`.
+
+**Example 1:**
+
+**Input:** s = "z"
+
+**Output:** "z"
+
+**Explanation:**
+
+A string of only one character is already the lexicographically smallest palindrome.
+
+**Example 2:**
+
+**Input:** s = "babab"
+
+**Output:** "abbba"
+
+**Explanation:**
+
+Rearranging `"babab"` → `"abbba"` gives the smallest lexicographic palindrome.
+
+**Example 3:**
+
+**Input:** s = "daccad"
+
+**Output:** "acddca"
+
+**Explanation:**
+
+Rearranging `"daccad"` → `"acddca"` gives the smallest lexicographic palindrome.
+
+**Constraints:**
+
+*   <code>1 <= s.length <= 10<sup>5</sup></code>
+*   `s` consists of lowercase English letters.
+*   `s` is guaranteed to be palindromic.

src/main/kotlin/g3501_3600/s3518_smallest_palindromic_rearrangement_ii/Solution.kt

@@ -0,0 +1,97 @@
+package g3501_3600.s3518_smallest_palindromic_rearrangement_ii
+
+// #Hard #String #Hash_Table #Math #Counting #Combinatorics
+// #2025_04_14_Time_27_ms_(100.00%)_Space_48.58_MB_(100.00%)
+
+class Solution {
+    fun smallestPalindrome(inputStr: String, k: Int): String {
+        var k = k
+        val frequency = IntArray(26)
+        for (i in 0..<inputStr.length) {
+            val ch = inputStr.get(i)
+            frequency[ch.code - 'a'.code]++
+        }
+        var mid = 0.toChar()
+        for (i in 0..25) {
+            if (frequency[i] % 2 == 1) {
+                mid = ('a'.code + i).toChar()
+                frequency[i]--
+                break
+            }
+        }
+        val halfFreq = IntArray(26)
+        var halfLength = 0
+        for (i in 0..25) {
+            halfFreq[i] = frequency[i] / 2
+            halfLength += halfFreq[i]
+        }
+        val totalPerms = multinomial(halfFreq)
+        if (k > totalPerms) {
+            return ""
+        }
+        val firstHalfBuilder = StringBuilder()
+        for (i in 0..<halfLength) {
+            for (c in 0..25) {
+                if (halfFreq[c] > 0) {
+                    halfFreq[c]--
+                    val perms = multinomial(halfFreq)
+                    if (perms >= k) {
+                        firstHalfBuilder.append(('a'.code + c).toChar())
+                        break
+                    } else {
+                        k -= perms.toInt()
+                        halfFreq[c]++
+                    }
+                }
+            }
+        }
+        val firstHalf = firstHalfBuilder.toString()
+        val revHalf = StringBuilder(firstHalf).reverse().toString()
+        val result: String
+        if (mid.code == 0) {
+            result = firstHalf + revHalf
+        } else {
+            result = firstHalf + mid + revHalf
+        }
+        return result
+    }
+
+    private fun multinomial(counts: IntArray): Long {
+        var tot = 0
+        for (cnt in counts) {
+            tot += cnt
+        }
+        var res: Long = 1
+        for (i in 0..25) {
+            val cnt = counts[i]
+            res = res * binom(tot, cnt)
+            if (res >= MAX_K) {
+                return MAX_K
+            }
+            tot -= cnt
+        }
+        return res
+    }
+
+    private fun binom(n: Int, k: Int): Long {
+        var k = k
+        if (k > n) {
+            return 0
+        }
+        if (k > n - k) {
+            k = n - k
+        }
+        var result: Long = 1
+        for (i in 1..k) {
+            result = result * (n - i + 1) / i
+            if (result >= MAX_K) {
+                return MAX_K
+            }
+        }
+        return result
+    }
+
+    companion object {
+        private const val MAX_K: Long = 1000001
+    }
+}

src/main/kotlin/g3501_3600/s3518_smallest_palindromic_rearrangement_ii/readme.md

@@ -0,0 +1,49 @@
+3518\. Smallest Palindromic Rearrangement II
+
+Hard
+
+You are given a **palindromic** string `s` and an integer `k`.
+
+Return the **k-th** **lexicographically smallest** palindromic permutation of `s`. If there are fewer than `k` distinct palindromic permutations, return an empty string.
+
+**Note:** Different rearrangements that yield the same palindromic string are considered identical and are counted once.
+
+**Example 1:**
+
+**Input:** s = "abba", k = 2
+
+**Output:** "baab"
+
+**Explanation:**
+
+*   The two distinct palindromic rearrangements of `"abba"` are `"abba"` and `"baab"`.
+*   Lexicographically, `"abba"` comes before `"baab"`. Since `k = 2`, the output is `"baab"`.
+
+**Example 2:**
+
+**Input:** s = "aa", k = 2
+
+**Output:** ""
+
+**Explanation:**
+
+*   There is only one palindromic rearrangement: `"aa"`.
+*   The output is an empty string since `k = 2` exceeds the number of possible rearrangements.
+
+**Example 3:**
+
+**Input:** s = "bacab", k = 1
+
+**Output:** "abcba"
+
+**Explanation:**
+
+*   The two distinct palindromic rearrangements of `"bacab"` are `"abcba"` and `"bacab"`.
+*   Lexicographically, `"abcba"` comes before `"bacab"`. Since `k = 1`, the output is `"abcba"`.
+
+**Constraints:**
+
+*   <code>1 <= s.length <= 10<sup>4</sup></code>
+*   `s` consists of lowercase English letters.
+*   `s` is guaranteed to be palindromic.
+*   <code>1 <= k <= 10<sup>6</sup></code>

src/main/kotlin/g3501_3600/s3519_count_numbers_with_non_decreasing_digits/Solution.kt

@@ -0,0 +1,98 @@
+package g3501_3600.s3519_count_numbers_with_non_decreasing_digits
+
+// #Hard #String #Dynamic_Programming #Math
+// #2025_04_14_Time_31_ms_(100.00%)_Space_46.39_MB_(100.00%)
+
+class Solution {
+    fun countNumbers(l: String, r: String, b: Int): Int {
+        val ans1 = find(r.toCharArray(), b)
+        val start = subTractOne(l.toCharArray())
+        val ans2 = find(start, b)
+        return ((ans1 - ans2) % 1000000007L).toInt()
+    }
+
+    private fun find(arr: CharArray, b: Int): Long {
+        val nums = convertNumToBase(arr, b)
+        val dp = Array<Array<Array<Long?>>>(nums.size) { Array<Array<Long?>>(2) { arrayOfNulls<Long>(11) } }
+        return solve(0, nums, 1, b, 0, dp) - 1
+    }
+
+    private fun solve(i: Int, arr: IntArray, tight: Int, base: Int, last: Int, dp: Array<Array<Array<Long?>>>): Long {
+        if (i == arr.size) {
+            return 1L
+        }
+        if (dp[i][tight][last] != null) {
+            return dp[i][tight][last]!!
+        }
+        var till = base - 1
+        if (tight == 1) {
+            till = arr[i]
+        }
+        var ans: Long = 0
+        for (j in 0..till) {
+            if (j >= last) {
+                ans = (ans + solve(i + 1, arr, tight and (if (j == arr[i]) 1 else 0), base, j, dp))
+            }
+        }
+        dp[i][tight][last] = ans
+        return ans
+    }
+
+    private fun subTractOne(arr: CharArray): CharArray {
+        val n = arr.size
+        var i = n - 1
+        while (i >= 0 && arr[i] == '0') {
+            arr[i--] = '9'
+        }
+        val x = arr[i].code - '0'.code - 1
+        arr[i] = (x + '0'.code).toChar()
+        var j = 0
+        var idx = 0
+        while (j < n && arr[j] == '0') {
+            j++
+        }
+        val res = CharArray(n - j)
+        for (k in j..<n) {
+            res[idx++] = arr[k]
+        }
+        return res
+    }
+
+    private fun convertNumToBase(arr: CharArray, base: Int): IntArray {
+        val n = arr.size
+        var num = IntArray(n)
+        var i = 0
+        while (i < n) {
+            num[i] = arr[i++].code - '0'.code
+        }
+        val temp: MutableList<Int?> = ArrayList<Int?>()
+        var len = n
+        while (len > 0) {
+            var rem = 0
+            val next = IntArray(len)
+            var newLen = 0
+            var j = 0
+            while (j < len) {
+                val cur = rem * 10L + num[j]
+                val q = (cur / base).toInt()
+                rem = (cur % base).toInt()
+                if (newLen > 0 || q != 0) {
+                    next[newLen] = q
+                    newLen++
+                }
+                j++
+            }
+            temp.add(rem)
+            num = next
+            len = newLen
+        }
+        val res = IntArray(temp.size)
+        var k = 0
+        val size = temp.size
+        while (k < size) {
+            res[k] = temp[size - 1 - k]!!
+            k++
+        }
+        return res
+    }
+}