Added tasks 34, 35.

Author: javadev

src/main/kotlin/g0001_0100/s0034_find_first_and_last_position_of_element_in_sorted_array/Solution.kt

@@ -0,0 +1,32 @@
+package g0001_0100.s0034_find_first_and_last_position_of_element_in_sorted_array
+
+// #Medium #Top_100_Liked_Questions #Top_Interview_Questions #Array #Binary_Search
+// #Algorithm_II_Day_1_Binary_Search #Binary_Search_I_Day_5
+// #2022_04_30_Time_228_ms_(83.38%)_Space_39.6_MB_(85.97%)
+
+class Solution constructor() {
+    fun searchRange(nums: IntArray, target: Int): IntArray {
+        val ans = IntArray(2)
+        ans[0] = helper(nums, target, false)
+        ans[1] = helper(nums, target, true)
+        return ans
+    }
+
+    private fun helper(nums: IntArray, target: Int, equals: Boolean): Int {
+        var l = 0
+        var r: Int = nums.size - 1
+        var result: Int = -1
+        while (l <= r) {
+            val mid: Int = l + (r - l) / 2
+            if (nums[mid] == target) {
+                result = mid
+            }
+            if (nums[mid] < target || (nums[mid] == target && equals)) {
+                l = mid + 1
+            } else {
+                r = mid - 1
+            }
+        }
+        return result
+    }
+}

src/main/kotlin/g0001_0100/s0034_find_first_and_last_position_of_element_in_sorted_array/readme.md

@@ -0,0 +1,34 @@
+34\. Find First and Last Position of Element in Sorted Array
+
+Medium
+
+Given an array of integers `nums` sorted in non-decreasing order, find the starting and ending position of a given `target` value.
+
+If `target` is not found in the array, return `[-1, -1]`.
+
+You must write an algorithm with `O(log n)` runtime complexity.
+
+**Example 1:**
+
+**Input:** nums = [5,7,7,8,8,10], target = 8
+
+**Output:** [3,4]
+
+**Example 2:**
+
+**Input:** nums = [5,7,7,8,8,10], target = 6
+
+**Output:** [-1,-1]
+
+**Example 3:**
+
+**Input:** nums = [], target = 0
+
+**Output:** [-1,-1]
+
+**Constraints:**
+
+*   <code>0 <= nums.length <= 10<sup>5</sup></code>
+*   <code>-10<sup>9</sup> <= nums[i] <= 10<sup>9</sup></code>
+*   `nums` is a non-decreasing array.
+*   <code>-10<sup>9</sup> <= target <= 10<sup>9</sup></code>

src/main/kotlin/g0001_0100/s0035_search_insert_position/Solution.kt

@@ -0,0 +1,22 @@
+package g0001_0100.s0035_search_insert_position
+
+// #Easy #Top_100_Liked_Questions #Array #Binary_Search #Algorithm_I_Day_1_Binary_Search
+// #Binary_Search_I_Day_2 #2022_04_30_Time_267_ms_(50.32%)_Space_39.5_MB_(33.93%)
+
+class Solution {
+    fun searchInsert(nums: IntArray, target: Int): Int {
+        var lo = 0
+        var hi = nums.size - 1
+        while (lo <= hi) {
+            val mid = lo + (hi - lo) / 2
+            if (target == nums[mid]) {
+                return mid
+            } else if (target < nums[mid]) {
+                hi = mid - 1
+            } else if (target > nums[mid]) {
+                lo = mid + 1
+            }
+        }
+        return lo
+    }
+}

src/main/kotlin/g0001_0100/s0035_search_insert_position/readme.md

@@ -0,0 +1,44 @@
+35\. Search Insert Position
+
+Easy
+
+Given a sorted array of distinct integers and a target value, return the index if the target is found. If not, return the index where it would be if it were inserted in order.
+
+You must write an algorithm with `O(log n)` runtime complexity.
+
+**Example 1:**
+
+**Input:** nums = [1,3,5,6], target = 5
+
+**Output:** 2
+
+**Example 2:**
+
+**Input:** nums = [1,3,5,6], target = 2
+
+**Output:** 1
+
+**Example 3:**
+
+**Input:** nums = [1,3,5,6], target = 7
+
+**Output:** 4
+
+**Example 4:**
+
+**Input:** nums = [1,3,5,6], target = 0
+
+**Output:** 0
+
+**Example 5:**
+
+**Input:** nums = [1], target = 0
+
+**Output:** 0
+
+**Constraints:**
+
+*   <code>1 <= nums.length <= 10<sup>4</sup></code>
+*   <code>-10<sup>4</sup> <= nums[i] <= 10<sup>4</sup></code>
+*   `nums` contains **distinct** values sorted in **ascending** order.
+*   <code>-10<sup>4</sup> <= target <= 10<sup>4</sup></code>

src/test/kotlin/g0001_0100/s0034_find_first_and_last_position_of_element_in_sorted_array/SolutionTest.kt

@@ -0,0 +1,28 @@
+package g0001_0100.s0034_find_first_and_last_position_of_element_in_sorted_array
+
+import org.hamcrest.CoreMatchers.equalTo
+import org.hamcrest.MatcherAssert.assertThat
+import org.junit.jupiter.api.Test
+
+internal class SolutionTest {
+    @Test
+    fun searchRange() {
+        val expected = intArrayOf(3, 4)
+        val actual = Solution().searchRange(intArrayOf(5, 7, 7, 8, 8, 10), 8)
+        assertThat(actual, equalTo(expected))
+    }
+
+    @Test
+    fun searchRange2() {
+        val expected = intArrayOf(-1, -1)
+        val actual = Solution().searchRange(intArrayOf(5, 7, 7, 8, 8, 10), 6)
+        assertThat(actual, equalTo(expected))
+    }
+
+    @Test
+    fun searchRange3() {
+        val expected = intArrayOf(-1, -1)
+        val actual = Solution().searchRange(intArrayOf(), 0)
+        assertThat(actual, equalTo(expected))
+    }
+}

src/test/kotlin/g0001_0100/s0035_search_insert_position/SolutionTest.kt

@@ -0,0 +1,22 @@
+package g0001_0100.s0035_search_insert_position
+
+import org.hamcrest.CoreMatchers.equalTo
+import org.hamcrest.MatcherAssert.assertThat
+import org.junit.jupiter.api.Test
+
+internal class SolutionTest {
+    @Test
+    fun searchInsert() {
+        assertThat(Solution().searchInsert(intArrayOf(1, 3, 5, 6), 5), equalTo(2))
+    }
+
+    @Test
+    fun searchInsert2() {
+        assertThat(Solution().searchInsert(intArrayOf(1, 3, 5, 6), 2), equalTo(1))
+    }
+
+    @Test
+    fun searchInsert3() {
+        assertThat(Solution().searchInsert(intArrayOf(1, 3, 5, 6), 7), equalTo(4))
+    }
+}