feat: add kotlin solutions to lc problems (#3492)

Author: Zuoqiu-Yingyi

solution/0000-0099/0001.Two Sum/README.md

@@ -318,6 +318,25 @@ proc twoSum(nums: seq[int], target: int): seq[int] =
   return @[]
 ```
 
+#### Kotlin
+
+```kotlin
+class Solution {
+    fun twoSum(nums: IntArray, target: Int): IntArray {
+        val m = mutableMapOf<Int, Int>()
+        nums.forEachIndexed { i, x ->
+            val y = target - x
+            val j = m.get(y)
+            if (j != null) {
+                return intArrayOf(j, i)
+            }
+            m[x] = i
+        }
+        return intArrayOf()
+    }
+}
+```
+
 <!-- tabs:end -->
 
 <!-- solution:end -->

solution/0000-0099/0001.Two Sum/README_EN.md

@@ -315,6 +315,25 @@ proc twoSum(nums: seq[int], target: int): seq[int] =
   return @[]
 ```
 
+#### Kotlin
+
+```kotlin
+class Solution {
+    fun twoSum(nums: IntArray, target: Int): IntArray {
+        val m = mutableMapOf<Int, Int>()
+        nums.forEachIndexed { i, x ->
+            val y = target - x
+            val j = m.get(y)
+            if (j != null) {
+                return intArrayOf(j, i)
+            }
+            m[x] = i
+        }
+        return intArrayOf()
+    }
+}
+```
+
 <!-- tabs:end -->
 
 <!-- solution:end -->

solution/0000-0099/0001.Two Sum/Solution.kt

@@ -0,0 +1,14 @@
+class Solution {
+    fun twoSum(nums: IntArray, target: Int): IntArray {
+        val m = mutableMapOf<Int, Int>()
+        nums.forEachIndexed { i, x ->
+            val y = target - x
+            val j = m.get(y)
+            if (j != null) {
+                return intArrayOf(j, i)
+            }
+            m[x] = i
+        }
+        return intArrayOf()
+    }
+}

solution/0000-0099/0003.Longest Substring Without Repeating Characters/README.md

@@ -26,7 +26,7 @@ tags:
 
 <pre>
 <strong>输入: </strong>s = "abcabcbb"
-<strong>输出: </strong>3 
+<strong>输出: </strong>3
 <strong>解释:</strong> 因为无重复字符的最长子串是 <code>"abc"</code>，所以其长度为 3。
 </pre>
 
@@ -309,6 +309,27 @@ proc lengthOfLongestSubstring(s: string): int =
   result = res # result has the default return value
 ```
 
+#### Kotlin
+
+```kotlin
+class Solution {
+    fun lengthOfLongestSubstring(s: String): Int {
+        var char_set = BooleanArray(128)
+        var left = 0
+        var ans = 0
+        s.forEachIndexed { right, c ->
+            while (char_set[c.code]) {
+                char_set[s[left].code] = false
+                left++
+            }
+            char_set[c.code] = true
+            ans = Math.max(ans, right - left + 1)
+        }
+        return ans
+    }
+}
+```
+
 <!-- tabs:end -->
 
 <!-- solution:end -->

solution/0000-0099/0003.Longest Substring Without Repeating Characters/README_EN.md

@@ -307,6 +307,27 @@ proc lengthOfLongestSubstring(s: string): int =
   result = res # result has the default return value
 ```
 
+#### Kotlin
+
+```kotlin
+class Solution {
+    fun lengthOfLongestSubstring(s: String): Int {
+        var char_set = BooleanArray(128)
+        var left = 0
+        var ans = 0
+        s.forEachIndexed { right, c ->
+            while (char_set[c.code]) {
+                char_set[s[left].code] = false
+                left++
+            }
+            char_set[c.code] = true
+            ans = Math.max(ans, right - left + 1)
+        }
+        return ans
+    }
+}
+```
+
 <!-- tabs:end -->
 
 <!-- solution:end -->

solution/0000-0099/0003.Longest Substring Without Repeating Characters/Solution.kt

@@ -0,0 +1,16 @@
+class Solution {
+    fun lengthOfLongestSubstring(s: String): Int {
+        var char_set = BooleanArray(128)
+        var left = 0
+        var ans = 0
+        s.forEachIndexed { right, c ->
+            while (char_set[c.code]) {
+                char_set[s[left].code] = false
+                left++
+            }
+            char_set[c.code] = true
+            ans = Math.max(ans, right - left + 1)
+        }
+        return ans
+    }
+}

solution/0000-0099/0034.Find First and Last Position of Element in Sorted Array/README.md

@@ -289,6 +289,32 @@ class Solution {
 }
 ```
 
+#### Kotlin
+
+```kotlin
+class Solution {
+    fun searchRange(nums: IntArray, target: Int): IntArray {
+        val left = this.search(nums, target)
+        val right = this.search(nums, target + 1)
+        return if (left == right) intArrayOf(-1, -1) else intArrayOf(left, right - 1)
+    }
+
+    private fun search(nums: IntArray, target: Int): Int {
+        var left = 0
+        var right = nums.size
+        while (left < right) {
+            val middle = (left + right) / 2
+            if (nums[middle] < target) {
+                left = middle + 1
+            } else {
+                right = middle
+            }
+        }
+        return left
+    }
+}
+```
+
 <!-- tabs:end -->
 
 <!-- solution:end -->

solution/0000-0099/0034.Find First and Last Position of Element in Sorted Array/README_EN.md

@@ -279,6 +279,32 @@ class Solution {
 }
 ```
 
+#### Kotlin
+
+```kotlin
+class Solution {
+    fun searchRange(nums: IntArray, target: Int): IntArray {
+        val left = this.search(nums, target)
+        val right = this.search(nums, target + 1)
+        return if (left == right) intArrayOf(-1, -1) else intArrayOf(left, right - 1)
+    }
+
+    private fun search(nums: IntArray, target: Int): Int {
+        var left = 0
+        var right = nums.size
+        while (left < right) {
+            val middle = (left + right) / 2
+            if (nums[middle] < target) {
+                left = middle + 1
+            } else {
+                right = middle
+            }
+        }
+        return left
+    }
+}
+```
+
 <!-- tabs:end -->
 
 <!-- solution:end -->

solution/0000-0099/0034.Find First and Last Position of Element in Sorted Array/Solution.kt

@@ -0,0 +1,21 @@
+class Solution {
+    fun searchRange(nums: IntArray, target: Int): IntArray {
+        val left = this.search(nums, target)
+        val right = this.search(nums, target + 1)
+        return if (left == right) intArrayOf(-1, -1) else intArrayOf(left, right - 1)
+    }
+
+    private fun search(nums: IntArray, target: Int): Int {
+        var left = 0
+        var right = nums.size
+        while (left < right) {
+            val middle = (left + right) / 2
+            if (nums[middle] < target) {
+                left = middle + 1
+            } else {
+                right = middle
+            }
+        }
+        return left
+    }
+}

solution/0000-0099/0043.Multiply Strings/README.md

@@ -325,6 +325,88 @@ class Solution {
 }
 ```
 
+#### Kotlin
+
+```kotlin
+class Solution {
+    fun multiply(num1: String, num2: String): String {
+        if (num1 == "0" || num2 == "0") return "0"
+
+        val chars_1 = num1.toCharArray().reversedArray()
+        val chars_2 = num2.toCharArray().reversedArray()
+
+        val result = mutableListOf<Int>()
+
+        chars_1.forEachIndexed { i, c1 ->
+            val multiplier_1 = c1 - '0'
+            var over = 0
+            var index = 0
+
+            fun sum(product: Int = 0): Unit {
+                while (index >= result.size) {
+                    result.add(0)
+                }
+                val value = product + over + result[index]
+                result[index] = value % 10
+                over = value / 10
+                return
+            }
+
+            chars_2.forEachIndexed { j, c2 ->
+                index = i + j
+                val multiplier_2 = c2 - '0'
+                sum(multiplier_1 * multiplier_2)
+            }
+
+            while (over > 0) {
+                index++
+                sum()
+            }
+        }
+
+        return result.reversed().joinToString("")
+    }
+}
+```
+
+#### JavaScript
+
+```js
+/**
+ * @param {string} num1
+ * @param {string} num2
+ * @return {string}
+ */
+var multiply = function (num1, num2) {
+    if (num1 === '0' || num2 === '0') return '0';
+
+    const result = Array(num1.length + num2.length).fill(0);
+    const code_0 = '0'.charCodeAt(0);
+
+    const num1_len = num1.length;
+    const num2_len = num2.length;
+
+    for (let i = 0; i < num1_len; ++i) {
+        const multiplier_1 = num1.charCodeAt(num1_len - i - 1) - code_0;
+        for (let j = 0; j < num2_len; ++j) {
+            const multiplier_2 = num2.charCodeAt(num2_len - j - 1) - code_0;
+            result[i + j] += multiplier_1 * multiplier_2;
+        }
+    }
+
+    result.reduce((carry, value, index) => {
+        const sum = carry + value;
+        result[index] = sum % 10;
+        return (sum / 10) | 0;
+    }, 0);
+
+    return result
+        .slice(0, result.findLastIndex(d => d !== 0) + 1)
+        .reverse()
+        .join('');
+};
+```
+
 <!-- tabs:end -->
 
 <!-- solution:end -->