Added tasks 3300-3307

Author: javadev

src/main/java/g3201_3300/s3300_minimum_element_after_replacement_with_digit_sum/Solution.java

@@ -0,0 +1,31 @@
+package g3201_3300.s3300_minimum_element_after_replacement_with_digit_sum;
+
+// #Easy #2024_09_30_Time_4_ms_(100.00%)_Space_43.3_MB_(100.00%)
+
+import java.util.Arrays;
+
+public class Solution {
+    public int minElement(int[] nums) {
+        int n = nums.length;
+        int[] arr = new int[n];
+
+        for (int i = 0; i < n; i++) {
+            int sum = sumOfDigits(nums[i]);
+            arr[i] = sum;
+        }
+        Arrays.sort(arr);
+        return arr[0];
+    }
+
+    private int sumOfDigits(int num) {
+        int sum = 0;
+        if (num <= 9) {
+            return num;
+        }
+        while (num > 0) {
+            sum += num % 10;
+            num /= 10;
+        }
+        return sum;
+    }
+}

src/main/java/g3201_3300/s3300_minimum_element_after_replacement_with_digit_sum/readme.md

@@ -0,0 +1,44 @@
+3300\. Minimum Element After Replacement With Digit Sum
+
+Easy
+
+You are given an integer array `nums`.
+
+You replace each element in `nums` with the **sum** of its digits.
+
+Return the **minimum** element in `nums` after all replacements.
+
+**Example 1:**
+
+**Input:** nums = [10,12,13,14]
+
+**Output:** 1
+
+**Explanation:**
+
+`nums` becomes `[1, 3, 4, 5]` after all replacements, with minimum element 1.
+
+**Example 2:**
+
+**Input:** nums = [1,2,3,4]
+
+**Output:** 1
+
+**Explanation:**
+
+`nums` becomes `[1, 2, 3, 4]` after all replacements, with minimum element 1.
+
+**Example 3:**
+
+**Input:** nums = [999,19,199]
+
+**Output:** 10
+
+**Explanation:**
+
+`nums` becomes `[27, 10, 19]` after all replacements, with minimum element 10.
+
+**Constraints:**
+
+*   `1 <= nums.length <= 100`
+*   <code>1 <= nums[i] <= 10<sup>4</sup></code>

src/main/java/g3301_3400/s3301_maximize_the_total_height_of_unique_towers/Solution.java

@@ -0,0 +1,27 @@
+package g3301_3400.s3301_maximize_the_total_height_of_unique_towers;
+
+// #Medium #2024_09_30_Time_49_ms_(100.00%)_Space_57.8_MB_(100.00%)
+
+import java.util.Arrays;
+
+public class Solution {
+    public long maximumTotalSum(int[] maximumHeight) {
+        Arrays.sort(maximumHeight);
+        long result = maximumHeight[maximumHeight.length - 1];
+        long previousHeight = maximumHeight[maximumHeight.length - 1];
+        for (int i = maximumHeight.length - 2; i >= 0; i--) {
+            if (previousHeight == 1) {
+                return -1;
+            }
+            long height = maximumHeight[i];
+            if (height >= previousHeight) {
+                result = result + previousHeight - 1;
+                previousHeight = previousHeight - 1;
+            } else {
+                result = result + height;
+                previousHeight = height;
+            }
+        }
+        return result;
+    }
+}

src/main/java/g3301_3400/s3301_maximize_the_total_height_of_unique_towers/readme.md

@@ -0,0 +1,47 @@
+3301\. Maximize the Total Height of Unique Towers
+
+Medium
+
+You are given an array `maximumHeight`, where `maximumHeight[i]` denotes the **maximum** height the <code>i<sup>th</sup></code> tower can be assigned.
+
+Your task is to assign a height to each tower so that:
+
+1.  The height of the <code>i<sup>th</sup></code> tower is a positive integer and does not exceed `maximumHeight[i]`.
+2.  No two towers have the same height.
+
+Return the **maximum** possible total sum of the tower heights. If it's not possible to assign heights, return `-1`.
+
+**Example 1:**
+
+**Input:** maximumHeight = [2,3,4,3]
+
+**Output:** 10
+
+**Explanation:**
+
+We can assign heights in the following way: `[1, 2, 4, 3]`.
+
+**Example 2:**
+
+**Input:** maximumHeight = [15,10]
+
+**Output:** 25
+
+**Explanation:**
+
+We can assign heights in the following way: `[15, 10]`.
+
+**Example 3:**
+
+**Input:** maximumHeight = [2,2,1]
+
+**Output:** \-1
+
+**Explanation:**
+
+It's impossible to assign positive heights to each index so that no two towers have the same height.
+
+**Constraints:**
+
+*   <code>1 <= maximumHeight.length <= 10<sup>5</sup></code>
+*   <code>1 <= maximumHeight[i] <= 10<sup>9</sup></code>

src/main/java/g3301_3400/s3302_find_the_lexicographically_smallest_valid_sequence/Solution.java

@@ -0,0 +1,39 @@
+package g3301_3400.s3302_find_the_lexicographically_smallest_valid_sequence;
+
+// #Medium #2024_09_30_Time_33_ms_(100.00%)_Space_79.5_MB_(50.00%)
+
+import java.util.Arrays;
+
+public class Solution {
+    public int[] validSequence(String word1, String word2) {
+        int n = word1.length();
+        int m = word2.length();
+        int[] revGreedyMatchInd = new int[m];
+        Arrays.fill(revGreedyMatchInd, -1);
+        {
+            int i = n - 1;
+            int j = m - 1;
+            while (j >= 0 && i >= 0) {
+                if (word1.charAt(i) == word2.charAt(j)) {
+                    revGreedyMatchInd[j--] = i;
+                }
+                i--;
+            }
+        }
+        boolean canSkip = true;
+        int j = 0;
+        int i = 0;
+        while (i < n && j < m && m - j <= n - i) {
+            if (word1.charAt(i) == word2.charAt(j)) {
+                revGreedyMatchInd[j++] = i;
+            } else if (canSkip && (j == m - 1 || i < revGreedyMatchInd[j + 1])) {
+                revGreedyMatchInd[j++] = i;
+                canSkip = false;
+            } else if (!canSkip && revGreedyMatchInd[j] == -1) {
+                break;
+            }
+            i++;
+        }
+        return j == m ? revGreedyMatchInd : new int[0];
+    }
+}

src/main/java/g3301_3400/s3302_find_the_lexicographically_smallest_valid_sequence/readme.md

@@ -0,0 +1,65 @@
+3302\. Find the Lexicographically Smallest Valid Sequence
+
+Medium
+
+You are given two strings `word1` and `word2`.
+
+A string `x` is called **almost equal** to `y` if you can change **at most** one character in `x` to make it _identical_ to `y`.
+
+A sequence of indices `seq` is called **valid** if:
+
+*   The indices are sorted in **ascending** order.
+*   _Concatenating_ the characters at these indices in `word1` in **the same** order results in a string that is **almost equal** to `word2`.
+
+Return an array of size `word2.length` representing the lexicographically smallest **valid** sequence of indices. If no such sequence of indices exists, return an **empty** array.
+
+**Note** that the answer must represent the _lexicographically smallest array_, **not** the corresponding string formed by those indices.
+
+**Example 1:**
+
+**Input:** word1 = "vbcca", word2 = "abc"
+
+**Output:** [0,1,2]
+
+**Explanation:**
+
+The lexicographically smallest valid sequence of indices is `[0, 1, 2]`:
+
+*   Change `word1[0]` to `'a'`.
+*   `word1[1]` is already `'b'`.
+*   `word1[2]` is already `'c'`.
+
+**Example 2:**
+
+**Input:** word1 = "bacdc", word2 = "abc"
+
+**Output:** [1,2,4]
+
+**Explanation:**
+
+The lexicographically smallest valid sequence of indices is `[1, 2, 4]`:
+
+*   `word1[1]` is already `'a'`.
+*   Change `word1[2]` to `'b'`.
+*   `word1[4]` is already `'c'`.
+
+**Example 3:**
+
+**Input:** word1 = "aaaaaa", word2 = "aaabc"
+
+**Output:** []
+
+**Explanation:**
+
+There is no valid sequence of indices.
+
+**Example 4:**
+
+**Input:** word1 = "abc", word2 = "ab"
+
+**Output:** [0,1]
+
+**Constraints:**
+
+*   <code>1 <= word2.length < word1.length <= 3 * 10<sup>5</sup></code>
+*   `word1` and `word2` consist only of lowercase English letters.

src/main/java/g3301_3400/s3303_find_the_occurrence_of_first_almost_equal_substring/Solution.java

@@ -0,0 +1,49 @@
+package g3301_3400.s3303_find_the_occurrence_of_first_almost_equal_substring;
+
+// #Hard #2024_09_30_Time_1198_ms_(100.00%)_Space_97.4_MB_(100.00%)
+
+import java.util.HashMap;
+import java.util.Map;
+
+public class Solution {
+    public int minStartingIndex(String s, String p) {
+        Map<Long, Integer> mp = new HashMap<>();
+        long hash = 0;
+        long base = 26;
+        long d = 1;
+        long hashP = 0;
+        long mod = 10000000000283L;
+        int n = s.length();
+        int sz = p.length();
+        // Rolling hash for string s
+        for (int i = 0; i < n; i++) {
+            hash = (hash * base + s.charAt(i)) % mod;
+            if (i >= sz) {
+                hash = (mod + hash - d * s.charAt(i - sz) % mod) % mod;
+            } else {
+                d = d * base % mod;
+            }
+            if (i >= sz - 1 && !mp.containsKey(hash)) {
+                mp.put(hash, i - sz + 1);
+            }
+        }
+        // Hash for the pattern p
+        for (int i = 0; i < sz; i++) {
+            hashP = (hashP * base + p.charAt(i)) % mod;
+        }
+        d = 1;
+        int ans = Integer.MAX_VALUE;
+        // Find the minimum index with almost equal string
+        for (int i = sz - 1; i >= 0; i--) {
+            long newhashP = (mod + hashP - d * p.charAt(i) % mod) % mod;
+            for (char a = 'a'; a <= 'z'; a++) {
+                long candidateHash = (newhashP + d * a % mod) % mod;
+                if (mp.containsKey(candidateHash)) {
+                    ans = Math.min(ans, mp.get(candidateHash));
+                }
+            }
+            d = d * base % mod;
+        }
+        return ans == Integer.MAX_VALUE ? -1 : ans;
+    }
+}

src/main/java/g3301_3400/s3303_find_the_occurrence_of_first_almost_equal_substring/readme.md

@@ -0,0 +1,50 @@
+3303\. Find the Occurrence of First Almost Equal Substring
+
+Hard
+
+You are given two strings `s` and `pattern`.
+
+A string `x` is called **almost equal** to `y` if you can change **at most** one character in `x` to make it _identical_ to `y`.
+
+Return the **smallest** _starting index_ of a substring in `s` that is **almost equal** to `pattern`. If no such index exists, return `-1`.
+
+A **substring** is a contiguous **non-empty** sequence of characters within a string.
+
+**Example 1:**
+
+**Input:** s = "abcdefg", pattern = "bcdffg"
+
+**Output:** 1
+
+**Explanation:**
+
+The substring `s[1..6] == "bcdefg"` can be converted to `"bcdffg"` by changing `s[4]` to `"f"`.
+
+**Example 2:**
+
+**Input:** s = "ababbababa", pattern = "bacaba"
+
+**Output:** 4
+
+**Explanation:**
+
+The substring `s[4..9] == "bababa"` can be converted to `"bacaba"` by changing `s[6]` to `"c"`.
+
+**Example 3:**
+
+**Input:** s = "abcd", pattern = "dba"
+
+**Output:** \-1
+
+**Example 4:**
+
+**Input:** s = "dde", pattern = "d"
+
+**Output:** 0
+
+**Constraints:**
+
+*   <code>1 <= pattern.length < s.length <= 3 * 10<sup>5</sup></code>
+*   `s` and `pattern` consist only of lowercase English letters.
+
+**Follow-up:** Could you solve the problem if **at most** `k` **consecutive** characters can be changed?

src/main/java/g3301_3400/s3304_find_the_k_th_character_in_string_game_i/Solution.java

@@ -0,0 +1,27 @@
+package g3301_3400.s3304_find_the_k_th_character_in_string_game_i;
+
+// #Easy #2024_09_30_Time_16_ms_(100.00%)_Space_44.5_MB_(100.00%)
+
+public class Solution {
+    public char kthCharacter(int k) {
+        StringBuilder sb = new StringBuilder();
+        char c = 'a';
+        sb.append(c);
+        String s = sb.toString();
+        while (s.length() <= k) {
+            s = sb.toString();
+            char[] cq = s.toCharArray();
+            for (char c1 : cq) {
+                int ascii = (int) c1;
+                c1 = (char) (ascii + 1);
+                sb.append(c1);
+            }
+        }
+        for (int i = 0; i < sb.toString().length(); i++) {
+            if (i == k) {
+                return sb.toString().charAt(i - 1);
+            }
+        }
+        return '\0';
+    }
+}