Added tasks 722, 724, 725, 726.

Author: ThanhNIT

src/main/java/g0701_0800/s0722_remove_comments/Solution.java

@@ -0,0 +1,56 @@
+package g0701_0800.s0722_remove_comments;
+
+// #Medium #Array #String
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class Solution {
+    public List<String> removeComments(String[] source) {
+        List<String> result = new ArrayList<>();
+        StringBuilder sb = new StringBuilder();
+        boolean multiComment = false;
+        for (String line : source) {
+            int n = line.length();
+            int index = 0;
+            while (index < n) {
+                char ch = line.charAt(index);
+                if (!multiComment && ch == '/') {
+                    index++;
+                    if (index >= n) {
+                        sb.append(ch);
+                        continue;
+                    }
+                    if (line.charAt(index) == '/') {
+                        break;
+                    } else if (line.charAt(index) == '*') {
+                        multiComment = true;
+                    } else {
+                        sb.append(ch).append(line.charAt(index));
+                    }
+                } else if (multiComment && ch == '*') {
+                    index++;
+                    if (index >= n) {
+                        continue;
+                    }
+                    if (line.charAt(index) == '/') {
+                        multiComment = false;
+                    } else {
+                        index--;
+                    }
+                } else if (!multiComment) {
+                    sb.append(ch);
+                }
+
+                index++;
+            }
+
+            if (sb.length() > 0 && !multiComment) {
+                result.add(sb.toString());
+                sb.setLength(0);
+            }
+        }
+
+        return result;
+    }
+}

src/main/java/g0701_0800/s0722_remove_comments/readme.md

@@ -0,0 +1,72 @@
+722. Remove Comments
+
+Medium
+
+Given a C++ program, remove comments from it. The program source is an array of strings `source` where `source[i]` is the <code>i<sup>th</sup></code> line of the source code. This represents the result of splitting the original source code string by the newline character `'  
+'`.
+
+In C++, there are two types of comments, line comments, and block comments.
+
+*   The string `"//"` denotes a line comment, which represents that it and the rest of the characters to the right of it in the same line should be ignored.
+*   The string `"/*"` denotes a block comment, which represents that all characters until the next (non-overlapping) occurrence of `"*/"` should be ignored. (Here, occurrences happen in reading order: line by line from left to right.) To be clear, the string `"/*/"` does not yet end the block comment, as the ending would be overlapping the beginning.
+
+The first effective comment takes precedence over others.
+
+*   For example, if the string `"//"` occurs in a block comment, it is ignored.
+*   Similarly, if the string `"/*"` occurs in a line or block comment, it is also ignored.
+
+If a certain line of code is empty after removing comments, you must not output that line: each string in the answer list will be non-empty.
+
+There will be no control characters, single quote, or double quote characters.
+
+*   For example, `source = "string s = "/* Not a comment. */";"` will not be a test case.
+
+Also, nothing else such as defines or macros will interfere with the comments.
+
+It is guaranteed that every open block comment will eventually be closed, so `"/*"` outside of a line or block comment always starts a new comment.
+
+Finally, implicit newline characters can be deleted by block comments. Please see the examples below for details.
+
+After removing the comments from the source code, return _the source code in the same format_.
+
+**Example 1:**
+
+**Input:** source = ["/*Test program */", "int main()", "{ ", " // variable declaration ", "int a, b, c;", "/* This is a test", " multiline ", " comment for ", " testing */", "a = b + c;", "}"]
+
+**Output:** ["int main()","{ "," ","int a, b, c;","a = b + c;","}"]
+
+**Explanation:** The line by line code is visualized as below: 
+
+    /*Test program */ 
+    int main() { 
+    // variable declaration 
+    int a, b, c; 
+    /* This is a test 
+    multiline comment 
+    for testing */ 
+    a = b + c; 
+    } 
+    The string /* denotes a block comment, including line 1 and lines 6-9. The string // denotes line 4 as comments. 
+    The line by line output code is visualized as below: 
+    int main() { 
+    int a, b, c; 
+    a = b + c; 
+    }
+
+**Example 2:**
+
+**Input:** source = ["a/*comment", "line", "more_comment*/b"]
+
+**Output:** ["ab"]
+
+**Explanation:** The original source string is "a/*comment  
+line  
+more_comment*/b", where we have bolded the newline characters. After deletion, the implicit newline characters are deleted, leaving the string "ab", which when delimited by newline characters becomes ["ab"].
+
+**Constraints:**
+
+*   `1 <= source.length <= 100`
+*   `0 <= source[i].length <= 80`
+*   `source[i]` consists of printable **ASCII** characters.
+*   Every open block comment is eventually closed.
+*   There are no single-quote or double-quote in the input.

src/main/java/g0701_0800/s0724_find_pivot_index/Solution.java

@@ -0,0 +1,23 @@
+package g0701_0800.s0724_find_pivot_index;
+
+// #Easy #Array #Prefix_Sum
+
+public class Solution {
+    public int pivotIndex(int[] nums) {
+        if (nums == null || nums.length == 0) {
+            return -1;
+        }
+        int[] sums = new int[nums.length];
+        sums[0] = nums[0];
+        for (int i = 1; i < nums.length; i++) {
+            sums[i] = sums[i - 1] + nums[i];
+        }
+        for (int i = 0; i < nums.length; i++) {
+            int temp = sums[nums.length - 1] - sums[i];
+            if (i == 0 && 0 == temp || (i > 0 && sums[i - 1] == temp)) {
+                return i;
+            }
+        }
+        return -1;
+    }
+}

src/main/java/g0701_0800/s0724_find_pivot_index/readme.md

@@ -0,0 +1,56 @@
+724\. Find Pivot Index
+
+Easy
+
+Given an array of integers `nums`, calculate the **pivot index** of this array.
+
+The **pivot index** is the index where the sum of all the numbers **strictly** to the left of the index is equal to the sum of all the numbers **strictly** to the index's right.
+
+If the index is on the left edge of the array, then the left sum is `0` because there are no elements to the left. This also applies to the right edge of the array.
+
+Return _the **leftmost pivot index**_. If no such index exists, return -1.
+
+**Example 1:**
+
+**Input:** nums = [1,7,3,6,5,6]
+
+**Output:** 3
+
+**Explanation:** 
+
+The pivot index is 3. 
+
+Left sum = nums[0] + nums[1] + nums[2] = 1 + 7 + 3 = 11 
+
+Right sum = nums[4] + nums[5] = 5 + 6 = 11
+
+**Example 2:**
+
+**Input:** nums = [1,2,3]
+
+**Output:** -1
+
+**Explanation:** 
+
+There is no index that satisfies the conditions in the problem statement.
+
+**Example 3:**
+
+**Input:** nums = [2,1,-1]
+
+**Output:** 0
+
+**Explanation:** 
+
+The pivot index is 0. 
+
+Left sum = 0 (no elements to the left of index 0) 
+
+Right sum = nums[1] + nums[2] = 1 + -1 = 0
+
+**Constraints:**
+
+*   <code>1 <= nums.length <= 10<sup>4</sup></code>
+*   `-1000 <= nums[i] <= 1000`
+
+**Note:** This question is the same as 1991: [https://leetcode.com/problems/find-the-middle-index-in-array/](https://leetcode.com/problems/find-the-middle-index-in-array/)

src/main/java/g0701_0800/s0725_split_linked_list_in_parts/Solution.java

@@ -0,0 +1,42 @@
+package g0701_0800.s0725_split_linked_list_in_parts;
+
+// #Medium #Linked_List
+
+import com_github_leetcode.ListNode;
+import java.util.Objects;
+
+public class Solution {
+    public ListNode[] splitListToParts(ListNode head, int k) {
+        int len = getLength(head);
+        int aveSize = len / k;
+        int extra = len % k;
+        ListNode[] result = new ListNode[k];
+        for (int i = 0; i < k; i++) {
+            result[i] = head;
+            int aveSizeTmp = aveSize;
+            aveSizeTmp += extra-- > 0 ? 1 : 0;
+            int aveSizeTmp2 = aveSizeTmp;
+            while (aveSizeTmp-- > 0) {
+                head = Objects.requireNonNull(head).next;
+            }
+            if (result[i] != null) {
+                ListNode tmp = result[i];
+                while (tmp.next != null && aveSizeTmp2-- > 1) {
+                    tmp = tmp.next;
+                }
+                tmp.next = null;
+            }
+        }
+        return result;
+    }
+
+    private int getLength(ListNode root) {
+        int len = 0;
+        ListNode tmp = root;
+        while (tmp != null) {
+            len++;
+            tmp = tmp.next;
+        }
+        return len;
+    }
+}

src/main/java/g0701_0800/s0725_split_linked_list_in_parts/readme.md

@@ -0,0 +1,43 @@
+725\. Split Linked List in Parts
+
+Medium
+
+Given the `head` of a singly linked list and an integer `k`, split the linked list into `k` consecutive linked list parts.
+
+The length of each part should be as equal as possible: no two parts should have a size differing by more than one. This may lead to some parts being null.
+
+The parts should be in the order of occurrence in the input list, and parts occurring earlier should always have a size greater than or equal to parts occurring later.
+
+Return _an array of the_ `k` _parts_.
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2021/06/13/split1-lc.jpg)
+
+**Input:** head = [1,2,3], k = 5
+
+**Output:** [[1],[2],[3],[],[]]
+
+**Explanation:** 
+
+The first element output[0] has output[0].val = 1, output[0].next = null. 
+
+The last element output[4] is null, but its string representation as a ListNode is [].
+
+**Example 2:**
+
+![](https://assets.leetcode.com/uploads/2021/06/13/split2-lc.jpg)
+
+**Input:** head = [1,2,3,4,5,6,7,8,9,10], k = 3
+
+**Output:** [[1,2,3,4],[5,6,7],[8,9,10]]
+
+**Explanation:** 
+
+The input has been split into consecutive parts with size difference at most 1, and earlier parts are a larger size than the later parts.
+
+**Constraints:**
+
+*   The number of nodes in the list is in the range `[0, 1000]`.
+*   `0 <= Node.val <= 1000`
+*   `1 <= k <= 50`

src/main/java/g0701_0800/s0726_number_of_atoms/Solution.java

@@ -0,0 +1,73 @@
+package g0701_0800.s0726_number_of_atoms;
+
+// #Hard #String #Hash_Table #Stack
+
+import java.util.ArrayList;
+import java.util.Comparator;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Stack;
+
+public class Solution {
+    private boolean isLower(char c) {
+        return c >= 97 && c <= 122;
+    }
+
+    private boolean isDigit(char c) {
+        return c >= 48 && c <= 57;
+    }
+
+    public String countOfAtoms(String formula) {
+        int product = 1;
+        Stack<Integer> mlrStack = new Stack<>();
+        Map<String, Integer> count = new HashMap<>();
+        for (int i = formula.length() - 1; i >= 0; --i) {
+            char c = formula.charAt(i);
+
+            if (c == '(') {
+                product /= mlrStack.pop();
+                continue;
+            }
+
+            int rank = 1;
+            int mlr = 0;
+            while (isDigit(c)) {
+                mlr += rank * (c - 48);
+                rank *= 10;
+                c = formula.charAt(--i);
+            }
+            if (mlr == 0) {
+                ++mlr;
+            }
+            mlrStack.push(mlr);
+            product *= mlr;
+
+            if (c == ')') {
+                continue;
+            }
+
+            StringBuilder atom = new StringBuilder();
+            while (isLower(c)) {
+                atom.insert(0, c);
+                c = formula.charAt(--i);
+            }
+            atom.insert(0, c);
+            String name = atom.toString();
+
+            count.put(name, count.getOrDefault(name, 0) + product);
+
+            product /= mlrStack.pop();
+        }
+        List<String> atomList = new ArrayList<>(count.keySet());
+        atomList.sort(Comparator.naturalOrder());
+        StringBuilder res = new StringBuilder();
+        for (String atom : atomList) {
+            res.append(atom);
+            if (count.get(atom) > 1) {
+                res.append(count.get(atom));
+            }
+        }
+        return res.toString();
+    }
+}