Updated readme.

Author: javadev

README.md

@@ -13,7 +13,7 @@
 
 | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- -->
 |-|-|-|-|-|-
-| 0001 |[Two Sum](src/main/java/g0001_0100/s0001_two_sum)| Easy | Top_100_Liked_Questions, Top_Interview_Questions, Array, Hash_Table | 3 | 80.08
+| 0001 |[Two Sum](src/main/java/g0001_0100/s0001_two_sum)| Easy | Top_100_Liked_Questions, Top_Interview_Questions, Array, Hash_Table | 1 | 99.68
 | 0088 |[Merge Sorted Array](src/main/java/g0001_0100/s0088_merge_sorted_array)| Easy | Top_Interview_Questions, Array, Sorting, Two_Pointers | 0 | 100.00
 
 #### Day 3 Array
@@ -1338,9 +1338,28 @@
 | 2181 |[Merge Nodes in Between Zeros](src/main/java/g2101_2200/s2181_merge_nodes_in_between_zeros)| Medium | Simulation, Linked_List | 6 | 96.26
 | 2172 |[Maximum AND Sum of Array](src/main/java/g2101_2200/s2172_maximum_and_sum_of_array)| Hard | Array, Dynamic_Programming, Bit_Manipulation, Bitmask | 21 | 87.50
 | 2166 |[Design Bitset](src/main/java/g2101_2200/s2166_design_bitset)| Medium | Array, Hash_Table, Design | 81 | 73.38
+| 2162 |[Minimum Cost to Set Cooking Time](src/main/java/g2101_2200/s2162_minimum_cost_to_set_cooking_time)| Medium | Math, Enumeration | 1 | 95.82
+| 2161 |[Partition Array According to Given Pivot](src/main/java/g2101_2200/s2161_partition_array_according_to_given_pivot)| Medium | Array, Two_Pointers, Simulation | 7 | 72.76
+| 2160 |[Minimum Sum of Four Digit Number After Splitting Digits](src/main/java/g2101_2200/s2160_minimum_sum_of_four_digit_number_after_splitting_digits)| Easy | Math, Sorting, Greedy | 1 | 78.31
+| 2155 |[All Divisions With the Highest Score of a Binary Array](src/main/java/g2101_2200/s2155_all_divisions_with_the_highest_score_of_a_binary_array)| Medium | Array | 18 | 98.41
 | 2154 |[Keep Multiplying Found Values by Two](src/main/java/g2101_2200/s2154_keep_multiplying_found_values_by_two)| Easy | Array, Hash_Table, Sorting, Simulation | 1 | 93.21
 | 2151 |[Maximum Good People Based on Statements](src/main/java/g2101_2200/s2151_maximum_good_people_based_on_statements)| Hard | Array, Bit_Manipulation, Backtracking, Enumeration | 76 | 47.57
 | 2150 |[Find All Lonely Numbers in the Array](src/main/java/g2101_2200/s2150_find_all_lonely_numbers_in_the_array)| Medium | Array, Hash_Table, Counting | 93 | 70.66
+| 2136 |[Earliest Possible Day of Full Bloom](src/main/java/g2101_2200/s2136_earliest_possible_day_of_full_bloom)| Hard | Array, Sorting, Greedy | 63 | 94.92
+| 2135 |[Count Words Obtained After Adding a Letter](src/main/java/g2101_2200/s2135_count_words_obtained_after_adding_a_letter)| Medium | Array, String, Hash_Table, Sorting, Bit_Manipulation | 67 | 93.08
+| 2134 |[Minimum Swaps to Group All 1's Together II](src/main/java/g2101_2200/s2134_minimum_swaps_to_group_all_1s_together_ii)| Medium | Array, Sliding_Window | 11 | 72.59
+| 2133 |[Check if Every Row and Column Contains All Numbers](src/main/java/g2101_2200/s2133_check_if_every_row_and_column_contains_all_numbers)| Easy | Array, Hash_Table, Matrix | 32 | 64.12
+| 2132 |[Stamping the Grid](src/main/java/g2101_2200/s2132_stamping_the_grid)| Hard | Array, Greedy, Matrix, Prefix_Sum | 11 | 93.06
+| 2131 |[Longest Palindrome by Concatenating Two Letter Words](src/main/java/g2101_2200/s2131_longest_palindrome_by_concatenating_two_letter_words)| Medium | Array, String, Hash_Table, Greedy, Counting | 73 | 76.60
+| 2130 |[Maximum Twin Sum of a Linked List](src/main/java/g2101_2200/s2130_maximum_twin_sum_of_a_linked_list)| Medium | Two_Pointers, Stack, Linked_List | 9 | 57.92
+| 2129 |[Capitalize the Title](src/main/java/g2101_2200/s2129_capitalize_the_title)| Easy | String | 2 | 94.22
+| 2127 |[Maximum Employees to Be Invited to a Meeting](src/main/java/g2101_2200/s2127_maximum_employees_to_be_invited_to_a_meeting)| Hard | Depth_First_Search, Graph, Topological_Sort | 37 | 85.71
+| 2126 |[Destroying Asteroids](src/main/java/g2101_2200/s2126_destroying_asteroids)| Medium | Array, Sorting, Greedy | 25 | 83.82
+| 2125 |[Number of Laser Beams in a Bank](src/main/java/g2101_2200/s2125_number_of_laser_beams_in_a_bank)| Medium | Array, String, Math, Matrix | 19 | 76.00
+| 2124 |[Check if All A's Appears Before All B's](src/main/java/g2101_2200/s2124_check_if_all_as_appears_before_all_bs)| Easy | String | 1 | 73.82
+| 2122 |[Recover the Original Array](src/main/java/g2101_2200/s2122_recover_the_original_array)| Hard | Array, Hash_Table, Sorting, Enumeration | 19 | 89.04
+| 2121 |[Intervals Between Identical Elements](src/main/java/g2101_2200/s2121_intervals_between_identical_elements)| Medium | Array, Hash_Table, Prefix_Sum | 93 | 79.63
+| 2120 |[Execution of All Suffix Instructions Staying in a Grid](src/main/java/g2101_2200/s2120_execution_of_all_suffix_instructions_staying_in_a_grid)| Medium | String, Simulation | 31 | 88.00
 | 2119 |[A Number After a Double Reversal](src/main/java/g2101_2200/s2119_a_number_after_a_double_reversal)| Easy | Math | 0 | 100.00
 | 2117 |[Abbreviating the Product of a Range](src/main/java/g2101_2200/s2117_abbreviating_the_product_of_a_range)| Hard | Math | 70 | 89.47
 | 2116 |[Check if a Parentheses String Can Be Valid](src/main/java/g2101_2200/s2116_check_if_a_parentheses_string_can_be_valid)| Medium | String, Greedy, Stack | 19 | 85.53
@@ -3016,5 +3035,5 @@
 | 0004 |[Median of Two Sorted Arrays](src/main/java/g0001_0100/s0004_median_of_two_sorted_arrays)| Hard | Top_100_Liked_Questions, Top_Interview_Questions, Array, Binary_Search, Divide_and_Conquer | 3 | 79.08
 | 0003 |[Longest Substring Without Repeating Characters](src/main/java/g0001_0100/s0003_longest_substring_without_repeating_characters)| Medium | Top_100_Liked_Questions, Top_Interview_Questions, String, Hash_Table, Sliding_Window, Algorithm_I_Day_6_Sliding_Window | 3 | 95.99
 | 0002 |[Add Two Numbers](src/main/java/g0001_0100/s0002_add_two_numbers)| Medium | Top_100_Liked_Questions, Top_Interview_Questions, Math, Linked_List, Recursion, Data_Structure_II_Day_10_Linked_List, Programming_Skills_II_Day_15 | 1 | 100.00
-| 0001 |[Two Sum](src/main/java/g0001_0100/s0001_two_sum)| Easy | Top_100_Liked_Questions, Top_Interview_Questions, Array, Hash_Table, Data_Structure_I_Day_2_Array | 3 | 80.08
+| 0001 |[Two Sum](src/main/java/g0001_0100/s0001_two_sum)| Easy | Top_100_Liked_Questions, Top_Interview_Questions, Array, Hash_Table, Data_Structure_I_Day_2_Array | 1 | 99.68
 

src/main/java/g0001_0100/s0001_two_sum/readme.md

@@ -40,45 +40,20 @@ You can return the answer in any order.
 ## Solution
 
 ```java
-import java.util.Arrays;
+import java.util.HashMap;
+import java.util.Map;
 
 public class Solution {
-    public int[] twoSum(int[] nums, int target) {
-        if (nums == null || nums.length <= 1) {
-            return new int[0];
-        }
-        int[] result = new int[2];
-        int left = 0;
-        int right = nums.length - 1;
-        int[] nums1 = Arrays.copyOf(nums, nums.length);
-        Arrays.sort(nums1);
-        while (left < right) {
-            if (nums1[left] + nums1[right] == target) {
-                break;
-            } else if (nums1[left] + nums1[right] > target) {
-                right--;
-            } else if (nums1[left] + nums1[right] < target) {
-                left++;
-            }
-        }
-
-        for (int i = 0; i < nums.length; i++) {
-            if (nums1[left] == nums[i]) {
-                result[0] = i;
-                break;
+    public int[] twoSum(int[] numbers, int target) {
+        Map<Integer, Integer> indexMap = new HashMap<>();
+        for (int i = 0; i < numbers.length; i++) {
+            Integer requiredNum = (Integer) (target - numbers[i]);
+            if (indexMap.containsKey(requiredNum)) {
+                return new int[] {indexMap.get(requiredNum), i};
             }
+            indexMap.put(numbers[i], i);
         }
-        for (int j = nums.length - 1; j >= 0; j--) {
-            if (nums1[right] == nums[j]) {
-                result[1] = j;
-                break;
-            }
-        }
-
-        int tmp = result[0];
-        result[0] = Math.min(result[0], result[1]);
-        result[1] = Math.max(tmp, result[1]);
-        return result;
+        return new int[] {-1, -1};
     }
 }
 ```

src/main/java/g2101_2200/s2120_execution_of_all_suffix_instructions_staying_in_a_grid/readme.md

@@ -0,0 +1,115 @@
+## 2120\. Execution of All Suffix Instructions Staying in a Grid
+
+Medium
+
+There is an `n x n` grid, with the top-left cell at `(0, 0)` and the bottom-right cell at `(n - 1, n - 1)`. You are given the integer `n` and an integer array `startPos` where <code>startPos = [start<sub>row</sub>, start<sub>col</sub>]</code> indicates that a robot is initially at cell <code>(start<sub>row</sub>, start<sub>col</sub>)</code>.
+
+You are also given a **0-indexed** string `s` of length `m` where `s[i]` is the <code>i<sup>th</sup></code> instruction for the robot: `'L'` (move left), `'R'` (move right), `'U'` (move up), and `'D'` (move down).
+
+The robot can begin executing from any <code>i<sup>th</sup></code> instruction in `s`. It executes the instructions one by one towards the end of `s` but it stops if either of these conditions is met:
+
+*   The next instruction will move the robot off the grid.
+*   There are no more instructions left to execute.
+
+Return _an array_ `answer` _of length_ `m` _where_ `answer[i]` _is **the number of instructions** the robot can execute if the robot **begins executing from** the_ <code>i<sup>th</sup></code> _instruction in_ `s`.
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2021/12/09/1.png)
+
+**Input:** n = 3, startPos = [0,1], s = "RRDDLU"
+
+**Output:** [1,5,4,3,1,0]
+
+**Explanation:** Starting from startPos and beginning execution from the i<sup>th</sup> instruction: 
+
+- 0<sup>th</sup>: "**R**RDDLU". Only one instruction "R" can be executed before it moves off the grid. 
+
+- 1<sup>st</sup>: "**RDDLU**". All five instructions can be executed while it stays in the grid and ends at (1, 1). 
+
+- 2<sup>nd</sup>: "**DDLU**". All four instructions can be executed while it stays in the grid and ends at (1, 0).
+
+- 3<sup>rd</sup>: "**DLU**". All three instructions can be executed while it stays in the grid and ends at (0, 0). 
+
+- 4<sup>th</sup>: "**L**U". Only one instruction "L" can be executed before it moves off the grid. 
+
+- 5<sup>th</sup>: "U". If moving up, it would move off the grid.
+
+**Example 2:**
+
+![](https://assets.leetcode.com/uploads/2021/12/09/2.png)
+
+**Input:** n = 2, startPos = [1,1], s = "LURD"
+
+**Output:** [4,1,0,0]
+
+**Explanation:** 
+
+- 0<sup>th</sup>: "**LURD**". 
+
+- 1<sup>st</sup>: "**U**RD". 
+
+- 2<sup>nd</sup>: "RD". 
+
+- 3<sup>rd</sup>: "D".
+
+**Example 3:**
+
+![](https://assets.leetcode.com/uploads/2021/12/09/3.png)
+
+**Input:** n = 1, startPos = [0,0], s = "LRUD"
+
+**Output:** [0,0,0,0]
+
+**Explanation:** No matter which instruction the robot begins execution from, it would move off the grid.
+
+**Constraints:**
+
+*   `m == s.length`
+*   `1 <= n, m <= 500`
+*   `startPos.length == 2`
+*   <code>0 <= start<sub>row</sub>, start<sub>col</sub> < n</code>
+*   `s` consists of `'L'`, `'R'`, `'U'`, and `'D'`.
+
+## Solution
+
+```java
+@SuppressWarnings("java:S135")
+public class Solution {
+    public int[] executeInstructions(int n, int[] startPos, String s) {
+        int[] answer = new int[s.length()];
+        for (int i = 0; i < s.length(); i++) {
+            int count = 0;
+            int currX = startPos[0];
+            int currY = startPos[1];
+            for (int j = i; j < s.length(); j++) {
+                char mv = s.charAt(j);
+                if (mv == 'R') {
+                    currY++;
+                    if (currY > n - 1) {
+                        break;
+                    }
+                } else if (mv == 'D') {
+                    currX++;
+                    if (currX > n - 1) {
+                        break;
+                    }
+                } else if (mv == 'L') {
+                    currY--;
+                    if (currY < 0) {
+                        break;
+                    }
+                } else if (mv == 'U') {
+                    currX--;
+                    if (currX < 0) {
+                        break;
+                    }
+                }
+                count++;
+            }
+            answer[i] = count;
+        }
+        return answer;
+    }
+}
+```

src/main/java/g2101_2200/s2121_intervals_between_identical_elements/readme.md

@@ -0,0 +1,100 @@
+## 2121\. Intervals Between Identical Elements
+
+Medium
+
+You are given a **0-indexed** array of `n` integers `arr`.
+
+The **interval** between two elements in `arr` is defined as the **absolute difference** between their indices. More formally, the **interval** between `arr[i]` and `arr[j]` is `|i - j|`.
+
+Return _an array_ `intervals` _of length_ `n` _where_ `intervals[i]` _is **the sum of intervals** between_ `arr[i]` _and each element in_ `arr` _with the same value as_ `arr[i]`_._
+
+**Note:** `|x|` is the absolute value of `x`.
+
+**Example 1:**
+
+**Input:** arr = [2,1,3,1,2,3,3]
+
+**Output:** [4,2,7,2,4,4,5]
+
+**Explanation:** 
+
+- Index 0: Another 2 is found at index 4. |0 - 4| = 4 
+
+- Index 1: Another 1 is found at index 3. |1 - 3| = 2 
+
+- Index 2: Two more 3s are found at indices 5 and 6. |2 - 5| + |2 - 6| = 7 
+
+- Index 3: Another 1 is found at index 1. |3 - 1| = 2 
+
+- Index 4: Another 2 is found at index 0. |4 - 0| = 4 
+
+- Index 5: Two more 3s are found at indices 2 and 6. |5 - 2| + |5 - 6| = 4 
+
+- Index 6: Two more 3s are found at indices 2 and 5. |6 - 2| + |6 - 5| = 5
+
+**Example 2:**
+
+**Input:** arr = [10,5,10,10]
+
+**Output:** [5,0,3,4]
+
+**Explanation:** 
+
+- Index 0: Two more 10s are found at indices 2 and 3. |0 - 2| + |0 - 3| = 5 
+
+- Index 1: There is only one 5 in the array, so its sum of intervals to identical elements is 0. 
+
+- Index 2: Two more 10s are found at indices 0 and 3. |2 - 0| + |2 - 3| = 3 
+
+- Index 3: Two more 10s are found at indices 0 and 2. |3 - 0| + |3 - 2| = 4
+
+**Constraints:**
+
+*   `n == arr.length`
+*   <code>1 <= n <= 10<sup>5</sup></code>
+*   <code>1 <= arr[i] <= 10<sup>5</sup></code>
+
+## Solution
+
+```java
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+public class Solution {
+    public long[] getDistances(int[] a) {
+        int n = a.length;
+        Map<Integer, List<Integer>> map = new HashMap<>();
+        for (int i = 0; i < n; i++) {
+            List<Integer> list = map.get(a[i]);
+            if (list == null) {
+                list = new ArrayList<>();
+            }
+            list.add(i);
+            map.put(a[i], list);
+        }
+        long[] ans = new long[n];
+        Arrays.fill(ans, 0);
+        for (List<Integer> list : map.values()) {
+            long sum = 0;
+            int first = list.get(0);
+            for (int i = 1; i < list.size(); i++) {
+                sum = sum + list.get(i) - first;
+            }
+            ans[first] = sum;
+            int prevElements = 0;
+            int nextElements = list.size() - 2;
+            for (int i = 1; i < list.size(); i++) {
+                int diff = list.get(i) - list.get(i - 1);
+                sum = sum + (long) diff * (prevElements - nextElements);
+                ans[list.get(i)] = sum;
+                prevElements++;
+                nextElements--;
+            }
+        }
+        return ans;
+    }
+}
+```