Added tasks 3516-3519

Author: javadev

src/main/java/g3501_3600/s3516_find_closest_person/Solution.java

@@ -0,0 +1,17 @@
+package g3501_3600.s3516_find_closest_person;
+
+// #Easy #Math #2025_04_14_Time_0_ms_(100.00%)_Space_41.20_MB_(_%)
+
+public class Solution {
+    public int findClosest(int x, int y, int z) {
+        int d1 = Math.abs(z - x);
+        int d2 = Math.abs(z - y);
+        if (d1 == d2) {
+            return 0;
+        } else if (d1 < d2) {
+            return 1;
+        } else {
+            return 2;
+        }
+    }
+}

src/main/java/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/java/g3501_3600/s3517_smallest_palindromic_rearrangement_i/Solution.java

@@ -0,0 +1,23 @@
+package g3501_3600.s3517_smallest_palindromic_rearrangement_i;
+
+// #Medium #String #Sorting #Counting_Sort #2025_04_14_Time_33_ms_(100.00%)_Space_46.07_MB_(100.00%)
+
+import java.util.Arrays;
+
+public class Solution {
+    public String smallestPalindrome(String s) {
+        int n = s.length();
+        int m = n / 2;
+        if (n == 1 || n == 2) {
+            return s;
+        }
+        char[] fArr = s.substring(0, m).toCharArray();
+        Arrays.sort(fArr);
+        String f = new String(fArr);
+        StringBuilder rev = new StringBuilder(f).reverse();
+        if (n % 2 == 1) {
+            f += s.charAt(m);
+        }
+        return f + rev;
+    }
+}

src/main/java/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/java/g3501_3600/s3518_smallest_palindromic_rearrangement_ii/Solution.java

@@ -0,0 +1,93 @@
+package g3501_3600.s3518_smallest_palindromic_rearrangement_ii;
+
+// #Hard #String #Hash_Table #Math #Counting #Combinatorics
+// #2025_04_14_Time_34_ms_(100.00%)_Space_45.64_MB_(100.00%)
+
+public class Solution {
+    private static final long MAX_K = 1000001;
+
+    public String smallestPalindrome(String inputStr, int k) {
+        int[] frequency = new int[26];
+        for (int i = 0; i < inputStr.length(); i++) {
+            char ch = inputStr.charAt(i);
+            frequency[ch - 'a']++;
+        }
+        char mid = 0;
+        for (int i = 0; i < 26; i++) {
+            if (frequency[i] % 2 == 1) {
+                mid = (char) ('a' + i);
+                frequency[i]--;
+                break;
+            }
+        }
+        int[] halfFreq = new int[26];
+        int halfLength = 0;
+        for (int i = 0; i < 26; i++) {
+            halfFreq[i] = frequency[i] / 2;
+            halfLength += halfFreq[i];
+        }
+        long totalPerms = multinomial(halfFreq);
+        if (k > totalPerms) {
+            return "";
+        }
+        StringBuilder firstHalfBuilder = new StringBuilder();
+        for (int i = 0; i < halfLength; i++) {
+            for (int c = 0; c < 26; c++) {
+                if (halfFreq[c] > 0) {
+                    halfFreq[c]--;
+                    long perms = multinomial(halfFreq);
+                    if (perms >= k) {
+                        firstHalfBuilder.append((char) ('a' + c));
+                        break;
+                    } else {
+                        k -= (int) perms;
+                        halfFreq[c]++;
+                    }
+                }
+            }
+        }
+        String firstHalf = firstHalfBuilder.toString();
+        String revHalf = new StringBuilder(firstHalf).reverse().toString();
+        String result;
+        if (mid == 0) {
+            result = firstHalf + revHalf;
+        } else {
+            result = firstHalf + mid + revHalf;
+        }
+        return result;
+    }
+
+    private long multinomial(int[] counts) {
+        int tot = 0;
+        for (int cnt : counts) {
+            tot += cnt;
+        }
+        long res = 1;
+        for (int i = 0; i < 26; i++) {
+            int cnt = counts[i];
+            res = res * binom(tot, cnt);
+            if (res >= MAX_K) {
+                return MAX_K;
+            }
+            tot -= cnt;
+        }
+        return res;
+    }
+
+    private long binom(int n, int k) {
+        if (k > n) {
+            return 0;
+        }
+        if (k > n - k) {
+            k = n - k;
+        }
+        long result = 1;
+        for (int i = 1; i <= k; i++) {
+            result = result * (n - i + 1) / i;
+            if (result >= MAX_K) {
+                return MAX_K;
+            }
+        }
+        return result;
+    }
+}

src/main/java/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/java/g3501_3600/s3519_count_numbers_with_non_decreasing_digits/Solution.java

@@ -0,0 +1,99 @@
+package g3501_3600.s3519_count_numbers_with_non_decreasing_digits;
+
+// #Hard #String #Dynamic_Programming #Math #2025_04_14_Time_19_ms_(100.00%)_Space_45.43_MB_(50.00%)
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class Solution {
+    public int countNumbers(String l, String r, int b) {
+        long ans1 = find(r.toCharArray(), b);
+        char[] start = subTractOne(l.toCharArray());
+        long ans2 = find(start, b);
+        return (int) ((ans1 - ans2) % 1000000007L);
+    }
+
+    private long find(char[] arr, int b) {
+        int[] nums = convertNumToBase(arr, b);
+        Long[][][] dp = new Long[nums.length][2][11];
+        return solve(0, nums, 1, b, 0, dp) - 1;
+    }
+
+    private long solve(int i, int[] arr, int tight, int base, int last, Long[][][] dp) {
+        if (i == arr.length) {
+            return 1L;
+        }
+        if (dp[i][tight][last] != null) {
+            return dp[i][tight][last];
+        }
+        int till = base - 1;
+        if (tight == 1) {
+            till = arr[i];
+        }
+        long ans = 0;
+        for (int j = 0; j <= till; j++) {
+            if (j >= last) {
+                ans = (ans + solve(i + 1, arr, tight & (j == arr[i] ? 1 : 0), base, j, dp));
+            }
+        }
+        return dp[i][tight][last] = ans;
+    }
+
+    private char[] subTractOne(char[] arr) {
+        int n = arr.length;
+        int i = n - 1;
+        while (i >= 0 && arr[i] == '0') {
+            arr[i--] = '9';
+        }
+        int x = arr[i] - '0' - 1;
+        arr[i] = (char) (x + '0');
+        int j = 0;
+        int idx = 0;
+        while (j < n && arr[j] == '0') {
+            j++;
+        }
+        char[] res = new char[n - j];
+        for (int k = j; k < n; k++) {
+            res[idx++] = arr[k];
+        }
+        return res;
+    }
+
+    private int[] convertNumToBase(char[] arr, int base) {
+        int n = arr.length;
+        int[] num = new int[n];
+        int i = 0;
+        while (i < n) {
+            num[i] = arr[i++] - '0';
+        }
+        List<Integer> temp = new ArrayList<>();
+        int len = n;
+        while (len > 0) {
+            int rem = 0;
+            int[] next = new int[len];
+            int newLen = 0;
+            int j = 0;
+            while (j < len) {
+                long cur = rem * 10L + num[j];
+                int q = (int) (cur / base);
+                rem = (int) (cur % base);
+                if (newLen > 0 || q != 0) {
+                    next[newLen] = q;
+                    newLen++;
+                }
+                j++;
+            }
+            temp.add(rem);
+            num = next;
+            len = newLen;
+        }
+        int[] res = new int[temp.size()];
+        int k = 0;
+        int size = temp.size();
+        while (k < size) {
+            res[k] = temp.get(size - 1 - k);
+            k++;
+        }
+        return res;
+    }
+}