Improved tags

Author: javadev

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

@@ -1,30 +1,21 @@
 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%)
+// #Easy #Array #Math #2024_10_01_Time_1_ms_(100.00%)_Space_42.9_MB_(75.97%)
 
-import java.util.Arrays;
-
-public class Solution {
+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;
+        int min = Integer.MAX_VALUE;
+        for (int x : nums) {
+            min = Math.min(min, solve(x));
         }
-        Arrays.sort(arr);
-        return arr[0];
+        return min;
     }
 
-    private int sumOfDigits(int num) {
+    private int solve(int x) {
         int sum = 0;
-        if (num <= 9) {
-            return num;
-        }
-        while (num > 0) {
-            sum += num % 10;
-            num /= 10;
+        while (x != 0) {
+            sum += x % 10;
+            x /= 10;
         }
         return sum;
     }

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

@@ -1,6 +1,6 @@
 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%)
+// #Medium #Array #Sorting #Greedy #2024_10_01_Time_49_ms_(92.39%)_Space_57.9_MB_(70.01%)
 
 import java.util.Arrays;
 

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

@@ -1,37 +1,49 @@
 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;
+// #Medium #String #Dynamic_Programming #Greedy #Two_Pointers
+// #2024_10_01_Time_21_ms_(97.32%)_Space_74.3_MB_(74.55%)
 
 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;
+        char[] c1 = word1.toCharArray();
+        char[] c2 = word2.toCharArray();
+        int[] dp = new int[c1.length + 1];
+        int j = c2.length - 1;
+        for (int i = c1.length - 1; i >= 0; i--) {
+            if (j >= 0 && c1[i] == c2[j]) {
+                dp[i] = dp[i + 1] + 1;
+                j--;
+            } else {
+                dp[i] = dp[i + 1];
+            }
+        }
+        int[] ans = new int[c2.length];
+        int i = 0;
+        j = 0;
+        while (i < c1.length && j < c2.length) {
+            if (c1[i] == c2[j]) {
+                ans[j] = i;
+                j++;
+            } else {
+                if (dp[i + 1] >= c2.length - 1 - j) {
+                    ans[j] = i;
+                    j++;
+                    i++;
+                    break;
+                }
             }
-            i--;
+            i++;
+        }
+        if (j < c2.length && i == c1.length) {
+            return new int[0];
         }
-        boolean canSkip = true;
-        int j1 = 0;
-        int i1 = 0;
-        while (i1 < n && j1 < m && m - j1 <= n - i1) {
-            if (word1.charAt(i1) == word2.charAt(j1)) {
-                revGreedyMatchInd[j1++] = i1;
-            } else if (canSkip && (j1 == m - 1 || i1 < revGreedyMatchInd[j1 + 1])) {
-                revGreedyMatchInd[j1++] = i1;
-                canSkip = false;
-            } else if (!canSkip && revGreedyMatchInd[j1] == -1) {
-                break;
+        while (j < c2.length && i < c1.length) {
+            if (c2[j] == c1[i]) {
+                ans[j] = i;
+                j++;
             }
-            i1++;
+            i++;
         }
-        return j1 == m ? revGreedyMatchInd : new int[0];
+        return ans;
     }
 }

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

@@ -1,49 +1,60 @@
 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;
+// #Hard #String #String_Matching #2024_10_01_Time_39_ms_(100.00%)_Space_46.1_MB_(100.00%)
 
 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;
+    public int minStartingIndex(String s, String pattern) {
         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;
+        int left = 0;
+        int right = 0;
+        int[] f1 = new int[26];
+        int[] f2 = new int[26];
+        for (char ch : pattern.toCharArray()) {
+            f2[ch - 'a']++;
+        }
+        while (right < n) {
+            char ch = s.charAt(right);
+            f1[ch - 'a']++;
+            if (right - left + 1 == pattern.length() + 1) {
+                f1[s.charAt(left) - 'a']--;
+                left += 1;
             }
-            if (i >= sz - 1 && !mp.containsKey(hash)) {
-                mp.put(hash, i - sz + 1);
+            if (right - left + 1 == pattern.length()) {
+                if (check(f1, f2, left, right, s, pattern) == true) {
+                    return left;
+                }
             }
+            right += 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));
+        return -1;
+    }
+
+    private boolean check(int[] f1, int[] f2, int left, int right, String s, String pattern) {
+        int cnt = 0;
+        for (int i = 0; i < 26; i++) {
+            if (f1[i] != f2[i]) {
+                if ((Math.abs(f1[i] - f2[i]) > 1) || (Math.abs(f1[i] - f2[i]) != 1 && cnt == 2)) {
+                    return false;
                 }
+                cnt += 1;
+            }
+        }
+        cnt = 0;
+        int start = 0;
+        int end = pattern.length() - 1;
+        while (start <= end) {
+            if (s.charAt(start + left) != pattern.charAt(start)) {
+                cnt += 1;
+            }
+            if (start + left != left + end && s.charAt(left + end) != pattern.charAt(end)) {
+                cnt += 1;
+            }
+            if (cnt >= 2) {
+                return false;
             }
-            d = d * base % mod;
+            start++;
+            end--;
         }
-        return ans == Integer.MAX_VALUE ? -1 : ans;
+        return true;
     }
 }

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

@@ -1,27 +1,34 @@
 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%)
+// #Easy #Math #Bit_Manipulation #Simulation #Recursion
+// #2024_10_01_Time_0_ms_(100.00%)_Space_41.2_MB_(99.17%)
 
 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 = c1;
-                c1 = (char) (ascii + 1);
-                sb.append(c1);
-            }
+        // Initialize the length of the current string
+        // Initial length when word = "a"
+        int length = 1;
+
+        // Find the total length after enough iterations
+        while (length < k) {
+            length *= 2;
         }
-        for (int i = 0; i < sb.toString().length(); i++) {
-            if (i == k) {
-                return sb.toString().charAt(i - 1);
+        // Trace back to the original character
+        // Start with 'a'
+        char currentChar = 'a';
+        while (length > 1) {
+            length /= 2;
+            if (k > length) {
+                // Adjust k for the next character
+                k -= length;
+                // Move to the next character
+                currentChar++;
+                if (currentChar > 'z') {
+                    // Wrap around if exceeds 'z'
+                    currentChar = 'a';
+                }
             }
         }
-        return '\0';
+        return currentChar;
     }
 }

src/main/java/g3301_3400/s3305_count_of_substrings_containing_every_vowel_and_k_consonants_i/Solution.java

@@ -1,38 +1,60 @@
 package g3301_3400.s3305_count_of_substrings_containing_every_vowel_and_k_consonants_i;
 
-// #Medium #2024_09_30_Time_1998_ms_(100.00%)_Space_45.5_MB_(50.00%)
-
-import java.util.HashSet;
+// #Medium #String #Hash_Table #Sliding_Window #2024_10_01_Time_2_ms_(99.72%)_Space_42.2_MB_(98.48%)
 
 public class Solution {
     public int countOfSubstrings(String word, int k) {
-        int possibleSubstring = 0;
-        HashSet<Character> vowelContainer = new HashSet<>();
-        String vowel = "aeiou";
-        for (char ch : vowel.toCharArray()) {
-            vowelContainer.add(ch);
-        }
-        for (int i = 0; i < word.length(); i++) {
-            for (int j = i; j < word.length(); j++) {
-                if (checkValid(word, i, j, vowelContainer, k)) {
-                    possibleSubstring++;
+        char[] arr = word.toCharArray();
+        int[] map = new int[26];
+        map['a' - 'a']++;
+        map['e' - 'a']++;
+        map['i' - 'a']++;
+        map['o' - 'a']++;
+        map['u' - 'a']++;
+        int need = 5;
+        int ans = 0;
+        int consCnt = 0;
+        int j = 0;
+        for (int i = 0; i < arr.length; i++) {
+            while (j < arr.length && (need > 0 || consCnt < k)) {
+                if (isVowel(arr[j])) {
+                    map[arr[j] - 'a']--;
+                    if (map[arr[j] - 'a'] == 0) {
+                        need--;
+                    }
+                } else {
+                    consCnt++;
                 }
+                j++;
+            }
+            if (need == 0 && consCnt == k) {
+                ans++;
+                int m = j;
+                while (m < arr.length) {
+                    if (isVowel(arr[m])) {
+                        ans++;
+                    } else {
+                        break;
+                    }
+                    m++;
+                }
+            }
+            if (isVowel(arr[i])) {
+                map[arr[i] - 'a']++;
+                if (map[arr[i] - 'a'] == 1) {
+                    need++;
+                }
+            } else {
+                consCnt--;
             }
         }
-        return possibleSubstring;
+        return ans;
     }
 
-    private boolean checkValid(
-            String word, int start, int end, HashSet<Character> vowelContainer, int limit) {
-        HashSet<Character> duplicateCheck = new HashSet<>();
-        int consonants = 0;
-        for (int i = start; i <= end; i++) {
-            if (!vowelContainer.contains(word.charAt(i))) {
-                consonants++;
-            } else {
-                duplicateCheck.add(word.charAt(i));
-            }
+    private boolean isVowel(char ch) {
+        if (ch == 'a' || ch == 'e' || ch == 'i' || ch == 'o' || ch == 'u') {
+            return true;
         }
-        return duplicateCheck.size() == 5 && consonants == limit;
+        return false;
     }
 }

src/main/java/g3301_3400/s3306_count_of_substrings_containing_every_vowel_and_k_consonants_ii/Solution.java

@@ -1,6 +1,7 @@
 package g3301_3400.s3306_count_of_substrings_containing_every_vowel_and_k_consonants_ii;
 
-// #Medium #2024_09_30_Time_341_ms_(100.00%)_Space_46.1_MB_(100.00%)
+// #Medium #String #Hash_Table #Sliding_Window
+// #2024_10_01_Time_340_ms_(44.09%)_Space_46.3_MB_(62.47%)
 
 import java.util.HashMap;
 import java.util.HashSet;

src/main/java/g3301_3400/s3307_find_the_k_th_character_in_string_game_ii/Solution.java

@@ -1,6 +1,6 @@
 package g3301_3400.s3307_find_the_k_th_character_in_string_game_ii;
 
-// #Hard #2024_09_30_Time_1_ms_(100.00%)_Space_43.4_MB_(100.00%)
+// #Hard #Math #Bit_Manipulation #Recursion #2024_10_01_Time_1_ms_(99.65%)_Space_43.2_MB_(59.72%)
 
 public class Solution {
     public char kthCharacter(long k, int[] operations) {