Added tasks 2451, 2452, 2453, 2454, 2455.

Author: ThanhNIT

src/main/java/g2401_2500/s2451_odd_string_difference/Solution.java

@@ -0,0 +1,32 @@
+package g2401_2500.s2451_odd_string_difference;
+
+// #Easy #String #Hash_Table #Math #2022_12_15_Time_0_ms_(100.00%)_Space_40_MB_(91.61%)
+
+public class Solution {
+    public String oddString(String[] w) {
+        int n = w[0].length() - 1;
+        int[] x = new int[n];
+        int s = 1;
+        int y = 0;
+        int index = 1;
+        for (int i = 0; i < n; i++) {
+            x[i] = w[0].charAt(i + 1) - w[0].charAt(i);
+        }
+        for (int i = 1; y * s == 0 || s + y < 3; i++) {
+            boolean b = true;
+            for (int j = 0; j < n; j++) {
+                if (x[j] != w[i].charAt(j + 1) - w[i].charAt(j)) {
+                    b = false;
+                    break;
+                }
+            }
+            if (b) {
+                s++;
+            } else {
+                y++;
+                index = i;
+            }
+        }
+        return s == 1 ? w[0] : w[index];
+    }
+}

src/main/java/g2401_2500/s2451_odd_string_difference/readme.md

@@ -0,0 +1,44 @@
+2451\. Odd String Difference
+
+Easy
+
+You are given an array of equal-length strings `words`. Assume that the length of each string is `n`.
+
+Each string `words[i]` can be converted into a **difference integer array** `difference[i]` of length `n - 1` where `difference[i][j] = words[i][j+1] - words[i][j]` where `0 <= j <= n - 2`. Note that the difference between two letters is the difference between their **positions** in the alphabet i.e. the position of `'a'` is `0`, `'b'` is `1`, and `'z'` is `25`.
+
+*   For example, for the string `"acb"`, the difference integer array is `[2 - 0, 1 - 2] = [2, -1]`.
+
+All the strings in words have the same difference integer array, **except one**. You should find that string.
+
+Return _the string in_ `words` _that has different **difference integer array**._
+
+**Example 1:**
+
+**Input:** words = ["adc","wzy","abc"]
+
+**Output:** "abc"
+
+**Explanation:** 
+
+- The difference integer array of "adc" is [3 - 0, 2 - 3] = [3, -1].
+
+- The difference integer array of "wzy" is [25 - 22, 24 - 25]= [3, -1]. 
+
+- The difference integer array of "abc" is [1 - 0, 2 - 1] = [1, 1].
+
+The odd array out is [1, 1], so we return the corresponding string, "abc".
+
+**Example 2:**
+
+**Input:** words = ["aaa","bob","ccc","ddd"]
+
+**Output:** "bob"
+
+**Explanation:** All the integer arrays are [0, 0] except for "bob", which corresponds to [13, -13].
+
+**Constraints:**
+
+*   `3 <= words.length <= 100`
+*   `n == words[i].length`
+*   `2 <= n <= 20`
+*   `words[i]` consists of lowercase English letters.

src/main/java/g2401_2500/s2452_words_within_two_edits_of_dictionary/Solution.java

@@ -0,0 +1,63 @@
+package g2401_2500.s2452_words_within_two_edits_of_dictionary;
+
+// #Medium #Array #String #2022_12_15_Time_16_ms_(70.33%)_Space_49.2_MB_(14.26%)
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+
+public class Solution {
+    private Node root;
+
+    static class Node {
+        HashMap<Character, Node> childs = new HashMap<>();
+    }
+
+    private void insert(String s) {
+        Node curr = root;
+        for (char ch : s.toCharArray()) {
+            if (curr.childs.get(ch) == null) {
+                curr.childs.put(ch, new Node());
+            }
+            curr = curr.childs.get(ch);
+        }
+    }
+
+    private boolean search(String word, Node curr, int i, int edits) {
+        // if reached the end with less than or equal 2 edits then return truem
+        if (i == word.length()) {
+            return edits <= 2;
+        }
+        // more than 2 mismatch don't go further
+        if (edits > 2) {
+            return false;
+        }
+        // there might be a case start is matching but others are diff and that's a edge case to
+        // handle
+        boolean ans = false;
+        for (Character ch : curr.childs.keySet()) {
+            ans |=
+                    search(
+                            word,
+                            curr.childs.get(ch),
+                            i + 1,
+                            ch == word.charAt(i) ? edits : edits + 1);
+        }
+        return ans;
+    }
+
+    public List<String> twoEditWords(String[] queries, String[] dictionary) {
+        root = new Node();
+        for (String s : dictionary) {
+            insert(s);
+        }
+        List<String> ans = new ArrayList<>();
+        for (String s : queries) {
+            boolean found = search(s, root, 0, 0);
+            if (found) {
+                ans.add(s);
+            }
+        }
+        return ans;
+    }
+}

src/main/java/g2401_2500/s2452_words_within_two_edits_of_dictionary/readme.md

@@ -0,0 +1,44 @@
+2452\. Words Within Two Edits of Dictionary
+
+Medium
+
+You are given two string arrays, `queries` and `dictionary`. All words in each array comprise of lowercase English letters and have the same length.
+
+In one **edit** you can take a word from `queries`, and change any letter in it to any other letter. Find all words from `queries` that, after a **maximum** of two edits, equal some word from `dictionary`.
+
+Return _a list of all words from_ `queries`_,_ _that match with some word from_ `dictionary` _after a maximum of **two edits**_. Return the words in the **same order** they appear in `queries`.
+
+**Example 1:**
+
+**Input:** queries = ["word","note","ants","wood"], dictionary = ["wood","joke","moat"]
+
+**Output:** ["word","note","wood"]
+
+**Explanation:**
+
+- Changing the 'r' in "word" to 'o' allows it to equal the dictionary word "wood".
+
+- Changing the 'n' to 'j' and the 't' to 'k' in "note" changes it to "joke".
+
+- It would take more than 2 edits for "ants" to equal a dictionary word.
+
+- "wood" can remain unchanged (0 edits) and match the corresponding dictionary word.
+
+Thus, we return ["word","note","wood"].
+
+**Example 2:**
+
+**Input:** queries = ["yes"], dictionary = ["not"]
+
+**Output:** []
+
+**Explanation:**
+
+Applying any two edits to "yes" cannot make it equal to "not". Thus, we return an empty array.
+
+**Constraints:**
+
+*   `1 <= queries.length, dictionary.length <= 100`
+*   `n == queries[i].length == dictionary[j].length`
+*   `1 <= n <= 100`
+*   All `queries[i]` and `dictionary[j]` are composed of lowercase English letters.

src/main/java/g2401_2500/s2453_destroy_sequential_targets/Solution.java

@@ -0,0 +1,27 @@
+package g2401_2500.s2453_destroy_sequential_targets;
+
+// #Medium #Array #Hash_Table #Counting #2022_12_15_Time_33_ms_(96.27%)_Space_58.9_MB_(95.38%)
+
+import java.util.HashMap;
+
+public class Solution {
+    public int destroyTargets(int[] nums, int space) {
+        HashMap<Integer, Integer> map = new HashMap<>();
+        for (int num : nums) {
+            int reminder = num % space;
+            int freq = map.getOrDefault(reminder, 0);
+            map.put(reminder, freq + 1);
+        }
+        int maxCount = 0;
+        int ans = Integer.MAX_VALUE;
+        for (int count : map.values()) {
+            maxCount = Math.max(count, maxCount);
+        }
+        for (int val : nums) {
+            if (map.get(val % space) == maxCount) {
+                ans = Math.min(ans, val);
+            }
+        }
+        return ans;
+    }
+}

src/main/java/g2401_2500/s2453_destroy_sequential_targets/readme.md

@@ -0,0 +1,39 @@
+2453\. Destroy Sequential Targets
+
+Medium
+
+You are given a **0-indexed** array `nums` consisting of positive integers, representing targets on a number line. You are also given an integer `space`.
+
+You have a machine which can destroy targets. **Seeding** the machine with some `nums[i]` allows it to destroy all targets with values that can be represented as `nums[i] + c * space`, where `c` is any non-negative integer. You want to destroy the **maximum** number of targets in `nums`.
+
+Return _the **minimum value** of_ `nums[i]` _you can seed the machine with to destroy the maximum number of targets._
+
+**Example 1:**
+
+**Input:** nums = [3,7,8,1,1,5], space = 2
+
+**Output:** 1
+
+**Explanation:** If we seed the machine with nums[3], then we destroy all targets equal to 1,3,5,7,9,... In this case, we would destroy 5 total targets (all except for nums[2]). It is impossible to destroy more than 5 targets, so we return nums[3].
+
+**Example 2:**
+
+**Input:** nums = [1,3,5,2,4,6], space = 2
+
+**Output:** 1
+
+**Explanation:** Seeding the machine with nums[0], or nums[3] destroys 3 targets. It is not possible to destroy more than 3 targets. Since nums[0] is the minimal integer that can destroy 3 targets, we return 1.
+
+**Example 3:**
+
+**Input:** nums = [6,2,5], space = 100
+
+**Output:** 2
+
+**Explanation:** Whatever initial seed we select, we can only destroy 1 target. The minimal seed is nums[1].
+
+**Constraints:**
+
+*   <code>1 <= nums.length <= 10<sup>5</sup></code>
+*   <code>1 <= nums[i] <= 10<sup>9</sup></code>
+*   <code>1 <= space <= 10<sup>9</sup></code>

src/main/java/g2401_2500/s2454_next_greater_element_iv/Solution.java

@@ -0,0 +1,31 @@
+package g2401_2500.s2454_next_greater_element_iv;
+
+// #Hard #Array #Sorting #Binary_Search #Stack #Monotonic_Stack #Heap_(Priority_Queue)
+// #2022_12_15_Time_29_ms_(95.84%)_Space_57.4_MB_(93.32%)
+
+import java.util.ArrayDeque;
+import java.util.Arrays;
+import java.util.Deque;
+
+public class Solution {
+    public int[] secondGreaterElement(int[] nums) {
+        int[] res = new int[nums.length];
+        Arrays.fill(res, -1);
+        Deque<Integer> stack1 = new ArrayDeque<>();
+        Deque<Integer> stack2 = new ArrayDeque<>();
+        Deque<Integer> tmp = new ArrayDeque<>();
+        for (int i = 0; i < nums.length; i++) {
+            while (!stack2.isEmpty() && nums[i] > nums[stack2.peek()]) {
+                res[stack2.pop()] = nums[i];
+            }
+            while (!stack1.isEmpty() && nums[i] > nums[stack1.peek()]) {
+                tmp.push(stack1.pop());
+            }
+            while (!tmp.isEmpty()) {
+                stack2.push(tmp.pop());
+            }
+            stack1.push(i);
+        }
+        return res;
+    }
+}

src/main/java/g2401_2500/s2454_next_greater_element_iv/readme.md

@@ -0,0 +1,50 @@
+2454\. Next Greater Element IV
+
+Hard
+
+You are given a **0-indexed** array of non-negative integers `nums`. For each integer in `nums`, you must find its respective **second greater** integer.
+
+The **second greater** integer of `nums[i]` is `nums[j]` such that:
+
+*   `j > i`
+*   `nums[j] > nums[i]`
+*   There exists **exactly one** index `k` such that `nums[k] > nums[i]` and `i < k < j`.
+
+If there is no such `nums[j]`, the second greater integer is considered to be `-1`.
+
+*   For example, in the array `[1, 2, 4, 3]`, the second greater integer of `1` is `4`, `2` is `3`, and that of `3` and `4` is `-1`.
+
+Return _an integer array_ `answer`_, where_ `answer[i]` _is the second greater integer of_ `nums[i]`_._
+
+**Example 1:**
+
+**Input:** nums = [2,4,0,9,6]
+
+**Output:** [9,6,6,-1,-1]
+
+**Explanation:** 
+
+0th index: 4 is the first integer greater than 2, and 9 is the second integer greater than 2, to the right of 2. 
+
+1st index: 9 is the first, and 6 is the second integer greater than 4, to the right of 4. 
+
+2nd index: 9 is the first, and 6 is the second integer greater than 0, to the right of 0. 
+
+3rd index: There is no integer greater than 9 to its right, so the second greater integer is considered to be -1. 
+
+4th index: There is no integer greater than 6 to its right, so the second greater integer is considered to be -1. 
+
+Thus, we return [9,6,6,-1,-1].
+
+**Example 2:**
+
+**Input:** nums = [3,3]
+
+**Output:** [-1,-1]
+
+**Explanation:** We return [-1,-1] since neither integer has any integer greater than it.
+
+**Constraints:**
+
+*   <code>1 <= nums.length <= 10<sup>5</sup></code>
+*   <code>0 <= nums[i] <= 10<sup>9</sup></code>

src/main/java/g2401_2500/s2455_average_value_of_even_numbers_that_are_divisible_by_three/Solution.java

@@ -0,0 +1,20 @@
+package g2401_2500.s2455_average_value_of_even_numbers_that_are_divisible_by_three;
+
+// #Easy #Array #Math #2022_12_15_Time_1_ms_(100.00%)_Space_42.6_MB_(82.41%)
+
+public class Solution {
+    public int averageValue(int[] nums) {
+        int count = 0;
+        int sum = 0;
+        for (int num : nums) {
+            if (num % 2 == 0 && num % 3 == 0) {
+                count++;
+                sum += num;
+            }
+        }
+        if (count == 0) {
+            return 0;
+        }
+        return sum / count;
+    }
+}

src/main/java/g2401_2500/s2455_average_value_of_even_numbers_that_are_divisible_by_three/readme.md

@@ -0,0 +1,28 @@
+2455\. Average Value of Even Numbers That Are Divisible by Three
+
+Easy
+
+Given an integer array `nums` of **positive** integers, return _the average value of all even integers that are divisible by_ `3`_._
+
+Note that the **average** of `n` elements is the **sum** of the `n` elements divided by `n` and **rounded down** to the nearest integer.
+
+**Example 1:**
+
+**Input:** nums = [1,3,6,10,12,15]
+
+**Output:** 9
+
+**Explanation:** 6 and 12 are even numbers that are divisible by 3. (6 + 12) / 2 = 9.
+
+**Example 2:**
+
+**Input:** nums = [1,2,4,7,10]
+
+**Output:** 0
+
+**Explanation:** There is no single number that satisfies the requirement, so return 0.
+
+**Constraints:**
+
+*   `1 <= nums.length <= 1000`
+*   `1 <= nums[i] <= 1000`