Added tasks 2456, 2457, 2458, 2460, 2461.

Author: ThanhNIT

src/main/java/g2401_2500/s2456_most_popular_video_creator/Solution.java

@@ -0,0 +1,36 @@
+package g2401_2500.s2456_most_popular_video_creator;
+
+// #Medium #Array #String #Hash_Table #Sorting #Heap_Priority_Queue
+// #2022_12_16_Time_57_ms_(97.10%)_Space_85.2_MB_(99.42%)
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+public class Solution {
+    public List<List<String>> mostPopularCreator(String[] creators, String[] ids, int[] views) {
+        HashMap<String, Long> totalViews = new HashMap<>();
+        HashMap<String, Integer> maxView = new HashMap<>();
+        long globalMaxView = 0;
+        for (int i = 0; i < creators.length; i++) {
+            long currentView = totalViews.getOrDefault(creators[i], 0L) + views[i];
+            globalMaxView = Math.max(currentView, globalMaxView);
+            totalViews.put(creators[i], currentView);
+            int lastIndex = maxView.getOrDefault(creators[i], -1);
+            if (!maxView.containsKey(creators[i])
+                    || views[lastIndex] < views[i]
+                    || (views[lastIndex] == views[i] && ids[lastIndex].compareTo(ids[i]) > 0)) {
+                maxView.put(creators[i], i);
+            }
+        }
+        List<List<String>> res = new ArrayList<>();
+        for (Map.Entry<String, Long> entry : totalViews.entrySet()) {
+            if (entry.getValue() == globalMaxView) {
+                res.add(Arrays.asList(entry.getKey(), ids[maxView.get(entry.getKey())]));
+            }
+        }
+        return res;
+    }
+}

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

@@ -0,0 +1,54 @@
+2456\. Most Popular Video Creator
+
+Medium
+
+You are given two string arrays `creators` and `ids`, and an integer array `views`, all of length `n`. The <code>i<sup>th</sup></code> video on a platform was created by `creator[i]`, has an id of `ids[i]`, and has `views[i]` views.
+
+The **popularity** of a creator is the **sum** of the number of views on **all** of the creator's videos. Find the creator with the **highest** popularity and the id of their **most** viewed video.
+
+*   If multiple creators have the highest popularity, find all of them.
+*   If multiple videos have the highest view count for a creator, find the lexicographically **smallest** id.
+
+Return _a 2D array of strings_ `answer` _where_ <code>answer[i] = [creator<sub>i</sub>, id<sub>i</sub>]</code> _means that_ <code>creator<sub>i</sub></code> _has the **highest** popularity and_ <code>id<sub>i</sub></code> _is the id of their most popular video._ The answer can be returned in any order.
+
+**Example 1:**
+
+**Input:** creators = ["alice","bob","alice","chris"], ids = ["one","two","three","four"], views = [5,10,5,4]
+
+**Output:** [["alice","one"],["bob","two"]]
+
+**Explanation:** 
+
+The popularity of alice is 5 + 5 = 10. 
+
+The popularity of bob is 10. 
+
+The popularity of chris is 4. 
+
+alice and bob are the most popular creators. 
+
+For bob, the video with the highest view count is "two". 
+
+For alice, the videos with the highest view count are "one" and "three". 
+
+Since "one" is lexicographically smaller than "three", it is included in the answer.
+
+**Example 2:**
+
+**Input:** creators = ["alice","alice","alice"], ids = ["a","b","c"], views = [1,2,2]
+
+**Output:** [["alice","b"]]
+
+**Explanation:** 
+
+The videos with id "b" and "c" have the highest view count. 
+
+Since "b" is lexicographically smaller than "c", it is included in the answer.
+
+**Constraints:**
+
+*   `n == creators.length == ids.length == views.length`
+*   <code>1 <= n <= 10<sup>5</sup></code>
+*   `1 <= creators[i].length, ids[i].length <= 5`
+*   `creators[i]` and `ids[i]` consist only of lowercase English letters.
+*   <code>0 <= views[i] <= 10<sup>5</sup></code>

src/main/java/g2401_2500/s2457_minimum_addition_to_make_integer_beautiful/Solution.java

@@ -0,0 +1,28 @@
+package g2401_2500.s2457_minimum_addition_to_make_integer_beautiful;
+
+// #Medium #Math #Greedy #2022_12_16_Time_0_ms_(100.00%)_Space_39.2_MB_(86.59%)
+
+public class Solution {
+    public long makeIntegerBeautiful(long n, int target) {
+        if (sumOfDigits(n) <= target) {
+            return 0;
+        }
+        long old = n;
+        long newNumber = 1;
+        while (sumOfDigits(n) > target) {
+            newNumber = newNumber * 10;
+            n = n / 10 + 1;
+        }
+        newNumber = (n) * newNumber;
+        return newNumber - old;
+    }
+
+    public long sumOfDigits(long n) {
+        long sum = 0;
+        while (n > 0) {
+            sum = sum + n % 10;
+            n = n / 10;
+        }
+        return sum;
+    }
+}

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

@@ -0,0 +1,39 @@
+2457\. Minimum Addition to Make Integer Beautiful
+
+Medium
+
+You are given two positive integers `n` and `target`.
+
+An integer is considered **beautiful** if the sum of its digits is less than or equal to `target`.
+
+Return the _minimum **non-negative** integer_ `x` _such that_ `n + x` _is beautiful_. The input will be generated such that it is always possible to make `n` beautiful.
+
+**Example 1:**
+
+**Input:** n = 16, target = 6
+
+**Output:** 4
+
+**Explanation:** Initially n is 16 and its digit sum is 1 + 6 = 7. After adding 4, n becomes 20 and digit sum becomes 2 + 0 = 2. It can be shown that we can not make n beautiful with adding non-negative integer less than 4.
+
+**Example 2:**
+
+**Input:** n = 467, target = 6
+
+**Output:** 33
+
+**Explanation:** Initially n is 467 and its digit sum is 4 + 6 + 7 = 17. After adding 33, n becomes 500 and digit sum becomes 5 + 0 + 0 = 5. It can be shown that we can not make n beautiful with adding non-negative integer less than 33.
+
+**Example 3:**
+
+**Input:** n = 1, target = 1
+
+**Output:** 0
+
+**Explanation:** Initially n is 1 and its digit sum is 1, which is already smaller than or equal to target.
+
+**Constraints:**
+
+*   <code>1 <= n <= 10<sup>12</sup></code>
+*   `1 <= target <= 150`
+*   The input will be generated such that it is always possible to make `n` beautiful.

src/main/java/g2401_2500/s2458_height_of_binary_tree_after_subtree_removal_queries/Solution.java

@@ -0,0 +1,53 @@
+package g2401_2500.s2458_height_of_binary_tree_after_subtree_removal_queries;
+
+// #Hard #Array #Tree #Binary_Tree #Depth_First_Search #Breadth_First_Search
+// #2022_12_20_Time_52_ms_(87.45%)_Space_70.6_MB_(98.17%)
+
+import com_github_leetcode.TreeNode;
+import java.util.HashMap;
+import java.util.Map;
+
+public class Solution {
+    public int[] treeQueries(TreeNode root, int[] queries) {
+        Map<Integer, int[]> levels = new HashMap<>();
+        Map<Integer, int[]> map = new HashMap<>();
+        int max = dfs(root, 0, map, levels) - 1;
+        int n = queries.length;
+        for (int i = 0; i < n; i++) {
+            int q = queries[i];
+            int[] node = map.get(q);
+            int height = node[0];
+            int level = node[1];
+            int[] lev = levels.get(level);
+            if (lev[0] == height) {
+                if (lev[1] != -1) {
+                    queries[i] = max - Math.abs(lev[0] - lev[1]);
+                } else {
+                    queries[i] = max - height - 1;
+                }
+            } else {
+                queries[i] = max;
+            }
+        }
+        return queries;
+    }
+
+    private int dfs(TreeNode root, int level, Map<Integer, int[]> map, Map<Integer, int[]> levels) {
+        if (root == null) {
+            return 0;
+        }
+        int left = dfs(root.left, level + 1, map, levels);
+        int right = dfs(root.right, level + 1, map, levels);
+        int height = Math.max(left, right);
+        int[] lev = levels.getOrDefault(level, new int[] {-1, -1});
+        if (height >= lev[0]) {
+            lev[1] = lev[0];
+            lev[0] = height;
+        } else {
+            lev[1] = Math.max(lev[1], height);
+        }
+        levels.put(level, lev);
+        map.put(root.val, new int[] {height, level});
+        return Math.max(left, right) + 1;
+    }
+}

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

@@ -0,0 +1,55 @@
+2458\. Height of Binary Tree After Subtree Removal Queries
+
+Hard
+
+You are given the `root` of a **binary tree** with `n` nodes. Each node is assigned a unique value from `1` to `n`. You are also given an array `queries` of size `m`.
+
+You have to perform `m` **independent** queries on the tree where in the <code>i<sup>th</sup></code> query you do the following:
+
+*   **Remove** the subtree rooted at the node with the value `queries[i]` from the tree. It is **guaranteed** that `queries[i]` will **not** be equal to the value of the root.
+
+Return _an array_ `answer` _of size_ `m` _where_ `answer[i]` _is the height of the tree after performing the_ <code>i<sup>th</sup></code> _query_.
+
+**Note**:
+
+*   The queries are independent, so the tree returns to its **initial** state after each query.
+*   The height of a tree is the **number of edges in the longest simple path** from the root to some node in the tree.
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2022/09/07/binaryytreeedrawio-1.png)
+
+**Input:** root = [1,3,4,2,null,6,5,null,null,null,null,null,7], queries = [4]
+
+**Output:** [2]
+
+**Explanation:** The diagram above shows the tree after removing the subtree rooted at node with value 4. The height of the tree is 2 (The path 1 -> 3 -> 2).
+
+**Example 2:**
+
+![](https://assets.leetcode.com/uploads/2022/09/07/binaryytreeedrawio-2.png)
+
+**Input:** root = [5,8,9,2,1,3,7,4,6], queries = [3,2,4,8]
+
+**Output:** [3,2,3,2]
+
+**Explanation:** We have the following queries: 
+
+- Removing the subtree rooted at node with value 3. The height of the tree becomes 3 (The path 5 -> 8 -> 2 -> 4). 
+ 
+- Removing the subtree rooted at node with value 2. The height of the tree becomes 2 (The path 5 -> 8 -> 1). 
+
+- Removing the subtree rooted at node with value 4. The height of the tree becomes 3 (The path 5 -> 8 -> 2 -> 6). 
+
+- Removing the subtree rooted at node with value 8. The height of the tree becomes 2 (The path 5 -> 9 -> 3).
+
+**Constraints:**
+
+*   The number of nodes in the tree is `n`.
+*   <code>2 <= n <= 10<sup>5</sup></code>
+*   `1 <= Node.val <= n`
+*   All the values in the tree are **unique**.
+*   `m == queries.length`
+*   <code>1 <= m <= min(n, 10<sup>4</sup>)</code>
+*   `1 <= queries[i] <= n`
+*   `queries[i] != root.val`

src/main/java/g2401_2500/s2460_apply_operations_to_an_array/Solution.java

@@ -0,0 +1,25 @@
+package g2401_2500.s2460_apply_operations_to_an_array;
+
+// #Easy #Array #Simulation #2022_12_20_Time_1_ms_(87.93%)_Space_42.4_MB_(89.13%)
+
+public class Solution {
+    public int[] applyOperations(int[] nums) {
+        for (int i = 0; i < nums.length - 1; i++) {
+            if (nums[i] == nums[i + 1]) {
+                nums[i] *= 2;
+                nums[i + 1] = 0;
+            }
+        }
+        int index = 0;
+        for (int i = 0; i < nums.length; i++) {
+            if (nums[i] != 0) {
+                nums[index] = nums[i];
+                index++;
+            }
+        }
+        for (int i = index; i < nums.length; i++) {
+            nums[i] = 0;
+        }
+        return nums;
+    }
+}

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

@@ -0,0 +1,50 @@
+2460\. Apply Operations to an Array
+
+Easy
+
+You are given a **0-indexed** array `nums` of size `n` consisting of **non-negative** integers.
+
+You need to apply `n - 1` operations to this array where, in the <code>i<sup>th</sup></code> operation (**0-indexed**), you will apply the following on the <code>i<sup>th</sup></code> element of `nums`:
+
+*   If `nums[i] == nums[i + 1]`, then multiply `nums[i]` by `2` and set `nums[i + 1]` to `0`. Otherwise, you skip this operation.
+
+After performing **all** the operations, **shift** all the `0`'s to the **end** of the array.
+
+*   For example, the array `[1,0,2,0,0,1]` after shifting all its `0`'s to the end, is `[1,2,1,0,0,0]`.
+
+Return _the resulting array_.
+
+**Note** that the operations are applied **sequentially**, not all at once.
+
+**Example 1:**
+
+**Input:** nums = [1,2,2,1,1,0]
+
+**Output:** [1,4,2,0,0,0]
+
+**Explanation:** We do the following operations: 
+
+- i = 0: nums[0] and nums[1] are not equal, so we skip this operation. 
+
+- i = 1: nums[1] and nums[2] are equal, we multiply nums[1] by 2 and change nums[2] to 0. The array becomes [1,**<ins>4</ins>**,**<ins>0</ins>**,1,1,0]. 
+
+- i = 2: nums[2] and nums[3] are not equal, so we skip this operation. 
+
+- i = 3: nums[3] and nums[4] are equal, we multiply nums[3] by 2 and change nums[4] to 0. The array becomes [1,4,0,**<ins>2</ins>**,**<ins>0</ins>**,0]. 
+
+- i = 4: nums[4] and nums[5] are equal, we multiply nums[4] by 2 and change nums[5] to 0. The array becomes [1,4,0,2,**<ins>0</ins>**,**<ins>0</ins>**]. 
+
+After that, we shift the 0's to the end, which gives the array [1,4,2,0,0,0].
+
+**Example 2:**
+
+**Input:** nums = [0,1]
+
+**Output:** [1,0]
+
+**Explanation:** No operation can be applied, we just shift the 0 to the end.
+
+**Constraints:**
+
+*   `2 <= nums.length <= 2000`
+*   `0 <= nums[i] <= 1000`

src/main/java/g2401_2500/s2461_maximum_sum_of_distinct_subarrays_with_length_k/Solution.java

@@ -0,0 +1,33 @@
+package g2401_2500.s2461_maximum_sum_of_distinct_subarrays_with_length_k;
+
+// #Medium #Array #Hash_Table #Sliding_Window #2022_12_20_Time_40_ms_(93.40%)_Space_59.8_MB_(89.83%)
+
+import java.util.HashSet;
+import java.util.Set;
+
+public class Solution {
+    public long maximumSubarraySum(int[] nums, int k) {
+        Set<Integer> seen = new HashSet<>();
+        long sum = 0;
+        long current = 0;
+        int i = 0;
+        int j = 0;
+        while (j < nums.length) {
+            while (seen.contains(nums[j])) {
+                int val = nums[i++];
+                seen.remove(val);
+                current -= val;
+            }
+            seen.add(nums[j]);
+            current += nums[j];
+            j++;
+            if (seen.size() == k) {
+                sum = Math.max(sum, current);
+                current -= nums[i];
+                seen.remove(nums[i]);
+                i++;
+            }
+        }
+        return sum;
+    }
+}