Improved tasks 1, 3, 4

Author: javadev

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

@@ -45,7 +45,7 @@ You can return the answer in any order.
 ```kotlin
 class Solution {
     fun twoSum(numbers: IntArray, target: Int): IntArray {
-        val indexMap: MutableMap<Int, Int> = HashMap()
+        val indexMap = HashMap<Int, Int>()
         for (i in numbers.indices) {
             val requiredNum = target - numbers[i]
             if (indexMap.containsKey(requiredNum)) {

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

@@ -47,27 +47,26 @@ Given a string `s`, find the length of the **longest substring** without repeati
 ```kotlin
 class Solution {
     fun lengthOfLongestSubstring(s: String): Int {
-        var i = 0
-        var j = 0
-        var longest = 0
-        // 1. if string empty, return 0
-        if (s.isEmpty()) {
-            return 0
-        }
-        while (j < s.length) {
-            // 2. if the char at index j already seen, update the longest if needs
-            if (i != j && s.substring(i, j).indexOf(s[j]) > -1) {
-                longest = Math.max(j - i, longest)
-                i++
+        val lastIndices = IntArray(256) { -1 }
+        var maxLen = 0
+        var curLen = 0
+        var start = 0
+        for (i in s.indices) {
+            val cur = s[i]
+            if (lastIndices[cur.code] < start) {
+                lastIndices[cur.code] = i
+                curLen++
             } else {
-                // 3. j out of bound already, update longest
-                if (++j == s.length) {
-                    longest = Math.max(s.length - i, longest)
-                    break
-                }
+                val lastIndex = lastIndices[cur.code]
+                start = lastIndex + 1
+                curLen = i - start + 1
+                lastIndices[cur.code] = i
+            }
+            if (curLen > maxLen) {
+                maxLen = curLen
             }
         }
-        return longest
+        return maxLen
     }
 }
 ```

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

@@ -55,24 +55,38 @@ The overall run time complexity should be `O(log (m+n))`.
 ## Solution
 
 ```kotlin
+import kotlin.math.max
+import kotlin.math.min
+
 class Solution {
     fun findMedianSortedArrays(nums1: IntArray, nums2: IntArray): Double {
-        val l: MutableList<Int> = ArrayList()
-        val f: Double
-        for (j in nums1) {
-            l.add(j)
-        }
-        for (i in nums2) {
-            l.add(i)
+        if (nums2.size < nums1.size) {
+            return findMedianSortedArrays(nums2, nums1)
         }
-        l.sort()
-        val k = l.size
-        f = if (k % 2 == 0) {
-            (l[k / 2 - 1] + l[k / 2]).toDouble() / 2
-        } else {
-            l[(k + 1) / 2 - 1].toDouble()
+        val n1 = nums1.size
+        val n2 = nums2.size
+        var low = 0
+        var high = n1
+        while (low <= high) {
+            val cut1 = (low + high) / 2
+            val cut2 = ((n1 + n2 + 1) / 2) - cut1
+            val l1 = if (cut1 == 0) Int.MIN_VALUE else nums1[cut1 - 1]
+            val l2 = if (cut2 == 0) Int.MIN_VALUE else nums2[cut2 - 1]
+            val r1 = if (cut1 == n1) Int.MAX_VALUE else nums1[cut1]
+            val r2 = if (cut2 == n2) Int.MAX_VALUE else nums2[cut2]
+            if (l1 <= r2 && l2 <= r1) {
+                return if ((n1 + n2) % 2 == 0) {
+                    (max(l1, l2).toDouble() + min(r1, r2).toDouble()) / 2.0
+                } else {
+                    max(l1, l2).toDouble()
+                }
+            } else if (l1 > r2) {
+                high = cut1 - 1
+            } else {
+                low = cut1 + 1
+            }
         }
-        return f
+        return 0.0
     }
 }
 ```