Added tasks 3289-3292

Author: javadev

src/main/java/g3201_3300/s3289_the_two_sneaky_numbers_of_digitville/Solution.java

@@ -0,0 +1,30 @@
+package g3201_3300.s3289_the_two_sneaky_numbers_of_digitville;
+
+// #Easy #2024_09_16_Time_3_ms_(100.00%)_Space_45_MB_(100.00%)
+
+import java.util.HashMap;
+import java.util.Map;
+
+public class Solution {
+    public int[] getSneakyNumbers(int[] nums) {
+        Map<Integer, Integer> countMap = new HashMap<>();
+        // Populate the HashMap with the frequency of each number
+        for (int num : nums) {
+            countMap.put(num, countMap.getOrDefault(num, 0) + 1);
+        }
+        // Array to store the result
+        int[] result = new int[2];
+        int index = 0;
+        // Find the numbers that appear exactly twice
+        for (Map.Entry<Integer, Integer> entry : countMap.entrySet()) {
+            if (entry.getValue() == 2) {
+                result[index++] = entry.getKey();
+                // Break if we have found both sneaky numbers
+                if (index == 2) {
+                    break;
+                }
+            }
+        }
+        return result;
+    }
+}

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

@@ -0,0 +1,44 @@
+3289\. The Two Sneaky Numbers of Digitville
+
+Easy
+
+In the town of Digitville, there was a list of numbers called `nums` containing integers from `0` to `n - 1`. Each number was supposed to appear **exactly once** in the list, however, **two** mischievous numbers sneaked in an _additional time_, making the list longer than usual.
+
+As the town detective, your task is to find these two sneaky numbers. Return an array of size **two** containing the two numbers (in _any order_), so peace can return to Digitville.
+
+**Example 1:**
+
+**Input:** nums = [0,1,1,0]
+
+**Output:** [0,1]
+
+**Explanation:**
+
+The numbers 0 and 1 each appear twice in the array.
+
+**Example 2:**
+
+**Input:** nums = [0,3,2,1,3,2]
+
+**Output:** [2,3]
+
+**Explanation:**
+
+The numbers 2 and 3 each appear twice in the array.
+
+**Example 3:**
+
+**Input:** nums = [7,1,5,4,3,4,6,0,9,5,8,2]
+
+**Output:** [4,5]
+
+**Explanation:**
+
+The numbers 4 and 5 each appear twice in the array.
+
+**Constraints:**
+
+*   `2 <= n <= 100`
+*   `nums.length == n + 2`
+*   `0 <= nums[i] < n`
+*   The input is generated such that `nums` contains **exactly** two repeated elements.

src/main/java/g3201_3300/s3290_maximum_multiplication_score/Solution.java

@@ -0,0 +1,18 @@
+package g3201_3300.s3290_maximum_multiplication_score;
+
+// #Medium #2024_09_16_Time_8_ms_(100.00%)_Space_62.5_MB_(100.00%)
+
+import java.util.Arrays;
+
+public class Solution {
+    public long maxScore(int[] a, int[] b) {
+        long[] dp = new long[4];
+        Arrays.fill(dp, (long) -1e11);
+        for (int bi : b) {
+            for (int i = 3; i >= 0; i--) {
+                dp[i] = Math.max(dp[i], (i > 0 ? dp[i - 1] : 0) + (long) a[i] * bi);
+            }
+        }
+        return dp[3];
+    }
+}

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

@@ -0,0 +1,33 @@
+3290\. Maximum Multiplication Score
+
+Medium
+
+You are given an integer array `a` of size 4 and another integer array `b` of size **at least** 4.
+
+You need to choose 4 indices <code>i<sub>0</sub></code>, <code>i<sub>1</sub></code>, <code>i<sub>2</sub></code>, and <code>i<sub>3</sub></code> from the array `b` such that <code>i<sub>0</sub> < i<sub>1</sub> < i<sub>2</sub> < i<sub>3</sub></code>. Your score will be equal to the value <code>a[0] * b[i<sub>0</sub>] + a[1] * b[i<sub>1</sub>] + a[2] * b[i<sub>2</sub>] + a[3] * b[i<sub>3</sub>]</code>.
+
+Return the **maximum** score you can achieve.
+
+**Example 1:**
+
+**Input:** a = [3,2,5,6], b = [2,-6,4,-5,-3,2,-7]
+
+**Output:** 26
+
+**Explanation:**   
+ We can choose the indices 0, 1, 2, and 5. The score will be `3 * 2 + 2 * (-6) + 5 * 4 + 6 * 2 = 26`.
+
+**Example 2:**
+
+**Input:** a = [-1,4,5,-2], b = [-5,-1,-3,-2,-4]
+
+**Output:** \-1
+
+**Explanation:**   
+ We can choose the indices 0, 1, 3, and 4. The score will be `(-1) * (-5) + 4 * (-1) + 5 * (-2) + (-2) * (-4) = -1`.
+
+**Constraints:**
+
+*   `a.length == 4`
+*   <code>4 <= b.length <= 10<sup>5</sup></code>
+*   <code>-10<sup>5</sup> <= a[i], b[i] <= 10<sup>5</sup></code>

src/main/java/g3201_3300/s3291_minimum_number_of_valid_strings_to_form_target_i/Solution.java

@@ -0,0 +1,48 @@
+package g3201_3300.s3291_minimum_number_of_valid_strings_to_form_target_i;
+
+// #Medium #2024_09_16_Time_263_ms_(60.00%)_Space_56.9_MB_(20.00%)
+
+public class Solution {
+    public int minValidStrings(String[] words, String target) {
+        TrieNode root = new TrieNode();
+        for (String word : words) {
+            insert(root, word);
+        }
+        int n = target.length();
+        int[] dp = new int[n];
+        for (int i = n - 1; i >= 0; i--) {
+            dp[i] = Integer.MAX_VALUE;
+            TrieNode node = root;
+            for (int j = i; j < n; j++) {
+                int idx = target.charAt(j) - 'a';
+                if (node.children[idx] == null) {
+                    break;
+                }
+                if (j == n - 1) {
+                    dp[i] = 1;
+                } else if (dp[j + 1] >= 0) {
+                    dp[i] = Math.min(dp[i], 1 + dp[j + 1]);
+                }
+                node = node.children[idx];
+            }
+            if (dp[i] == Integer.MAX_VALUE) {
+                dp[i] = -1;
+            }
+        }
+        return dp[0];
+    }
+
+    private void insert(TrieNode root, String word) {
+        TrieNode node = root;
+        for (char c : word.toCharArray()) {
+            if (node.children[c - 'a'] == null) {
+                node.children[c - 'a'] = new TrieNode();
+            }
+            node = node.children[c - 'a'];
+        }
+    }
+
+    private static class TrieNode {
+        TrieNode[] children = new TrieNode[26];
+    }
+}

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

@@ -0,0 +1,53 @@
+3291\. Minimum Number of Valid Strings to Form Target I
+
+Medium
+
+You are given an array of strings `words` and a string `target`.
+
+A string `x` is called **valid** if `x` is a prefix of **any** string in `words`.
+
+Return the **minimum** number of **valid** strings that can be _concatenated_ to form `target`. If it is **not** possible to form `target`, return `-1`.
+
+A prefix of a string is a substring that starts from the beginning of the string and extends to any point within it.
+
+**Example 1:**
+
+**Input:** words = ["abc","aaaaa","bcdef"], target = "aabcdabc"
+
+**Output:** 3
+
+**Explanation:**
+
+The target string can be formed by concatenating:
+
+*   Prefix of length 2 of `words[1]`, i.e. `"aa"`.
+*   Prefix of length 3 of `words[2]`, i.e. `"bcd"`.
+*   Prefix of length 3 of `words[0]`, i.e. `"abc"`.
+
+**Example 2:**
+
+**Input:** words = ["abababab","ab"], target = "ababaababa"
+
+**Output:** 2
+
+**Explanation:**
+
+The target string can be formed by concatenating:
+
+*   Prefix of length 5 of `words[0]`, i.e. `"ababa"`.
+*   Prefix of length 5 of `words[0]`, i.e. `"ababa"`.
+
+**Example 3:**
+
+**Input:** words = ["abcdef"], target = "xyz"
+
+**Output:** \-1
+
+**Constraints:**
+
+*   `1 <= words.length <= 100`
+*   <code>1 <= words[i].length <= 5 * 10<sup>3</sup></code>
+*   The input is generated such that <code>sum(words[i].length) <= 10<sup>5</sup></code>.
+*   `words[i]` consists only of lowercase English letters.
+*   <code>1 <= target.length <= 5 * 10<sup>3</sup></code>
+*   `target` consists only of lowercase English letters.

src/main/java/g3201_3300/s3292_minimum_number_of_valid_strings_to_form_target_ii/Solution.java

@@ -0,0 +1,60 @@
+package g3201_3300.s3292_minimum_number_of_valid_strings_to_form_target_ii;
+
+// #Hard #2024_09_16_Time_103_ms_(100.00%)_Space_94.7_MB_(100.00%)
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+public class Solution {
+    public int minValidStrings(String[] words, String target) {
+        int n = target.length();
+        int[] dp = new int[n + 1];
+        Arrays.fill(dp, Integer.MAX_VALUE);
+        dp[0] = 0;
+        List<List<Integer>> matches = new ArrayList<>(n);
+        for (int i = 0; i < n; i++) {
+            matches.add(new ArrayList<>());
+        }
+        char[] targetChars = target.toCharArray();
+        for (String word : words) {
+            char[] wordChars = word.toCharArray();
+            int m = wordChars.length;
+            int[] pi = new int[m];
+            for (int i = 1, j = 0; i < m; i++) {
+                while (j > 0 && wordChars[i] != wordChars[j]) {
+                    j = pi[j - 1];
+                }
+                if (wordChars[i] == wordChars[j]) {
+                    j++;
+                }
+                pi[i] = j;
+            }
+            for (int i = 0, j = 0; i < n; i++) {
+                while (j > 0 && targetChars[i] != wordChars[j]) {
+                    j = pi[j - 1];
+                }
+                if (targetChars[i] == wordChars[j]) {
+                    j++;
+                }
+                if (j > 0) {
+                    matches.get(i - j + 1).add(j);
+                    if (j == m) {
+                        j = pi[j - 1];
+                    }
+                }
+            }
+        }
+        for (int i = 0; i < n; i++) {
+            if (dp[i] == Integer.MAX_VALUE) {
+                continue;
+            }
+            for (int len : matches.get(i)) {
+                if (i + len <= n) {
+                    dp[i + len] = Math.min(dp[i + len], dp[i] + 1);
+                }
+            }
+        }
+        return dp[n] == Integer.MAX_VALUE ? -1 : dp[n];
+    }
+}

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

@@ -0,0 +1,53 @@
+3292\. Minimum Number of Valid Strings to Form Target II
+
+Hard
+
+You are given an array of strings `words` and a string `target`.
+
+A string `x` is called **valid** if `x` is a prefix of **any** string in `words`.
+
+Return the **minimum** number of **valid** strings that can be _concatenated_ to form `target`. If it is **not** possible to form `target`, return `-1`.
+
+A prefix of a string is a substring that starts from the beginning of the string and extends to any point within it.
+
+**Example 1:**
+
+**Input:** words = ["abc","aaaaa","bcdef"], target = "aabcdabc"
+
+**Output:** 3
+
+**Explanation:**
+
+The target string can be formed by concatenating:
+
+*   Prefix of length 2 of `words[1]`, i.e. `"aa"`.
+*   Prefix of length 3 of `words[2]`, i.e. `"bcd"`.
+*   Prefix of length 3 of `words[0]`, i.e. `"abc"`.
+
+**Example 2:**
+
+**Input:** words = ["abababab","ab"], target = "ababaababa"
+
+**Output:** 2
+
+**Explanation:**
+
+The target string can be formed by concatenating:
+
+*   Prefix of length 5 of `words[0]`, i.e. `"ababa"`.
+*   Prefix of length 5 of `words[0]`, i.e. `"ababa"`.
+
+**Example 3:**
+
+**Input:** words = ["abcdef"], target = "xyz"
+
+**Output:** \-1
+
+**Constraints:**
+
+*   `1 <= words.length <= 100`
+*   <code>1 <= words[i].length <= 5 * 10<sup>4</sup></code>
+*   The input is generated such that <code>sum(words[i].length) <= 10<sup>5</sup></code>.
+*   `words[i]` consists only of lowercase English letters.
+*   <code>1 <= target.length <= 5 * 10<sup>4</sup></code>
+*   `target` consists only of lowercase English letters.

src/test/java/g3201_3300/s3289_the_two_sneaky_numbers_of_digitville/SolutionTest.java

@@ -0,0 +1,28 @@
+package g3201_3300.s3289_the_two_sneaky_numbers_of_digitville;
+
+import static org.hamcrest.CoreMatchers.equalTo;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+import org.junit.jupiter.api.Test;
+
+class SolutionTest {
+    @Test
+    void getSneakyNumbers() {
+        assertThat(
+                new Solution().getSneakyNumbers(new int[] {0, 1, 1, 0}), equalTo(new int[] {0, 1}));
+    }
+
+    @Test
+    void getSneakyNumbers2() {
+        assertThat(
+                new Solution().getSneakyNumbers(new int[] {0, 3, 2, 1, 3, 2}),
+                equalTo(new int[] {2, 3}));
+    }
+
+    @Test
+    void getSneakyNumbers3() {
+        assertThat(
+                new Solution().getSneakyNumbers(new int[] {7, 1, 5, 4, 3, 4, 6, 0, 9, 5, 8, 2}),
+                equalTo(new int[] {4, 5}));
+    }
+}