Improved tasks 1, 3, 4, 3136, 3612

Author: javadev

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/s0001_two_sum/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/s0003_longest_substring_without_repeating_characters/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
     }
 }
 ```

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

@@ -64,30 +64,21 @@ class Solution {
         if (word.length < 3) {
             return false
         }
-        if (word.contains("@") || word.contains("#") || word.contains("$")) {
-            return false
-        }
-        val vowels = charArrayOf('a', 'e', 'i', 'o', 'u', 'A', 'E', 'I', 'O', 'U')
-        val consonants = charArrayOf(
-            'b', 'c', 'd', 'f', 'g', 'h', 'j', 'k', 'l', 'm', 'n', 'p', 'q', 'r', 's', 't', 'v',
-            'w', 'x', 'y', 'z', 'B', 'C', 'D', 'F', 'G', 'H', 'J', 'K', 'L', 'M', 'N', 'P', 'Q',
-            'R', 'S', 'T', 'V', 'W', 'X', 'Y', 'Z',
-        )
-        var flag1 = false
-        var flag2 = false
-        for (c in vowels) {
-            if (word.indexOf(c) != -1) {
-                flag1 = true
-                break
-            }
-        }
-        for (c in consonants) {
-            if (word.indexOf(c) != -1) {
-                flag2 = true
-                break
+        var hasVowel = false
+        var hasConsonant = false
+        for (c in word.toCharArray()) {
+            if (Character.isLetter(c)) {
+                val ch = c.lowercaseChar()
+                if (ch == 'a' || ch == 'e' || ch == 'i' || ch == 'o' || ch == 'u') {
+                    hasVowel = true
+                } else {
+                    hasConsonant = true
+                }
+            } else if (!Character.isDigit(c)) {
+                return false
             }
         }
-        return flag1 && flag2
+        return hasVowel && hasConsonant
     }
 }
 ```

src/main/kotlin/g3101_3200/s3136_valid_word/readme.md

@@ -24,53 +24,13 @@ Return the final string `result` after processing all characters in `s`.
 
 **Explanation:**
 
-`i`
-
-`s[i]`
-
-Operation
-
-Current `result`
-
-0
-
-`'a'`
-
-Append `'a'`
-
-`"a"`
-
-1
-
-`'#'`
-
-Duplicate `result`
-
-`"aa"`
-
-2
-
-`'b'`
-
-Append `'b'`
-
-`"aab"`
-
-3
-
-`'%'`
-
-Reverse `result`
-
-`"baa"`
-
-4
-
-`'*'`
-
-Remove the last character
-
-`"ba"`
+| i | s[i]  | Operation                  | Current `result` |
+|---|-------|----------------------------|------------------|
+| 0 | `'a'` | Append `'a'`               | `"a"`            |
+| 1 | `'#'` | Duplicate `result`         | `"aa"`           |
+| 2 | `'b'` | Append `'b'`               | `"aab"`          |
+| 3 | `'%'` | Reverse `result`           | `"baa"`          |
+| 4 | `'*'` | Remove the last character  | `"ba"`           |
 
 Thus, the final `result` is `"ba"`.
 
@@ -82,37 +42,11 @@ Thus, the final `result` is `"ba"`.
 
 **Explanation:**
 
-`i`
-
-`s[i]`
-
-Operation
-
-Current `result`
-
-0
-
-`'z'`
-
-Append `'z'`
-
-`"z"`
-
-1
-
-`'*'`
-
-Remove the last character
-
-`""`
-
-2
-
-`'#'`
-
-Duplicate the string
-
-`""`
+| i | s[i]  | Operation                 | Current `result` |
+|---|-------|---------------------------|------------------|
+| 0 | `'z'` | Append `'z'`              | `"z"`            |
+| 1 | `'*'` | Remove the last character | `""`             |
+| 2 | `'#'` | Duplicate the string      | `""`             |
 
 Thus, the final `result` is `""`.