Fixed warnings, formatted codes.

Author: javadev

src/main/kotlin/s0001_two_sum/Solution.kt

@@ -10,7 +10,7 @@ class Solution {
                 map[nums[i]] = i
                 continue
             }
-            if (map[value] !== i) {
+            if (map[value] != i) {
                 res[1] = i
                 res[0] = map[value]!!
                 break

src/main/kotlin/s0002_add_two_numbers/Solution.kt

@@ -17,14 +17,26 @@ class Solution {
         var curr = 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 = if ((p != null)) {
+                p.`val`
+            } else {
+                0
+            }
+            val y = if ((q != null)) {
+                q.`val`
+            } else {
+                0
+            }
             val sum = carry + x + y
             carry = sum / 10
             curr.next = ListNode(sum % 10)
             curr = curr.next!!
-            if (p != null) p = p.next
-            if (q != null) q = q.next
+            if (p != null) {
+                p = p.next
+            }
+            if (q != null) {
+                q = q.next
+            }
         }
         if (carry > 0) {
             curr.next = ListNode(carry)

src/main/kotlin/s0003_longest_substring_without_repeating_characters/Solution.kt

@@ -6,12 +6,12 @@ class Solution {
         var f = 0
         val charArray = IntArray(128)
         for (i in 0 until s.length) {
-            if (charArray[s[i].toInt()] == 0) {
+            if (charArray[s[i].code] == 0) {
                 longest = if (longest < (i + 1 - f)) (i + 1 - f) else longest
-                charArray[s[i].toInt()] += 1
+                charArray[s[i].code] += 1
             } else {
                 while (s[f] != s[i]) {
-                    charArray[s[f].toInt()] = 0
+                    charArray[s[f].code] = 0
                     f++
                 }
                 f++

src/main/kotlin/s0004_median_of_two_sorted_arrays/Solution.kt

@@ -14,10 +14,10 @@ class Solution {
                 q++
             }
         }
-        if (array.size % 2 == 0) {
-            return (array[array.size / 2] + array[(array.size / 2) - 1]).toDouble() / 2
+        return if (array.size % 2 == 0) {
+            (array[array.size / 2] + array[(array.size / 2) - 1]).toDouble() / 2
         } else {
-            return array[array.size / 2].toDouble()
+            array[array.size / 2].toDouble()
         }
     }
 }

src/main/kotlin/s0005_longest_palindromic_substring/Solution.kt

@@ -5,14 +5,15 @@ class Solution {
         if (s.isEmpty()) {
             return s
         }
-        val dp = Array(s.length, { BooleanArray(s.length) })
+        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
+                // 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

src/main/kotlin/s0006_zigzag_conversion/Solution.kt

@@ -10,8 +10,9 @@ class Solution {
             var j = 0
             while (j + i < n) {
                 ret.append(s[j + i])
-                if (i != 0 && i != numRows - 1 && j + cycleLen - i < n)
+                if (i != 0 && i != numRows - 1 && j + cycleLen - i < n) {
                     ret.append(s[j + cycleLen - i])
+                }
                 j += cycleLen
             }
         }

src/main/kotlin/s0007_reverse_integer/Solution.kt

@@ -2,14 +2,15 @@ package s0007_reverse_integer
 
 class Solution {
     fun reverse(x: Int): Int {
-    var rev:Long = 0
-    var localX = x
-    while (localX != 0)
-    {
-      rev = (rev * 10) + (localX % 10)
-      localX /= 10
-    }
-    if (rev > Integer.MAX_VALUE || rev < Integer.MIN_VALUE) return 0
-    return rev.toInt()
+        var rev: Long = 0
+        var localX = x
+        while (localX != 0) {
+            rev = (rev * 10) + (localX % 10)
+            localX /= 10
+        }
+        if (rev > Integer.MAX_VALUE || rev < Integer.MIN_VALUE) {
+            return 0
+        }
+        return rev.toInt()
     }
 }

src/main/kotlin/s0008_string_to_integer_atoi/Solution.kt

@@ -2,10 +2,10 @@ package s0008_string_to_integer_atoi
 
 class Solution {
     fun myAtoi(str: String): Int {
-    if (str.trim({ it <= ' ' }).isEmpty())
+    if (str.trim { it <= ' ' }.isEmpty())
     return 0
-    var localStr = str.trim({ it <= ' ' })
-    var i = 0
+    var localStr = str.trim { it <= ' ' }
+        var i = 0
     var ans = 0
     var sign = 1
     val len = localStr.length

src/main/kotlin/s0010_regular_expression_matching/Solution.kt

@@ -1,25 +1,19 @@
 package s0010_regular_expression_matching
 
 class Solution {
-    fun isMatch(text:String, pattern:String): Boolean {
-    val dp = Array<BooleanArray>(text.length + 1, {BooleanArray(pattern.length + 1)})
-    dp[text.length][pattern.length] = true
-    for (i in text.length downTo 0)
-    {
-      for (j in pattern.length - 1 downTo 0)
-      {
-        val first_match = ((i < text.length && ((pattern.get(j) == text.get(i) || pattern.get(j) == '.'))))
-        if (j + 1 < pattern.length && pattern.get(j + 1) == '*')
-        {
-          dp[i][j] = dp[i][j + 2] || first_match && dp[i + 1][j]
+    fun isMatch(text: String, pattern: String): Boolean {
+        val dp = Array(text.length + 1) { BooleanArray(pattern.length + 1) }
+        dp[text.length][pattern.length] = true
+        for (i in text.length downTo 0) {
+            for (j in pattern.length - 1 downTo 0) {
+                val firstMatch = ((i < text.length && ((pattern[j] == text[i] || pattern[j] == '.'))))
+                if (j + 1 < pattern.length && pattern[j + 1] == '*') {
+                    dp[i][j] = dp[i][j + 2] || firstMatch && dp[i + 1][j]
+                } else {
+                    dp[i][j] = firstMatch && dp[i + 1][j + 1]
+                }
+            }
         }
-        else
-        {
-          dp[i][j] = first_match && dp[i + 1][j + 1]
-        }
-      }
-    }
-    return dp[0][0]
-
+        return dp[0][0]
     }
 }

src/main/kotlin/s0011_container_with_most_water/Solution.kt

@@ -1,40 +1,33 @@
 package s0011_container_with_most_water
 
 class Solution {
-  fun maxArea(height:IntArray):Int {
-    var max = 0
-    if (height != null && height.size != 0)
-    {
-      var left = 0
-      var right = height.size - 1
-      while (left < right)
-      {
-        // next two if conditions are to make sure there are two non-zero containers to
-        // hold water. If not move next to find one
-        if (height[left] == 0)
-        {
-          left++
-          continue
+    fun maxArea(height: IntArray): Int {
+        var max = 0
+        if (height.isNotEmpty()) {
+            var left = 0
+            var right = height.size - 1
+            while (left < right) {
+                // next two if conditions are to make sure there are two non-zero containers to
+                // hold water. If not move next to find one
+                if (height[left] == 0) {
+                    left++
+                    continue
+                }
+                if (height[right] == 0) {
+                    right--
+                    continue
+                }
+                // if control came here that means left and right containers are non zero and
+                // can hold water. Get the count of containers and multiple by lower container
+                if (height[left] < height[right]) {
+                    max = Math.max(max, (right - left) * height[left])
+                    left++
+                } else {
+                    max = Math.max(max, (right - left) * height[right])
+                    right--
+                }
+            }
         }
-        if (height[right] == 0)
-        {
-          right--
-          continue
-        }
-        // if control came here that means left and right containers are non zero and
-        // can hold water. Get the count of containers and multiple by lower container
-        if (height[left] < height[right])
-        {
-          max = Math.max(max, (right - left) * height[left])
-          left++
-        }
-        else
-        {
-          max = Math.max(max, (right - left) * height[right])
-          right--
-        }
-      }
+        return max
     }
-    return max
-  }
 }