I think i'm cheating myself too much

Author: JustAnotherSoftwareDeveloper

solutions/src/CobinationSumThree.kt

@@ -0,0 +1,29 @@
+import java.util.*
+
+
+/**
+ * https://leetcode.com/problems/combination-sum-iii/
+ * cheated, for no reason because the answer was as complex as I was
+ */
+class CobinationSumThree {
+    fun combinationSum3(k: Int, n: Int): List<List<Int>>? {
+        val num = intArrayOf(1, 2, 3, 4, 5, 6, 7, 8, 9)
+        val result: MutableList<List<Int>> = ArrayList()
+        helper(result, ArrayList(), num, k, n, 0)
+        return result
+    }
+
+    private fun helper(result: MutableList<List<Int>>, list: MutableList<Int>, num: IntArray, k: Int, target: Int, start: Int) {
+        if (k == 0 && target == 0) {
+            result.add(ArrayList(list))
+        } else {
+            var i = start
+            while (i < num.size && target > 0 && k > 0) {
+                list.add(num[i])
+                helper(result, list, num, k - 1, target - num[i], i + 1)
+                list.removeAt(list.size - 1)
+                i++
+            }
+        }
+    }
+}

solutions/src/KthLargestElement.kt

@@ -0,0 +1,45 @@
+/**
+ * Looked up solution
+ *
+ */
+class KthLargestElement {
+    fun findKthLargest(nums: IntArray, k: Int): Int {
+        var k = k
+        k = nums.size - k
+        var lo = 0
+        var hi = nums.size - 1
+        while (lo < hi) {
+            val j = partition(nums, lo, hi)
+            if (j < k) {
+                lo = j + 1
+            } else if (j > k) {
+                hi = j - 1
+            } else {
+                break
+            }
+        }
+        return nums[k]
+    }
+
+    private fun partition(a: IntArray, lo: Int, hi: Int): Int {
+        var i = lo
+        var j = hi + 1
+        while (true) {
+            while (i < hi && a[++i] < a[lo]);
+            while (j > lo && a[lo] < a[--j]);
+            if (i >= j) {
+                break
+            }
+            exch(a, i, j)
+        }
+        exch(a, lo, j)
+        return j
+    }
+
+    private fun exch(a: IntArray, i: Int, j: Int) {
+        val tmp = a[i]
+        a[i] = a[j]
+        a[j] = tmp
+    }
+
+}

solutions/src/MiniumSizeSubArraySum.kt

@@ -0,0 +1,55 @@
+import kotlin.math.min
+
+/**
+ * https://leetcode.com/problems/minimum-size-subarray-sum/
+ */
+class MiniumSizeSubArraySum {
+    fun minSubArrayLen(s: Int, nums: IntArray) : Int {
+        if (nums.isEmpty()) {
+            return 0
+        }
+        var minLength : Int? = null
+        var lower = 0
+        var upper = 0
+        var sumAtLower = IntArray(nums.size)
+        var sumUpper = IntArray(nums.size)
+        val totalSum = nums.sum()
+        for(i in nums.indices) {
+            if (i == 0) {
+                sumAtLower[0] = nums[0]
+            }
+            else {
+                sumAtLower[i]=nums[i]+sumAtLower[i-1]
+            }
+        }
+        for (i in nums.lastIndex downTo 0) {
+            if (i == nums.lastIndex) {
+                sumUpper[i] = nums[i]
+            }
+            else {
+                sumUpper[i] = nums[i]+sumUpper[i+1]
+            }
+        }
+        while (lower in 0..upper && upper < nums.size) {
+            val sum = when {
+                lower == 0 -> {
+                    sumAtLower[upper]
+                }
+                upper == nums.lastIndex -> {
+                    sumUpper[lower]
+                }
+                else -> {
+                    totalSum - (sumAtLower[lower-1]+sumUpper[upper+1])
+                }
+            }
+            if (sum >= s) {
+                minLength = minOf(1 + (upper- lower), minLength ?: Int.MAX_VALUE)
+                lower++
+            }
+            else {
+                upper++
+            }
+        }
+        return minLength ?: 0
+    }
+}

solutions/src/Search2DMatrixTwo.kt

@@ -0,0 +1,44 @@
+/**
+ * https://leetcode.com/problems/search-a-2d-matrix-ii/
+ */
+class Search2DMatrixTwo {
+    fun searchMatrix(matrix: Array<IntArray>, target: Int): Boolean {
+        if (matrix.isEmpty()) {
+            return false
+        }
+        if (matrix[0].isEmpty()) {
+            return false
+        }
+        for (i in matrix.indices) {
+            if (matrix[i].binarySearch(target) >= 0) {
+                return true
+            }
+        }
+        for (j in matrix[0].indices) {
+            if (binarySearchColumn(matrix,j,0,matrix.lastIndex,target)) {
+                return true
+            }
+        }
+        return false
+    }
+
+    private fun binarySearchColumn(matrix: Array<IntArray>, column: Int, lower: Int, upper: Int, target: Int) : Boolean {
+        return if (lower > upper) {
+            false
+        }
+        else {
+            val mid = lower + (upper-lower)/2
+            when {
+                matrix[mid][column] == target -> {
+                    true
+                }
+                matrix[mid][column] > target -> {
+                    binarySearchColumn(matrix,column,lower,mid-1,target)
+                }
+                else -> {
+                    binarySearchColumn(matrix,column,mid+1,upper,target)
+                }
+            }
+        }
+    }
+}

solutions/src/SingleNumberIII.kt

@@ -0,0 +1,14 @@
+/**
+ * https://leetcode.com/problems/single-number-iii/
+ */
+class SingleNumberIII {
+    fun singleNumber(nums: IntArray) : IntArray {
+        return nums
+                .toList()
+                .groupingBy { it }
+                .eachCount()
+                .filter { it.value == 1 }
+                .map { it.key }
+                .toIntArray()
+    }
+}

solutions/src/TestBed.kt

@@ -5,12 +5,21 @@ import kotlin.time.measureTime
 @ExperimentalTime
 fun main(args: Array<String>) {
     println(measureTime {
-        val tester = CourseScheduleTwo()
+        val tester = Search2DMatrixTwo()
         val results = listOf(
-                tester.findOrder(2, arrayOf(intArrayOf(1,0)))
+                tester.searchMatrix(
+                        arrayOf(
+                                intArrayOf(1,4,7,11,15),
+                                intArrayOf(2,5,8,12,19),
+                                intArrayOf(3,6,9,16,22),
+                                intArrayOf(10,13,14,17,24),
+                                intArrayOf(18,21,23,26,30)
+                        ),
+                        20
+                )
 
         )
-        println(results.map { it.toList() })
+        println(results.map { it })
     })
 
 }