Added tasks 2413-2545

Author: javadev

README.md

@@ -55,8 +55,6 @@ The overall run time complexity should be `O(log (m+n))`.
 ## Solution
 
 ```kotlin
-import kotlin.collections.ArrayList
-
 class Solution {
     fun findMedianSortedArrays(nums1: IntArray, nums2: IntArray): Double {
         val l: MutableList<Int> = ArrayList()

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

@@ -119,8 +119,8 @@ Since -91283472332 is less than the lower bound of the range [-2<sup>31</sup>, 2
 
 ```kotlin
 class Solution {
-    fun myAtoi(str: String?): Int {
-        if (str.isNullOrEmpty()) {
+    fun myAtoi(str: String): Int {
+        if (str.isEmpty()) {
             return 0
         }
         var i = 0

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

@@ -68,7 +68,7 @@ Given an integer, convert it to a roman numeral.
 
 ```kotlin
 class Solution {
-    fun intToRoman(num: Int): String? {
+    fun intToRoman(num: Int): String {
         var localNum = num
         val sb = StringBuilder()
         val m = 1000

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

@@ -35,8 +35,6 @@ Notice that the solution set must not contain duplicate triplets.
 ## Solution
 
 ```kotlin
-import kotlin.collections.ArrayList
-
 class Solution {
     fun threeSum(nums: IntArray): List<List<Int>> {
         nums.sort()

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

@@ -35,8 +35,8 @@ You may assume that each input would have exactly one solution.
 
 ```kotlin
 class Solution {
-    fun threeSumClosest(nums: IntArray?, target: Int): Int {
-        if (nums == null || nums.size < 3) {
+    fun threeSumClosest(nums: IntArray, target: Int): Int {
+        if (nums.size < 3) {
             return 0
         }
         if (nums.size == 3) {

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

@@ -51,6 +51,7 @@ You may not alter the values in the list's nodes, only nodes themselves may be c
 ## Solution
 
 ```kotlin
+9
 import com_github_leetcode.ListNode
 
 /*

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

@@ -54,7 +54,8 @@ class Solution {
             while (j >= i + 1 && nums[i] >= nums[j]) { j-- }
             nums[i] = nums[j].also { nums[j] = nums[i] }
         }
-        var l = i + 1; var r = nums.size - 1
+        var l = i + 1
+        var r = nums.size - 1
         while (l < r) {
             nums[l] = nums[r].also { nums[r] = nums[l] }
             l++

src/main/kotlin/g0001_0100/s0028_implement_strstr/readme.md renamed to src/main/kotlin/g0001_0100/s0028_find_the_index_of_the_first_occurrence_in_a_string/readme.md

@@ -46,18 +46,18 @@ The matching should cover the **entire** input string (not partial).
 
 ```kotlin
 class Solution {
-    fun isMatch(inputString: String, pattern: String): Boolean {
+    fun isMatch(s: String, p: String): Boolean {
         var i = 0
         var j = 0
         var starIdx = -1
         var lastMatch = -1
-        while (i < inputString.length) {
-            if (j < pattern.length &&
-                (inputString[i] == pattern[j] || pattern[j] == '?')
+        while (i < s.length) {
+            if (j < p.length &&
+                (s[i] == p[j] || p[j] == '?')
             ) {
                 i++
                 j++
-            } else if (j < pattern.length && pattern[j] == '*') {
+            } else if (j < p.length && p[j] == '*') {
                 starIdx = j
                 lastMatch = i
                 j++
@@ -76,10 +76,10 @@ class Solution {
             }
         }
         var isMatch = true
-        while (j < pattern.length && pattern[j] == '*') {
+        while (j < p.length && p[j] == '*') {
             j++
         }
-        if (i != inputString.length || j != pattern.length) {
+        if (i != s.length || j != p.length) {
             isMatch = false
         }
         return isMatch