Improved solutions.

Author: javadev

src/main/kotlin/g0001_0100/s0001_two_sum/Solution.kt

@@ -1,21 +1,41 @@
 package g0001_0100.s0001_two_sum
 
+import java.util.*
+
 class Solution {
-    fun twoSum(nums: IntArray, target: Int): IntArray {
-        val res = IntArray(2)
-        val map = HashMap<Int, Int>()
+    fun twoSum(nums: IntArray?, target: Int): IntArray {
+        if (nums == null || nums.size <= 1) {
+            return IntArray(0)
+        }
+        val result = IntArray(2)
+        var left = 0
+        var right = nums.size - 1
+        val nums1 = Arrays.copyOf(nums, nums.size)
+        Arrays.sort(nums1)
+        while (left < right) {
+            if (nums1[left] + nums1[right] == target) {
+                break
+            } else if (nums1[left] + nums1[right] > target) {
+                right--
+            } else if (nums1[left] + nums1[right] < target) {
+                left++
+            }
+        }
         for (i in nums.indices) {
-            val value = target - nums[i]
-            if (!map.containsKey(value)) {
-                map[nums[i]] = i
-                continue
+            if (nums1[left] == nums[i]) {
+                result[0] = i
+                break
             }
-            if (map[value] != i) {
-                res[1] = i
-                res[0] = map[value]!!
+        }
+        for (j in nums.indices.reversed()) {
+            if (nums1[right] == nums[j]) {
+                result[1] = j
                 break
             }
         }
-        return res
+        val tmp = result[0]
+        result[0] = Math.min(result[0], result[1])
+        result[1] = Math.max(tmp, result[1])
+        return result
     }
 }

src/main/kotlin/g0001_0100/s0002_add_two_numbers/Solution.kt

@@ -1,36 +1,27 @@
 package g0001_0100.s0002_add_two_numbers
 
 /*
- * Example:
- * var li = ListNode(5)
- * var v = li.`val`
  * Definition for singly-linked list.
- * class ListNode(var `val`: Int) {
- *     var next: ListNode? = null
+ * public class ListNode {
+ *     int val;
+ *     ListNode next;
+ *     ListNode(int x) { val = x; }
  * }
  */
 class Solution {
     fun addTwoNumbers(l1: ListNode?, l2: ListNode?): ListNode? {
         val dummyHead = ListNode(0)
         var p = l1
         var q = l2
-        var curr = dummyHead
+        var curr: ListNode? = dummyHead
         var carry = 0
         while (p != null || q != null) {
-            val x = if ((p != null)) {
-                p.`val`
-            } else {
-                0
-            }
-            val y = if ((q != null)) {
-                q.`val`
-            } else {
-                0
-            }
+            val x = p?.`val` ?: 0
+            val y = q?.`val` ?: 0
             val sum = carry + x + y
             carry = sum / 10
-            curr.next = ListNode(sum % 10)
-            curr = curr.next!!
+            curr!!.next = ListNode(sum % 10)
+            curr = curr.next
             if (p != null) {
                 p = p.next
             }
@@ -39,7 +30,7 @@ class Solution {
             }
         }
         if (carry > 0) {
-            curr.next = ListNode(carry)
+            curr!!.next = ListNode(carry)
         }
         return dummyHead.next
     }

src/main/kotlin/g0001_0100/s0003_longest_substring_without_repeating_characters/Solution.kt

@@ -2,21 +2,28 @@ package g0001_0100.s0003_longest_substring_without_repeating_characters
 
 class Solution {
     fun lengthOfLongestSubstring(s: String): Int {
-        var longest = 0
-        var f = 0
-        val charArray = IntArray(128)
+        val lastIndices = IntArray(256)
+        for (i in 0..255) {
+            lastIndices[i] = -1
+        }
+        var maxLen = 0
+        var curLen = 0
+        var start = 0
         for (i in 0 until s.length) {
-            if (charArray[s[i].code] == 0) {
-                longest = if (longest < (i + 1 - f)) (i + 1 - f) else longest
-                charArray[s[i].code] += 1
+            val cur = s[i]
+            if (lastIndices[cur.code] < start) {
+                lastIndices[cur.code] = i
+                curLen++
             } else {
-                while (s[f] != s[i]) {
-                    charArray[s[f].code] = 0
-                    f++
-                }
-                f++
+                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/Solution.kt

@@ -1,23 +1,25 @@
 package g0001_0100.s0004_median_of_two_sorted_arrays
 
+import kotlin.collections.ArrayList
+
 class Solution {
     fun findMedianSortedArrays(nums1: IntArray, nums2: IntArray): Double {
-        val array = IntArray(nums1.size + nums2.size)
-        var p = 0
-        var q = 0
-        for (i in array.indices) {
-            if ((p < nums1.size && q < nums2.size && nums1[p] <= nums2[q]) || q == nums2.size) {
-                array[i] = nums1[p]
-                p++
-            } else if ((p < nums1.size && q < nums2.size && nums1[p] > nums2[q]) || p == nums1.size) {
-                array[i] = nums2[q]
-                q++
-            }
+        val l: MutableList<Int> = ArrayList()
+        val f: Double
+        for (j in nums1) {
+            l.add(j)
+        }
+        for (i in nums2) {
+            l.add(i)
         }
-        return if (array.size % 2 == 0) {
-            (array[array.size / 2] + array[(array.size / 2) - 1]).toDouble() / 2
+        l.sort()
+        val k = l.size
+        f = if (k % 2 == 0) {
+            (l[k / 2 - 1] + l[k / 2]).toDouble() / 2
         } else {
-            array[array.size / 2].toDouble()
+            l[(k + 1) / 2 - 1].toDouble()
         }
+        return f
     }
 }
+

src/main/kotlin/g0001_0100/s0005_longest_palindromic_substring/Solution.kt

@@ -2,30 +2,34 @@ package g0001_0100.s0005_longest_palindromic_substring
 
 class Solution {
     fun longestPalindrome(s: String): String {
-        if (s.isEmpty()) {
-            return s
+        val newStr = CharArray(s.length * 2 + 1)
+        newStr[0] = '#'
+        for (i in s.indices) {
+            newStr[2 * i + 1] = s[i]
+            newStr[2 * i + 2] = '#'
         }
-        val dp = Array(s.length) { BooleanArray(s.length) }
-        var longestPalindromeStart = 0
-        var longestPalindromeLength = 1
-        for (i in s.length - 1 downTo 0) {
-            // single character is a palindrome so making it true
-            dp[i][i] = true
-            for (j in i + 1 until s.length) {
-                // checking for two edge cases 1.if characters are equal check for diagonal lower
-                // left one if true make it true
-                // 2. or if both equal and its the first elelment in the loop make it as true
-                if ((s[i] == s[j] && dp[i + 1][j - 1]) || (i + 1 == j && s[i] == s[j])) {
-                    dp[i][j] = true
-                    // update the length if greater than previous
-                    if (j - i + 1 > longestPalindromeLength) {
-                        longestPalindromeLength = j - i + 1
-                        longestPalindromeStart = i
-                    }
-                }
+        val dp = IntArray(newStr.size)
+        var friendCenter = 0
+        var friendRadius = 0
+        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
+            while (i + dp[i] < newStr.size && i - dp[i] >= 0 && newStr[i + dp[i]] == newStr[i - dp[i]]) {
+                dp[i]++
+            }
+            if (friendCenter + friendRadius < i + dp[i]) {
+                friendCenter = i
+                friendRadius = dp[i]
+            }
+            if (lpsRadius < dp[i]) {
+                lpsCenter = i
+                lpsRadius = dp[i]
             }
         }
-        // return the substring using starting and ending index
-        return s.substring(longestPalindromeStart, longestPalindromeStart + longestPalindromeLength)
+        return s.substring((lpsCenter - lpsRadius + 1) / 2, (lpsCenter + lpsRadius - 1) / 2)
     }
-}
+}

src/main/kotlin/g0001_0100/s0006_zigzag_conversion/Solution.kt

@@ -2,20 +2,31 @@ package g0001_0100.s0006_zigzag_conversion
 
 class Solution {
     fun convert(s: String, numRows: Int): String {
-        if (numRows == 1) return s
-        val ret = StringBuilder()
-        val n = s.length
-        val cycleLen = 2 * numRows - 2
+        val sLen = s.length
+        if (numRows == 1) {
+            return s
+        }
+        val maxDist = numRows * 2 - 2
+        val buf = StringBuilder()
         for (i in 0 until numRows) {
-            var j = 0
-            while (j + i < n) {
-                ret.append(s[j + i])
-                if (i != 0 && i != numRows - 1 && j + cycleLen - i < n) {
-                    ret.append(s[j + cycleLen - i])
+            var index = i
+            if (i == 0 || i == numRows - 1) {
+                while (index < sLen) {
+                    buf.append(s[index])
+                    index += maxDist
+                }
+            } else {
+                while (index < sLen) {
+                    buf.append(s[index])
+                    index += maxDist - i * 2
+                    if (index >= sLen) {
+                        break
+                    }
+                    buf.append(s[index])
+                    index += i * 2
                 }
-                j += cycleLen
             }
         }
-        return ret.toString()
+        return buf.toString()
     }
-}
+}

src/main/kotlin/g0001_0100/s0008_string_to_integer_atoi/Solution.kt

@@ -1,27 +1,41 @@
 package g0001_0100.s0008_string_to_integer_atoi
 
 class Solution {
-    fun myAtoi(str: String): Int {
-    if (str.trim { it <= ' ' }.isEmpty())
-    return 0
-    var localStr = str.trim { it <= ' ' }
+    fun myAtoi(str: String?): Int {
+        if (str == null || str.isEmpty()) {
+            return 0
+        }
         var i = 0
-    var ans = 0
-    var sign = 1
-    val len = localStr.length
-    if (localStr.get(i) == '-' || localStr.get(i) == '+')
-    sign = if (localStr.get(i++) == '+') 1 else -1
-    while (i < len)
-    {
-      val tmp = localStr.get(i) - '0'
-      if (tmp < 0 || tmp > 9)
-      break
-      if ((ans > Integer.MAX_VALUE / 10 || (ans == Integer.MAX_VALUE / 10 && Integer.MAX_VALUE % 10 < tmp)))
-      return if (sign == 1) Integer.MAX_VALUE else Integer.MIN_VALUE
-      else
-      ans = ans * 10 + tmp
-      ++i
+        var negativeSign = false
+        val input = str.toCharArray()
+        while (i < input.size && input[i] == ' ') {
+            i++
+        }
+        if (i == input.size) {
+            return 0
+        } else if (input[i] == '+') {
+            i++
+        } else if (input[i] == '-') {
+            i++
+            negativeSign = true
+        }
+        var num = 0
+        while (i < input.size && input[i] <= '9' && input[i] >= '0') {
+            // current char
+            var tem = input[i] - '0'
+            tem = if (negativeSign) -tem else tem
+            // avoid invalid number like 038
+            if (num == 0 && tem == '0'.code) {
+                i++
+            } else if (num == Int.MIN_VALUE / 10 && tem <= -8 || num < Int.MIN_VALUE / 10) {
+                return Int.MIN_VALUE
+            } else if (num == Int.MAX_VALUE / 10 && tem >= 7 || num > Int.MAX_VALUE / 10) {
+                return Int.MAX_VALUE
+            } else {
+                num = num * 10 + tem
+                i++
+            }
+        }
+        return num
     }
-    return sign * ans
-    }
-}
+}

src/test/kotlin/g0001_0100/s0005_longest_palindromic_substring/SolutionTest.kt

@@ -7,6 +7,6 @@ import org.junit.Test
 class SolutionTest {
     @Test
     fun longestPalindrome() {
-        assertThat(Solution().longestPalindrome("babad"), equalTo("aba"))
+        assertThat(Solution().longestPalindrome("babad"), equalTo("bab"))
     }
 }