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? {