Updated java and kotlin tasks

Author: javadev

README.md

@@ -17,7 +17,7 @@ You can return the answer in any order.
 
 **Output:** [0,1]
 
-**Explanation:** Because nums[0] + nums[1] == 9, we return [0, 1]. 
+**Output:** Because nums[0] + nums[1] == 9, we return [0, 1]. 
 
 **Example 2:**
 
@@ -38,7 +38,7 @@ You can return the answer in any order.
 *   <code>-10<sup>9</sup> <= target <= 10<sup>9</sup></code>
 *   **Only one valid answer exists.**
 
-**Follow-up:** Can you come up with an algorithm that is less than <code>O(n<sup>2</sup>)</code> time complexity?
+**Follow-up:** Can you come up with an algorithm that is less than <code>O(n<sup>2</sup>) </code>time complexity?
 
 ## Solution
 

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

@@ -53,10 +53,14 @@ class Solution {
         var lpsCenter = 0
         var lpsRadius = 0
         for (i in newStr.indices) {
-            dp[i] = if (friendCenter + friendRadius > i) Math.min(
-                dp[friendCenter * 2 - i],
-                friendCenter + friendRadius - i
-            ) else 1
+            dp[i] = if (friendCenter + friendRadius > i) {
+                Math.min(
+                    dp[friendCenter * 2 - i],
+                    friendCenter + friendRadius - i,
+                )
+            } else {
+                1
+            }
             while (i + dp[i] < newStr.size && i - dp[i] >= 0 && newStr[i + dp[i]] == newStr[i - dp[i]]) {
                 dp[i]++
             }

src/main/kotlin/g0001_0100/s0005_longest_palindromic_substring/readme.md

@@ -89,7 +89,7 @@ class Solution {
                     i,
                     j - 2,
                     s,
-                    p
+                    p,
                 )
             }
         } else {

src/main/kotlin/g0001_0100/s0010_regular_expression_matching/readme.md

@@ -15,19 +15,19 @@ A mapping of digit to letters (just like on the telephone buttons) is given belo
 
 **Input:** digits = "23"
 
-**Output:** ["ad","ae","af","bd","be","bf","cd","ce","cf"] 
+**Output:** ["ad","ae","af","bd","be","bf","cd","ce","cf"]
 
 **Example 2:**
 
 **Input:** digits = ""
 
-**Output:** [] 
+**Output:** []
 
 **Example 3:**
 
 **Input:** digits = "2"
 
-**Output:** ["a","b","c"] 
+**Output:** ["a","b","c"]
 
 **Constraints:**
 
@@ -52,7 +52,7 @@ class Solution {
         nums: String,
         letters: Array<String>,
         curr: StringBuilder,
-        ans: MutableList<String>
+        ans: MutableList<String>,
     ) {
         if (curr.length == nums.length) {
             ans.add(curr.toString())

src/main/kotlin/g0001_0100/s0017_letter_combinations_of_a_phone_number/readme.md

@@ -13,19 +13,19 @@ Given the `head` of a linked list, remove the `nth` node from the end of the lis
 
 **Input:** head = [1,2,3,4,5], n = 2
 
-**Output:** [1,2,3,5] 
+**Output:** [1,2,3,5]
 
 **Example 2:**
 
 **Input:** head = [1], n = 1
 
-**Output:** [] 
+**Output:** []
 
 **Example 3:**
 
 **Input:** head = [1,2], n = 1
 
-**Output:** [1] 
+**Output:** [1]
 
 **Constraints:**
 

src/main/kotlin/g0001_0100/s0019_remove_nth_node_from_end_of_list/readme.md

@@ -16,31 +16,31 @@ An input string is valid if:
 
 **Input:** s = "()"
 
-**Output:** true 
+**Output:** true
 
 **Example 2:**
 
 **Input:** s = "()[]{}"
 
-**Output:** true 
+**Output:** true
 
 **Example 3:**
 
 **Input:** s = "(]"
 
-**Output:** false 
+**Output:** false
 
 **Example 4:**
 
 **Input:** s = "([)]"
 
-**Output:** false 
+**Output:** false
 
 **Example 5:**
 
 **Input:** s = "{[]}"
 
-**Output:** true 
+**Output:** true
 
 **Constraints:**
 

src/main/kotlin/g0001_0100/s0020_valid_parentheses/readme.md

@@ -13,19 +13,19 @@ Merge two sorted linked lists and return it as a **sorted** list. The list shoul
 
 **Input:** l1 = [1,2,4], l2 = [1,3,4]
 
-**Output:** [1,1,2,3,4,4] 
+**Output:** [1,1,2,3,4,4]
 
 **Example 2:**
 
 **Input:** l1 = [], l2 = []
 
-**Output:** [] 
+**Output:** []
 
 **Example 3:**
 
 **Input:** l1 = [], l2 = [0]
 
-**Output:** [0] 
+**Output:** [0]
 
 **Constraints:**
 

src/main/kotlin/g0001_0100/s0021_merge_two_sorted_lists/readme.md

@@ -11,13 +11,13 @@ Given `n` pairs of parentheses, write a function to _generate all combinations o
 
 **Input:** n = 3
 
-**Output:** ["((()))","(()())","(())()","()(())","()()()"] 
+**Output:** ["((()))","(()())","(())()","()(())","()()()"]
 
 **Example 2:**
 
 **Input:** n = 1
 
-**Output:** ["()"] 
+**Output:** ["()"]
 
 **Constraints:**
 

src/main/kotlin/g0001_0100/s0022_generate_parentheses/readme.md

@@ -15,19 +15,19 @@ _Merge all the linked-lists into one sorted linked-list and return it._
 
 **Output:** [1,1,2,3,4,4,5,6]
 
-**Explanation:** The linked-lists are: [ 1->4->5, 1->3->4, 2->6 ] merging them into one sorted list: 1->1->2->3->4->4->5->6 
+**Explanation:** The linked-lists are: [ 1->4->5, 1->3->4, 2->6 ] merging them into one sorted list: 1->1->2->3->4->4->5->6
 
 **Example 2:**
 
 **Input:** lists = []
 
-**Output:** [] 
+**Output:** []
 
 **Example 3:**
 
 **Input:** lists = \[\[]]
 
-**Output:** [] 
+**Output:** []
 
 **Constraints:**
 
@@ -56,7 +56,9 @@ class Solution {
     fun mergeKLists(lists: Array<ListNode>): ListNode? {
         return if (lists.isEmpty()) {
             null
-        } else mergeKLists(lists, 0, lists.size)
+        } else {
+            mergeKLists(lists, 0, lists.size)
+        }
     }
 
     private fun mergeKLists(lists: Array<ListNode>, leftIndex: Int, rightIndex: Int): ListNode? {

src/main/kotlin/g0001_0100/s0023_merge_k_sorted_lists/readme.md

@@ -13,19 +13,19 @@ Given a linked list, swap every two adjacent nodes and return its head. You must
 
 **Input:** head = [1,2,3,4]
 
-**Output:** [2,1,4,3] 
+**Output:** [2,1,4,3]
 
 **Example 2:**
 
 **Input:** head = []
 
-**Output:** [] 
+**Output:** []
 
 **Example 3:**
 
 **Input:** head = [1]
 
-**Output:** [1] 
+**Output:** [1]
 
 **Constraints:**
 

src/main/kotlin/g0001_0100/s0024_swap_nodes_in_pairs/readme.md

@@ -17,27 +17,27 @@ You may not alter the values in the list's nodes, only nodes themselves may be c
 
 **Input:** head = [1,2,3,4,5], k = 2
 
-**Output:** [2,1,4,3,5] 
+**Output:** [2,1,4,3,5]
 
 **Example 2:**
 
 ![](https://assets.leetcode.com/uploads/2020/10/03/reverse_ex2.jpg)
 
 **Input:** head = [1,2,3,4,5], k = 3
 
-**Output:** [3,2,1,4,5] 
+**Output:** [3,2,1,4,5]
 
 **Example 3:**
 
 **Input:** head = [1,2,3,4,5], k = 1
 
-**Output:** [1,2,3,4,5] 
+**Output:** [1,2,3,4,5]
 
 **Example 4:**
 
 **Input:** head = [1], k = 1
 
-**Output:** [1] 
+**Output:** [1]
 
 **Constraints:**
 

src/main/kotlin/g0001_0100/s0025_reverse_nodes_in_k_group/readme.md

@@ -5,35 +5,37 @@
 
 Medium
 
-Implement **next permutation**, which rearranges numbers into the lexicographically next greater permutation of numbers.
+A **permutation** of an array of integers is an arrangement of its members into a sequence or linear order.
 
-If such an arrangement is not possible, it must rearrange it as the lowest possible order (i.e., sorted in ascending order).
+*   For example, for `arr = [1,2,3]`, the following are all the permutations of `arr`: `[1,2,3], [1,3,2], [2, 1, 3], [2, 3, 1], [3,1,2], [3,2,1]`.
+
+The **next permutation** of an array of integers is the next lexicographically greater permutation of its integer. More formally, if all the permutations of the array are sorted in one container according to their lexicographical order, then the **next permutation** of that array is the permutation that follows it in the sorted container. If such arrangement is not possible, the array must be rearranged as the lowest possible order (i.e., sorted in ascending order).
+
+*   For example, the next permutation of `arr = [1,2,3]` is `[1,3,2]`.
+*   Similarly, the next permutation of `arr = [2,3,1]` is `[3,1,2]`.
+*   While the next permutation of `arr = [3,2,1]` is `[1,2,3]` because `[3,2,1]` does not have a lexicographical larger rearrangement.
+
+Given an array of integers `nums`, _find the next permutation of_ `nums`.
 
 The replacement must be **[in place](http://en.wikipedia.org/wiki/In-place_algorithm)** and use only constant extra memory.
 
 **Example 1:**
 
 **Input:** nums = [1,2,3]
 
-**Output:** [1,3,2] 
+**Output:** [1,3,2]
 
 **Example 2:**
 
 **Input:** nums = [3,2,1]
 
-**Output:** [1,2,3] 
+**Output:** [1,2,3]
 
 **Example 3:**
 
 **Input:** nums = [1,1,5]
 
-**Output:** [1,5,1] 
-
-**Example 4:**
-
-**Input:** nums = [1]
-
-**Output:** [1] 
+**Output:** [1,5,1]
 
 **Constraints:**
 

src/main/kotlin/g0001_0100/s0031_next_permutation/readme.md

@@ -13,21 +13,21 @@ Given a string containing just the characters `'('` and `')'`, find the length o
 
 **Output:** 2
 
-**Explanation:** The longest valid parentheses substring is "()". 
+**Explanation:** The longest valid parentheses substring is "()".
 
 **Example 2:**
 
 **Input:** s = ")()())"
 
 **Output:** 4
 
-**Explanation:** The longest valid parentheses substring is "()()". 
+**Explanation:** The longest valid parentheses substring is "()()".
 
 **Example 3:**
 
 **Input:** s = ""
 
-**Output:** 0 
+**Output:** 0
 
 **Constraints:**
 

src/main/kotlin/g0001_0100/s0032_longest_valid_parentheses/readme.md

@@ -17,19 +17,19 @@ You must write an algorithm with `O(log n)` runtime complexity.
 
 **Input:** nums = [4,5,6,7,0,1,2], target = 0
 
-**Output:** 4 
+**Output:** 4
 
 **Example 2:**
 
 **Input:** nums = [4,5,6,7,0,1,2], target = 3
 
-**Output:** -1 
+**Output:** -1
 
 **Example 3:**
 
 **Input:** nums = [1], target = 0
 
-**Output:** -1 
+**Output:** -1
 
 **Constraints:**
 

src/main/kotlin/g0001_0100/s0033_search_in_rotated_sorted_array/readme.md

@@ -15,19 +15,19 @@ You must write an algorithm with `O(log n)` runtime complexity.
 
 **Input:** nums = [5,7,7,8,8,10], target = 8
 
-**Output:** [3,4] 
+**Output:** [3,4]
 
 **Example 2:**
 
 **Input:** nums = [5,7,7,8,8,10], target = 6
 
-**Output:** [-1,-1] 
+**Output:** [-1,-1]
 
 **Example 3:**
 
 **Input:** nums = [], target = 0
 
-**Output:** [-1,-1] 
+**Output:** [-1,-1]
 
 **Constraints:**