Add Binary Search Solutions

Author: marttp

kotlin/Binary Search/CuttingWood.kt

@@ -0,0 +1,27 @@
+fun cuttingWood(heights: List<Int>, k: Int): Int {
+    var left = 0
+    var right = heights.maxOrNull()!!
+    while (left < right) {
+        // Bias the midpoint to the right during the upper-bound binary
+        // search.
+        val mid = (left + (right - left) / 2) + 1
+        if (cutsEnoughWood(mid, k, heights)) {
+            left = mid
+        } else {
+            right = mid - 1
+        }
+    }
+    return right
+}
+
+// Determine if the current value of 'H' cuts at least 'k' meters of
+// wood.
+fun cutsEnoughWood(H: Int, k: Int, heights: List<Int>): Boolean {
+    var woodCollected = 0
+    for (height in heights) {
+        if (height > H) {
+            woodCollected += height - H
+        }
+    }
+    return woodCollected >= k
+}

kotlin/Binary Search/FindTheInsertionIndex.kt

@@ -0,0 +1,17 @@
+fun findTheInsertionIndex(nums: List<Int>, target: Int): Int {
+    var left = 0
+    var right = nums.size
+    while (left < right) {
+        val mid = left + (right - left) / 2
+        // If the midpoint value is greater than or equal to the target,
+        // the lower bound is either at the midpoint, or to its left.
+        if (nums[mid] >= target) {
+            right = mid
+        // The midpoint value is less than the target, indicating the
+        // lower bound is somewhere to the right.
+        } else {
+            left = mid + 1
+        }
+    }
+    return left
+}

kotlin/Binary Search/FindTheMedianFromTwoSortedArray.kt

@@ -0,0 +1,39 @@
+fun findTheMedianFromTwoSortedArrays(nums1: List<Int>, nums2: List<Int>): Double {
+    val m = nums1.size
+    val n = nums2.size
+    // Ensure 'nums1' is the smaller array.
+    if (m > n) {
+        return findTheMedianFromTwoSortedArrays(nums2, nums1)
+    }
+    var left = 0
+    var right = m - 1
+    val halfTotalLen = (m + n) / 2
+    // A median always exists in a non-empty array, so continue binary search until
+    // it’s found.
+    while (true) {
+        val L1Index = (left + right) / 2
+        val L2Index = halfTotalLen - (L1Index + 1) - 1
+        // Set to -infinity or +infinity if out of bounds.
+        val L1 = if (L1Index < 0) Double.MIN_VALUE else nums1[L1Index].toDouble()
+        val R1 = if (L1Index >= m - 1) Double.MAX_VALUE else nums1[L1Index + 1].toDouble()
+        val L2 = if (L2Index < 0) Double.MIN_VALUE else nums2[L2Index].toDouble()
+        val R2 = if (L2Index >= n - 1) Double.MAX_VALUE else nums2[L2Index + 1].toDouble()
+        // If 'L1 > R2', then 'L1' is too far to the right. Narrow the search space
+        // toward the left.
+        if (L1 > R2) {
+            right = L1Index - 1
+            // If 'L2 > R1', then 'L1' is too far to the left. Narrow the search space
+            // toward the right.
+        } else if (L2 > R1) {
+            left = L1Index + 1
+            // If both 'L1' and 'L2' are less than or equal to both 'R1' and 'R2', we
+            // found the correct slice.
+        } else {
+            return if ((m + n) % 2 == 0) {
+                (maxOf(L1, L2) + minOf(R1, R2)) / 2.0
+            } else {
+                minOf(R1, R2)
+            }
+        }
+    }
+}

kotlin/Binary Search/FindTheTargetInARotatedSortedArray.kt

@@ -0,0 +1,30 @@
+fun findTheTargetInARotatedSortedArray(nums: List<Int>, target: Int): Int {
+    var left = 0
+    var right = nums.size - 1
+    while (left < right) {
+        val mid = left + (right - left) / 2
+        if (nums[mid] == target) {
+            return mid
+        }
+        // If the left subarray [left : mid] is sorted, check if the 
+        // target falls in this range. If it does, search the left 
+        // subarray. Otherwise, search the right.
+        if (nums[left] <= nums[mid]) {
+            if (nums[left] <= target && target < nums[mid]) {
+                right = mid - 1
+            } else {
+                left = mid + 1
+            }
+        // If the right subarray [mid : right] is sorted, check if the
+        // target falls in this range. If it does, search the right
+        // subarray. Otherwise, search the left.
+        } else {
+            if (nums[mid] < target && target <= nums[right]) {
+                left = mid + 1
+            } else {
+                right = mid - 1
+            }
+        }
+    }
+    return if (nums.isNotEmpty() && nums[left] == target) left else -1
+}

kotlin/Binary Search/FirstAndLastOccurrencesOfANumber.kt

@@ -0,0 +1,38 @@
+fun firstAndLastOccurrencesOfANumber(nums: List<Int>, target: Int): List<Int> {
+    val lowerBound = lowerBoundBinarySearch(nums, target)
+    val upperBound = upperBoundBinarySearch(nums, target)
+    return listOf(lowerBound, upperBound)
+}
+
+fun lowerBoundBinarySearch(nums: List<Int>, target: Int): Int {
+    var left = 0
+    var right = nums.size - 1
+    while (left < right) {
+        val mid = left + (right - left) / 2
+        when {
+            nums[mid] > target -> right = mid - 1
+            nums[mid] < target -> left = mid + 1
+            else -> right = mid
+        }
+    }
+    return if (nums.isNotEmpty() && nums[left] == target) left else -1
+}
+
+fun upperBoundBinarySearch(nums: List<Int>, target: Int): Int {
+    var left = 0
+    var right = nums.size - 1
+    while (left < right) {
+        // In upper-bound binary search, bias the midpoint to the right.
+        val mid = (left + (right - left) / 2) + 1
+        when {
+            nums[mid] > target -> right = mid - 1
+            nums[mid] < target -> left = mid + 1
+            else -> left = mid
+        }
+    }
+    // If the target doesn't exist in the array, then it's possible that
+    // 'left = mid + 1' places the left pointer outside the array when
+    // 'mid == n - 1'. So, we use the right pointer in the return
+    // statement instead.
+    return if (nums.isNotEmpty() && nums[right] == target) right else -1
+}

kotlin/Binary Search/LocalMaximaInArray.kt

@@ -0,0 +1,13 @@
+fun localMaximaInArray(nums: List<Int>): Int {
+    var left = 0
+    var right = nums.size - 1
+    while (left < right) {
+        val mid = left + (right - left) / 2
+        if (nums[mid] > nums[mid + 1]) {
+            right = mid
+        } else {
+            left = mid + 1
+        }
+    }
+    return left
+}

kotlin/Binary Search/MatrixSearch.kt

@@ -0,0 +1,20 @@
+fun matrixSearch(matrix: List<List<Int>>, target: Int): Boolean {
+    val m = matrix.size
+    val n = matrix[0].size
+    var left = 0
+    var right = m * n - 1
+    // Perform binary search to find the target.
+    while (left <= right) {
+        val mid = left + (right - left) / 2
+        val r = mid / n
+        val c = mid % n
+        if (matrix[r][c] == target) {
+            return true
+        } else if (matrix[r][c] > target) {
+            right = mid - 1
+        } else {
+            left = mid + 1
+        }
+    }
+    return false
+}

kotlin/Binary Search/WeightRandomSelection.kt

@@ -0,0 +1,29 @@
+class WeightedRandomSelection(private val weights: IntArray) {
+    private val prefixSums = IntArray(weights.size)
+
+    init {
+        prefixSums[0] = weights[0]
+        for (i in 1 until weights.size) {
+            prefixSums[i] = prefixSums[i - 1] + weights[i]
+        }
+    }
+
+    fun select(): Int {
+        // Pick a random target between 1 and the largest endpoint on the number
+        // line.
+        val target = (1..prefixSums.last()).random()
+        var left = 0
+        var right = prefixSums.size - 1
+        // Perform lower-bound binary search to find which endpoint (i.e., prefix
+        // sum value) corresponds to the target.
+        while (left < right) {
+            val mid = left + (right - left) / 2
+            if (prefixSums[mid] < target) {
+                left = mid + 1
+            } else {
+                right = mid
+            }
+        }
+        return left
+    }
+}