Added tasks 2412, 2413, 2414, 2415, 2416, 2418, 2419, 2420, 2421, 2423, 2424, 2425, 2426.

Author: javadev

src/main/java/g2401_2500/s2412_minimum_money_required_before_transactions/Solution.java

@@ -0,0 +1,19 @@
+package g2401_2500.s2412_minimum_money_required_before_transactions;
+
+// #Hard #Array #Sorting #Greedy #2022_11_15_Time_4_ms_(97.57%)_Space_98_MB_(87.50%)
+
+public class Solution {
+    public long minimumMoney(int[][] transactions) {
+        int max = 0;
+        long sum = 0;
+        for (int[] transaction : transactions) {
+            int diff = transaction[1] - transaction[0];
+            if (diff < 0) {
+                sum -= diff;
+                transaction[0] += diff;
+            }
+            max = Math.max(max, transaction[0]);
+        }
+        return max + sum;
+    }
+}

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

@@ -0,0 +1,41 @@
+2412\. Minimum Money Required Before Transactions
+
+Hard
+
+You are given a **0-indexed** 2D integer array `transactions`, where <code>transactions[i] = [cost<sub>i</sub>, cashback<sub>i</sub>]</code>.
+
+The array describes transactions, where each transaction must be completed exactly once in **some order**. At any given moment, you have a certain amount of `money`. In order to complete transaction `i`, <code>money >= cost<sub>i</sub></code> must hold true. After performing a transaction, `money` becomes <code>money - cost<sub>i</sub> + cashback<sub>i</sub></code>.
+
+Return _the minimum amount of_ `money` _required before any transaction so that all of the transactions can be completed **regardless of the order** of the transactions._
+
+**Example 1:**
+
+**Input:** transactions = [[2,1],[5,0],[4,2]]
+
+**Output:** 10
+
+**Explanation:**
+
+Starting with money = 10, the transactions can be performed in any order.
+
+It can be shown that starting with money < 10 will fail to complete all transactions in some order. 
+
+**Example 2:**
+
+**Input:** transactions = [[3,0],[0,3]]
+
+**Output:** 3
+
+**Explanation:**
+
+- If transactions are in the order [[3,0],[0,3]], the minimum money required to complete the transactions is 3.
+
+- If transactions are in the order [[0,3],[3,0]], the minimum money required to complete the transactions is 0.
+
+Thus, starting with money = 3, the transactions can be performed in any order. 
+
+**Constraints:**
+
+*   <code>1 <= transactions.length <= 10<sup>5</sup></code>
+*   `transactions[i].length == 2`
+*   <code>0 <= cost<sub>i</sub>, cashback<sub>i</sub> <= 10<sup>9</sup></code>

src/main/java/g2401_2500/s2413_smallest_even_multiple/Solution.java

@@ -0,0 +1,9 @@
+package g2401_2500.s2413_smallest_even_multiple;
+
+// #Easy #Math #Number_Theory #2022_11_15_Time_0_ms_(100.00%)_Space_40.9_MB_(48.99%)
+
+public class Solution {
+    public int smallestEvenMultiple(int n) {
+        return n % 2 == 0 ? n : n * 2;
+    }
+}

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

@@ -0,0 +1,25 @@
+2413\. Smallest Even Multiple
+
+Easy
+
+Given a **positive** integer `n`, return _the smallest positive integer that is a multiple of **both**_ `2` _and_ `n`.
+
+**Example 1:**
+
+**Input:** n = 5
+
+**Output:** 10
+
+**Explanation:** The smallest multiple of both 5 and 2 is 10. 
+
+**Example 2:**
+
+**Input:** n = 6
+
+**Output:** 6
+
+**Explanation:** The smallest multiple of both 6 and 2 is 6. Note that a number is a multiple of itself. 
+
+**Constraints:**
+
+*   `1 <= n <= 150`

src/main/java/g2401_2500/s2414_length_of_the_longest_alphabetical_continuous_substring/Solution.java

@@ -0,0 +1,21 @@
+package g2401_2500.s2414_length_of_the_longest_alphabetical_continuous_substring;
+
+// #Medium #String #2022_11_15_Time_28_ms_(36.44%)_Space_53.9_MB_(81.43%)
+
+public class Solution {
+    public int longestContinuousSubstring(String s) {
+        int ans = 0;
+        int cnt = 1;
+        int j = 1;
+        while (j < s.length()) {
+            if (s.charAt(j) == s.charAt(j - 1) + 1) {
+                cnt++;
+            } else {
+                ans = Math.max(ans, cnt);
+                cnt = 1;
+            }
+            j++;
+        }
+        return Math.max(ans, cnt);
+    }
+}

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

@@ -0,0 +1,32 @@
+2414\. Length of the Longest Alphabetical Continuous Substring
+
+Medium
+
+An **alphabetical continuous string** is a string consisting of consecutive letters in the alphabet. In other words, it is any substring of the string `"abcdefghijklmnopqrstuvwxyz"`.
+
+*   For example, `"abc"` is an alphabetical continuous string, while `"acb"` and `"za"` are not.
+
+Given a string `s` consisting of lowercase letters only, return the _length of the **longest** alphabetical continuous substring._
+
+**Example 1:**
+
+**Input:** s = "abacaba"
+
+**Output:** 2
+
+**Explanation:** There are 4 distinct continuous substrings: "a", "b", "c" and "ab".
+
+"ab" is the longest continuous substring. 
+
+**Example 2:**
+
+**Input:** s = "abcde"
+
+**Output:** 5
+
+**Explanation:** "abcde" is the longest continuous substring. 
+
+**Constraints:**
+
+*   <code>1 <= s.length <= 10<sup>5</sup></code>
+*   `s` consists of only English lowercase letters.

src/main/java/g2401_2500/s2415_reverse_odd_levels_of_binary_tree/Solution.java

@@ -0,0 +1,72 @@
+package g2401_2500.s2415_reverse_odd_levels_of_binary_tree;
+
+// #Medium #Tree #Binary_Tree #Depth_First_Search #Breadth_First_Search
+// #2022_11_15_Time_12_ms_(64.14%)_Space_49.7_MB_(87.20%)
+
+import com_github_leetcode.TreeNode;
+import java.util.ArrayList;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Queue;
+
+/*
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode() {}
+ *     TreeNode(int val) { this.val = val; }
+ *     TreeNode(int val, TreeNode left, TreeNode right) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
+ * }
+ */
+public class Solution {
+    private List<Integer> list = new ArrayList<>();
+
+    public TreeNode reverseOddLevels(TreeNode root) {
+        solve(root);
+        return enrich(list, 0);
+    }
+
+    private TreeNode enrich(List<Integer> list, int i) {
+        TreeNode root = null;
+        if (i < list.size()) {
+            root = new TreeNode(list.get(i));
+            root.left = enrich(list, 2 * i + 1);
+            root.right = enrich(list, 2 * i + 2);
+        }
+        return root;
+    }
+
+    private void solve(TreeNode root) {
+        Queue<TreeNode> q = new LinkedList<>();
+        q.add(root);
+        int level = 0;
+        while (!q.isEmpty()) {
+            int size = q.size();
+            List<Integer> res = new ArrayList<>();
+            for (int i = 0; i < size; i++) {
+                TreeNode cur = q.remove();
+                res.add(cur.val);
+                if (cur.left != null) {
+                    q.add(cur.left);
+                }
+                if (cur.right != null) {
+                    q.add(cur.right);
+                }
+            }
+            if (level % 2 != 0) {
+                for (int i = res.size() - 1; i >= 0; i--) {
+                    list.add(res.get(i));
+                }
+            } else {
+                list.addAll(res);
+            }
+            level++;
+        }
+    }
+}

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

@@ -0,0 +1,59 @@
+2415\. Reverse Odd Levels of Binary Tree
+
+Medium
+
+Given the `root` of a **perfect** binary tree, reverse the node values at each **odd** level of the tree.
+
+*   For example, suppose the node values at level 3 are `[2,1,3,4,7,11,29,18]`, then it should become `[18,29,11,7,4,3,1,2]`.
+
+Return _the root of the reversed tree_.
+
+A binary tree is **perfect** if all parent nodes have two children and all leaves are on the same level.
+
+The **level** of a node is the number of edges along the path between it and the root node.
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2022/07/28/first_case1.png)
+
+**Input:** root = [2,3,5,8,13,21,34]
+
+**Output:** [2,5,3,8,13,21,34]
+
+**Explanation:**
+
+The tree has only one odd level.
+
+The nodes at level 1 are 3, 5 respectively, which are reversed and become 5, 3. 
+
+**Example 2:**
+
+![](https://assets.leetcode.com/uploads/2022/07/28/second_case3.png)
+
+**Input:** root = [7,13,11]
+
+**Output:** [7,11,13]
+
+**Explanation:**
+
+The nodes at level 1 are 13, 11, which are reversed and become 11, 13. 
+
+**Example 3:**
+
+**Input:** root = [0,1,2,0,0,0,0,1,1,1,1,2,2,2,2]
+
+**Output:** [0,2,1,0,0,0,0,2,2,2,2,1,1,1,1]
+
+**Explanation:**
+
+The odd levels have non-zero values.
+
+The nodes at level 1 were 1, 2, and are 2, 1 after the reversal.
+
+The nodes at level 3 were 1, 1, 1, 1, 2, 2, 2, 2, and are 2, 2, 2, 2, 1, 1, 1, 1 after the reversal. 
+
+**Constraints:**
+
+*   The number of nodes in the tree is in the range <code>[1, 2<sup>14</sup>]</code>.
+*   <code>0 <= Node.val <= 10<sup>5</sup></code>
+*   `root` is a **perfect** binary tree.

src/main/java/g2401_2500/s2416_sum_of_prefix_scores_of_strings/Solution.java

@@ -0,0 +1,52 @@
+package g2401_2500.s2416_sum_of_prefix_scores_of_strings;
+
+// #Hard #Array #String #Counting #Trie #2022_11_15_Time_179_ms_(94.98%)_Space_374.1_MB_(10.98%)
+
+public class Solution {
+    private Solution[] child;
+    private int ct;
+
+    public Solution() {
+        child = new Solution[26];
+        ct = 0;
+    }
+
+    public int[] sumPrefixScores(String[] words) {
+        for (String s : words) {
+            insert(s);
+        }
+        int[] res = new int[words.length];
+        for (int i = 0; i < words.length; i++) {
+            String word = words[i];
+            res[i] = countPre(word);
+        }
+        return res;
+    }
+
+    private void insert(String word) {
+        Solution cur = this;
+        for (int i = 0; i < word.length(); i++) {
+            int id = word.charAt(i) - 'a';
+            if (cur.child[id] == null) {
+                cur.child[id] = new Solution();
+            }
+            cur.child[id].ct++;
+            cur = cur.child[id];
+        }
+    }
+
+    private int countPre(String word) {
+        Solution cur = this;
+        int localCt = 0;
+        for (int i = 0; i < word.length(); i++) {
+            int id = word.charAt(i) - 'a';
+            if (cur.child[id] == null) {
+                return localCt;
+            }
+            localCt += cur.ct;
+            cur = cur.child[id];
+        }
+        localCt += cur.ct;
+        return localCt;
+    }
+}