add kotlin solutions

Author: MagicienDeCode

June-LeetCoding-Challenge/09-Is-Subsequence/Is-Subsequence.kt

@@ -0,0 +1,54 @@
+class IsSubsequenceKotlin392 {
+
+    fun isSubsequence(s: String, t: String): Boolean {
+        if (s.isEmpty()) {
+            return true
+        }
+        var indexS = 0
+        t.forEach {
+            if (it == s[indexS]) {
+                if (++indexS == s.length) {
+                    return true
+                }
+            }
+        }
+        return false
+    }
+
+    /*
+    fun isSubsequence(s: String, t: String): Boolean {
+        val tMap = mutableMapOf<Char, MutableList<Int>>()
+        t.forEachIndexed { index, c ->
+            tMap.computeIfAbsent(c) { mutableListOf() }.add(index)
+        }
+        var indexOft = 0
+        s.forEach {
+            indexOft = binarySearch(tMap[it], indexOft)
+            if (indexOft++ == -1) {
+                return false
+            }
+        }
+        return true
+    }
+
+    private fun binarySearch(nums: List<Int>?, target: Int): Int {
+        if (nums.isNullOrEmpty()) {
+            return -1
+        }
+        var left = 0
+        var right = nums.size - 1
+        while (left + 1 < right) {
+            val mid = left + (right - left) / 2
+            when {
+                nums[mid] <= target -> left = mid
+                nums[mid] > target -> right = mid
+            }
+        }
+        return when {
+            nums[left] >= target -> nums[left]
+            nums[right] >= target -> nums[right]
+            else -> -1
+        }
+    }
+     */
+}

June-LeetCoding-Challenge/10-Search-Insert-Position/Search-Insert-Position.kt

@@ -0,0 +1,21 @@
+class SearchInsertPositionKotlin35 {
+    fun searchInsert(nums: IntArray, target: Int): Int {
+        if (nums.isEmpty()) {
+            return -1
+        }
+        var left = 0
+        var right = nums.size - 1
+        while (left + 1 < right) {
+            val mid = left + (right - left) / 2
+            when {
+                nums[mid] <= target -> left = mid
+                nums[mid] > target -> right = mid
+            }
+        }
+        return when {
+            target <= nums[left] -> left
+            target <= nums[right] -> right
+            else -> right + 1
+        }
+    }
+}

June-LeetCoding-Challenge/11-Sort-Colors/Sort-Colors.kt

@@ -0,0 +1,44 @@
+class SortColorsKotlin75 {
+    fun sortColors(nums: IntArray) {
+        var zeroPosition = 0
+        var twoPosition = nums.size - 1
+        var index = 0
+        while (index <= twoPosition) {
+            when {
+                nums[index] == 1 -> ++index
+                nums[index] == 0 -> swap(nums, zeroPosition++, index++)
+                else -> swap(nums, twoPosition--, index)
+            }
+        }
+    }
+
+    private fun swap(nums: IntArray, i: Int, j: Int) {
+        if (i == j) {
+            return
+        }
+        nums[i] = nums[i].xor(nums[j])
+        nums[j] = nums[i].xor(nums[j])
+        nums[i] = nums[i].xor(nums[j])
+    }
+}
+
+fun main() {
+    val solution = SortColorsKotlin75()
+    val test = intArrayOf(2, 2)
+    println(solution.sortColors(test))
+    test.forEach(::print)
+
+    // 0 3
+    val test2 = intArrayOf(3, 3)
+    test2[0] = test2[0].xor(test2[0])
+    test2[0] = test2[0].xor(test2[0])
+    test2[0] = test2[0].xor(test2[0])
+    test2.forEach(::print)
+
+    // 4 4
+    val test3 = intArrayOf(4, 4)
+    test3[0] = test3[0].xor(test3[1])
+    test3[1] = test3[0].xor(test3[1])
+    test3[0] = test3[0].xor(test3[1])
+    test3.forEach(::print)
+}

June-LeetCoding-Challenge/12-Insert-Delete-GetRandom/Insert-Delete-GetRandom.kt

@@ -0,0 +1,47 @@
+import kotlin.random.Random
+
+class InsertDeleteGetRandomO1Kotlin380 {
+    /** Initialize your data structure here. */
+    private val arrayList: MutableList<Int> = ArrayList()
+    private val map: MutableMap<Int, Int> = HashMap()
+
+    /** Inserts a value to the set. Returns true if the set did not already contain the specified element. */
+    fun insert(`val`: Int): Boolean {
+        if (map.containsKey(`val`)) {
+            return false
+        }
+        map[`val`] = arrayList.size
+        arrayList.add(`val`)
+        return true
+    }
+
+    /** Removes a value from the set. Returns true if the set contained the specified element. */
+    fun remove(`val`: Int): Boolean {
+        if (!map.containsKey(`val`)) {
+            return false
+        }
+        val removeIndex = map.getValue(`val`)
+        if (removeIndex != arrayList.size - 1) {
+            arrayList[removeIndex] = arrayList[arrayList.size - 1]
+            map[arrayList[arrayList.size - 1]] = removeIndex
+        }
+        arrayList.removeAt(arrayList.size - 1)
+        map.remove(`val`)
+        return true
+    }
+
+    /** Get a random element from the set. */
+    fun getRandom(): Int {
+        return arrayList[Random.Default.nextInt(arrayList.size)]
+    }
+}
+
+fun main() {
+    val solution = InsertDeleteGetRandomO1Kotlin380()
+    println(solution.insert(1))
+    println(solution.remove(2))
+    println(solution.insert(2))
+    println(solution.getRandom())
+    println(solution.remove(1))
+    println(solution.insert(2))
+}

June-LeetCoding-Challenge/13-Largest-Divisible-Subset/Largest-Divisible-Subset.kt

@@ -0,0 +1,32 @@
+class LargestDivisibleSubsetKotlin368 {
+    fun largestDivisibleSubset(nums: IntArray): List<Int> {
+        if (nums.isEmpty()) {
+            return emptyList()
+        }
+        nums.sort()
+        val dp = IntArray(nums.size) { 1 }
+        val links = IntArray(nums.size) { -1 }
+        var max = 0
+        var start = 0
+        for (i in nums.indices) {
+            for (j in i + 1 until nums.size) {
+                if (nums[j] % nums[i] == 0 &&
+                    dp[j] < dp[i] + 1
+                ) {
+                    dp[j] = dp[i] + 1
+                    links[j] = i
+                    if (dp[j] > max) {
+                        max = dp[j]
+                        start = j
+                    }
+                }
+            }
+        }
+        val result: MutableList<Int> = ArrayList()
+        while (start != -1) {
+            result.add(nums[start])
+            start = links[start]
+        }
+        return result
+    }
+}

June-LeetCoding-Challenge/14-Cheapest-Flights-Within-K-Stops/Cheapest-Flights-Within-K-Stops.kt

@@ -0,0 +1,37 @@
+class CheapestFlightsWithinKStopsKotlin787 {
+    /*
+    fun findCheapestPrice(n: Int, flights: Array<IntArray>, src: Int, dst: Int, K: Int): Int {
+        val dp = Array(K + 2) { IntArray(n) { 10000 * n } }
+        dp[0][src] = 0
+        for (time in 1..K + 1) {
+            dp[time][src] = 0
+            for (flight in flights) {
+                dp[time][flight[1]] = minOf(
+                    dp[time][flight[1]],
+                    dp[time - 1][flight[0]] + flight[2]
+                )
+            }
+        }
+        return when {
+            dp[K + 1][dst] >= 10000 * n -> -1
+            else -> dp[K + 1][dst]
+        }
+    }
+     */
+
+    fun findCheapestPrice(n: Int, flights: Array<IntArray>, src: Int, dst: Int, K: Int): Int {
+        var dp = IntArray(n) { 10000 * n }
+        dp[src] = 0
+        for (time in 0..K) {
+            val new = dp.copyOf(dp.size)
+            for (flight in flights) {
+                new[flight[1]] = minOf(new[flight[1]], dp[flight[0]] + flight[2])
+            }
+            dp = new
+        }
+        return when {
+            dp[dst] >= 10000 * n -> -1
+            else -> dp[dst]
+        }
+    }
+}