Updated tasks 322-1143

Author: ThanhNIT

src/main/java/g0301_0400/s0347_top_k_frequent_elements/readme.md

@@ -16,9 +16,16 @@ Given an integer array `nums` and an integer `k`, return _the_ `k` _most frequen
 
 **Output:** [1]
 
+**Example 3:**
+
+**Input:** nums = [1,2,1,2,1,2,3,1,3,2], k = 2
+
+**Output:** [1,2]
+
 **Constraints:**
 
 *   <code>1 <= nums.length <= 10<sup>5</sup></code>
+*   <code>-10<sup>4</sup> <= nums[i] <= 10<sup>4</sup></code>
 *   `k` is in the range `[1, the number of unique elements in the array]`.
 *   It is **guaranteed** that the answer is **unique**.
 

src/main/java/g0301_0400/s0373_find_k_pairs_with_smallest_sums/readme.md

@@ -2,7 +2,7 @@
 
 Medium
 
-You are given two integer arrays `nums1` and `nums2` sorted in **ascending order** and an integer `k`.
+You are given two integer arrays `nums1` and `nums2` sorted in **non-decreasing order** and an integer `k`.
 
 Define a pair `(u, v)` which consists of one element from the first array and one element from the second array.
 
@@ -14,27 +14,20 @@ Return _the_ `k` _pairs_ <code>(u<sub>1</sub>, v<sub>1</sub>), (u<sub>2</sub>, v
 
 **Output:** [[1,2],[1,4],[1,6]]
 
-**Explanation:** The first 3 pairs are returned from the sequence: [1,2],[1,4],[1,6],[7,2],[7,4],[11,2],[7,6],[11,4],[11,6]
+**Explanation:** The first 3 pairs are returned from the sequence: [1,2],[1,4],[1,6],[7,2],[7,4],[11,2],[7,6],[11,4],[11,6] 
 
 **Example 2:**
 
 **Input:** nums1 = [1,1,2], nums2 = [1,2,3], k = 2
 
 **Output:** [[1,1],[1,1]]
 
-**Explanation:** The first 2 pairs are returned from the sequence: [1,1],[1,1],[1,2],[2,1],[1,2],[2,2],[1,3],[1,3],[2,3]
-
-**Example 3:**
-
-**Input:** nums1 = [1,2], nums2 = [3], k = 3
-
-**Output:** [[1,3],[2,3]]
-
-**Explanation:** All possible pairs are returned from the sequence: [1,3],[2,3]
+**Explanation:** The first 2 pairs are returned from the sequence: [1,1],[1,1],[1,2],[2,1],[1,2],[2,2],[1,3],[1,3],[2,3] 
 
 **Constraints:**
 
 *   <code>1 <= nums1.length, nums2.length <= 10<sup>5</sup></code>
 *   <code>-10<sup>9</sup> <= nums1[i], nums2[i] <= 10<sup>9</sup></code>
-*   `nums1` and `nums2` both are sorted in **ascending order**.
-*   `1 <= k <= 1000`
+*   `nums1` and `nums2` both are sorted in **non-decreasing order**.
+*   <code>1 <= k <= 10<sup>4</sup></code>
+*   `k <= nums1.length * nums2.length`

src/main/java/g0301_0400/s0380_insert_delete_getrandom_o1/readme.md

@@ -35,4 +35,4 @@ You must implement the functions of the class such that each function works in *
 
 *   <code>-2<sup>31</sup> <= val <= 2<sup>31</sup> - 1</code>
 *   At most `2 * `<code>10<sup>5</sup></code> calls will be made to `insert`, `remove`, and `getRandom`.
-*   There will be **at least one** element in the data structure when `getRandom` is called.
+*   There will be **at least one** element in the data structure when `getRandom` is called.

src/main/java/g0301_0400/s0383_ransom_note/readme.md

@@ -2,27 +2,27 @@
 
 Easy
 
-Given two stings `ransomNote` and `magazine`, return `true` if `ransomNote` can be constructed from `magazine` and `false` otherwise.
+Given two strings `ransomNote` and `magazine`, return `true` _if_ `ransomNote` _can be constructed by using the letters from_ `magazine` _and_ `false` _otherwise_.
 
 Each letter in `magazine` can only be used once in `ransomNote`.
 
 **Example 1:**
 
 **Input:** ransomNote = "a", magazine = "b"
 
-**Output:** false
+**Output:** false 
 
 **Example 2:**
 
 **Input:** ransomNote = "aa", magazine = "ab"
 
-**Output:** false
+**Output:** false 
 
 **Example 3:**
 
 **Input:** ransomNote = "aa", magazine = "aab"
 
-**Output:** true
+**Output:** true 
 
 **Constraints:**
 

src/main/java/g0301_0400/s0392_is_subsequence/readme.md

@@ -4,19 +4,19 @@ Easy
 
 Given two strings `s` and `t`, return `true` _if_ `s` _is a **subsequence** of_ `t`_, or_ `false` _otherwise_.
 
-A **subsequence** of a string is a new string that is formed from the original string by deleting some (can be none) of the characters without disturbing the relative positions of the remaining characters. (i.e., `"ace"` is a subsequence of `"abcde"` while `"aec"` is not).
+A **subsequence** of a string is a new string that is formed from the original string by deleting some (can be none) of the characters without disturbing the relative positions of the remaining characters. (i.e., `"ace"` is a subsequence of <code>"<ins>a</ins>b<ins>c</ins>d<ins>e</ins>"</code> while `"aec"` is not).
 
 **Example 1:**
 
 **Input:** s = "abc", t = "ahbgdc"
 
-**Output:** true
+**Output:** true 
 
 **Example 2:**
 
 **Input:** s = "axc", t = "ahbgdc"
 
-**Output:** false
+**Output:** false 
 
 **Constraints:**
 

src/main/java/g0301_0400/s0394_decode_string/readme.md

@@ -6,9 +6,9 @@ Given an encoded string, return its decoded string.
 
 The encoding rule is: `k[encoded_string]`, where the `encoded_string` inside the square brackets is being repeated exactly `k` times. Note that `k` is guaranteed to be a positive integer.
 
-You may assume that the input string is always valid; No extra white spaces, square brackets are well-formed, etc.
+You may assume that the input string is always valid; there are no extra white spaces, square brackets are well-formed, etc. Furthermore, you may assume that the original data does not contain any digits and that digits are only for those repeat numbers, `k`. For example, there will not be input like `3a` or `2[4]`.
 
-Furthermore, you may assume that the original data does not contain any digits and that digits are only for those repeat numbers, `k`. For example, there won't be input like `3a` or `2[4]`.
+The test cases are generated so that the length of the output will never exceed <code>10<sup>5</sup></code>.
 
 **Example 1:**
 
@@ -28,12 +28,6 @@ Furthermore, you may assume that the original data does not contain any digits a
 
 **Output:** "abcabccdcdcdef" 
 
-**Example 4:**
-
-**Input:** s = "abc3[cd]xyz"
-
-**Output:** "abccdcdcdxyz" 
-
 **Constraints:**
 
 *   `1 <= s.length <= 30`

src/main/java/g0301_0400/s0399_evaluate_division/readme.md

@@ -10,6 +10,8 @@ Return _the answers to all queries_. If a single answer cannot be determined, re
 
 **Note:** The input is always valid. You may assume that evaluating the queries will not result in division by zero and that there is no contradiction.
 
+**Note:** The variables that do not occur in the list of equations are undefined, so the answer cannot be determined for them.
+
 **Example 1:**
 
 **Input:** equations = [["a","b"],["b","c"]], values = [2.0,3.0], queries = [["a","c"],["b","a"],["a","e"],["a","a"],["x","x"]]
@@ -28,13 +30,13 @@ return: [6.0, 0.5, -1.0, 1.0, -1.0 ]
 
 **Input:** equations = [["a","b"],["b","c"],["bc","cd"]], values = [1.5,2.5,5.0], queries = [["a","c"],["c","b"],["bc","cd"],["cd","bc"]]
 
-**Output:** [3.75000,0.40000,5.00000,0.20000]
+**Output:** [3.75000,0.40000,5.00000,0.20000] 
 
 **Example 3:**
 
 **Input:** equations = [["a","b"]], values = [0.5], queries = [["a","b"],["b","a"],["a","c"],["x","y"]]
 
-**Output:** [0.50000,2.00000,-1.00000,-1.00000]
+**Output:** [0.50000,2.00000,-1.00000,-1.00000] 
 
 **Constraints:**
 

src/main/java/g0401_0500/s0416_partition_equal_subset_sum/readme.md

@@ -2,7 +2,7 @@
 
 Medium
 
-Given a **non-empty** array `nums` containing **only positive integers**, find if the array can be partitioned into two subsets such that the sum of elements in both subsets is equal.
+Given an integer array `nums`, return `true` _if you can partition the array into two subsets such that the sum of the elements in both subsets is equal or_ `false` _otherwise_.
 
 **Example 1:**
 

src/main/java/g0401_0500/s0427_construct_quad_tree/readme.md

@@ -2,11 +2,9 @@
 
 Medium
 
-Given a `n * n` matrix `grid` of `0's` and `1's` only. We want to represent the `grid` with a Quad-Tree.
+Given a `n * n` matrix `grid` of `0's` and `1's` only. We want to represent `grid` with a Quad-Tree.
 
-Return _the root of the Quad-Tree_ representing the `grid`.
-
-Notice that you can assign the value of a node to **True** or **False** when `isLeaf` is **False**, and both are **accepted** in the answer.
+Return _the root of the Quad-Tree representing_ `grid`.
 
 A Quad-Tree is a tree data structure in which each internal node has exactly four children. Besides, each node has two attributes:
 
@@ -34,7 +32,7 @@ If you want to know more about the Quad-Tree, you can refer to the [wiki](https:
 
 **Quad-Tree format:**
 
-The output represents the serialized format of a Quad-Tree using level order traversal, where `null` signifies a path terminator where no node exists below.
+You don't need to read this section for solving the problem. This is only if you want to understand the output format here. The output represents the serialized format of a Quad-Tree using level order traversal, where `null` signifies a path terminator where no node exists below.
 
 It is very similar to the serialization of the binary tree. The only difference is that the node is represented as a list `[isLeaf, val]`.
 
@@ -75,4 +73,4 @@ If the value of `isLeaf` or `val` is True we represent it as **1** in the list `
 **Constraints:**
 
 *   `n == grid.length == grid[i].length`
-*   <code>n == 2<sup>x</sup></code> where `0 <= x <= 6`
+*   <code>n == 2<sup>x</sup></code> where `0 <= x <= 6`

src/main/java/g0401_0500/s0433_minimum_genetic_mutation/readme.md

@@ -4,38 +4,30 @@ Medium
 
 A gene string can be represented by an 8-character long string, with choices from `'A'`, `'C'`, `'G'`, and `'T'`.
 
-Suppose we need to investigate a mutation from a gene string `start` to a gene string `end` where one mutation is defined as one single character changed in the gene string.
+Suppose we need to investigate a mutation from a gene string `startGene` to a gene string `endGene` where one mutation is defined as one single character changed in the gene string.
 
 *   For example, `"AACCGGTT" --> "AACCGGTA"` is one mutation.
 
 There is also a gene bank `bank` that records all the valid gene mutations. A gene must be in `bank` to make it a valid gene string.
 
-Given the two gene strings `start` and `end` and the gene bank `bank`, return _the minimum number of mutations needed to mutate from_ `start` _to_ `end`. If there is no such a mutation, return `-1`.
+Given the two gene strings `startGene` and `endGene` and the gene bank `bank`, return _the minimum number of mutations needed to mutate from_ `startGene` _to_ `endGene`. If there is no such a mutation, return `-1`.
 
 Note that the starting point is assumed to be valid, so it might not be included in the bank.
 
 **Example 1:**
 
-**Input:** start = "AACCGGTT", end = "AACCGGTA", bank = ["AACCGGTA"]
+**Input:** startGene = "AACCGGTT", endGene = "AACCGGTA", bank = ["AACCGGTA"]
 
 **Output:** 1 
 
 **Example 2:**
 
-**Input:** start = "AACCGGTT", end = "AAACGGTA", bank = ["AACCGGTA","AACCGCTA","AAACGGTA"]
+**Input:** startGene = "AACCGGTT", endGene = "AAACGGTA", bank = ["AACCGGTA","AACCGCTA","AAACGGTA"]
 
 **Output:** 2 
 
-**Example 3:**
-
-**Input:** start = "AAAAACCC", end = "AACCCCCC", bank = ["AAAACCCC","AAACCCCC","AACCCCCC"]
-
-**Output:** 3 
-
 **Constraints:**
 
-*   `start.length == 8`
-*   `end.length == 8`
 *   `0 <= bank.length <= 10`
-*   `bank[i].length == 8`
-*   `start`, `end`, and `bank[i]` consist of only the characters `['A', 'C', 'G', 'T']`.
+*   `startGene.length == endGene.length == bank[i].length == 8`
+*   `startGene`, `endGene`, and `bank[i]` consist of only the characters `['A', 'C', 'G', 'T']`.