Added tasks 26, 33.

Author: javadev

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

@@ -0,0 +1,23 @@
+package g0001_0100.s0026_remove_duplicates_from_sorted_array
+
+// #Easy #Top_Interview_Questions #Array #Two_Pointers
+// #2022_03_29_Time_361_ms_(77.19%)_Space_47.7_MB_(25.17%)
+
+class Solution {
+    fun removeDuplicates(nums: IntArray): Int {
+        val n = nums.size
+        var i = 0
+        var j = 1
+        if (n <= 1) {
+            return n
+        }
+        while (j <= n - 1) {
+            if (nums[i] != nums[j]) {
+                nums[i + 1] = nums[j]
+                i++
+            }
+            j++
+        }
+        return i + 1
+    }
+}

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

@@ -0,0 +1,49 @@
+26\. Remove Duplicates from Sorted Array
+
+Easy
+
+Given an integer array `nums` sorted in **non-decreasing order**, remove the duplicates [**in-place**](https://en.wikipedia.org/wiki/In-place_algorithm) such that each unique element appears only **once**. The **relative order** of the elements should be kept the **same**.
+
+Since it is impossible to change the length of the array in some languages, you must instead have the result be placed in the **first part** of the array `nums`. More formally, if there are `k` elements after removing the duplicates, then the first `k` elements of `nums` should hold the final result. It does not matter what you leave beyond the first `k` elements.
+
+Return `k` _after placing the final result in the first_ `k` _slots of_ `nums`.
+
+Do **not** allocate extra space for another array. You must do this by **modifying the input array [in-place](https://en.wikipedia.org/wiki/In-place_algorithm)** with O(1) extra memory.
+
+**Custom Judge:**
+
+The judge will test your solution with the following code:
+
+    int[] nums = [...]; // Input array
+    int[] expectedNums = [...]; // The expected answer with correct length
+
+    int k = removeDuplicates(nums); // Calls your implementation
+
+    assert k == expectedNums.length;
+    for (int i = 0; i < k; i++) {
+        assert nums[i] == expectedNums[i];
+    } 
+
+If all assertions pass, then your solution will be **accepted**.
+
+**Example 1:**
+
+**Input:** nums = [1,1,2]
+
+**Output:** 2, nums = [1,2,\_]
+
+**Explanation:** Your function should return k = 2, with the first two elements of nums being 1 and 2 respectively. It does not matter what you leave beyond the returned k (hence they are underscores).
+
+**Example 2:**
+
+**Input:** nums = [0,0,1,1,1,2,2,3,3,4]
+
+**Output:** 5, nums = [0,1,2,3,4,\_,\_,\_,\_,\_]
+
+**Explanation:** Your function should return k = 5, with the first five elements of nums being 0, 1, 2, 3, and 4 respectively. It does not matter what you leave beyond the returned k (hence they are underscores).
+
+**Constraints:**
+
+*   <code>0 <= nums.length <= 3 * 10<sup>4</sup></code>
+*   `-100 <= nums[i] <= 100`
+*   `nums` is sorted in **non-decreasing** order.

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

@@ -0,0 +1,37 @@
+package g0001_0100.s0033_search_in_rotated_sorted_array
+
+// #Medium #Top_100_Liked_Questions #Top_Interview_Questions #Array #Binary_Search
+// #Algorithm_II_Day_1_Binary_Search #2022_03_29_Time_184_ms_(86.08%)_Space_37.2_MB_(36.66%)
+
+class Solution {
+    fun search(nums: IntArray, target: Int): Int {
+        var mid: Int
+        var lo = 0
+        var hi = nums.size - 1
+        while (lo <= hi) {
+            mid = (hi - lo shr 1) + lo
+            if (target == nums[mid]) {
+                return mid
+            }
+            // if this is true, then the possible rotation can only be in the second half
+            if (nums[lo] <= nums[mid]) {
+                // the target is in the first half only if it's
+                if (nums[lo] <= target && target <= nums[mid]) {
+                    // included
+                    hi = mid - 1
+                } else {
+                    // between nums[lo] and nums[mid]
+                    lo = mid + 1
+                }
+                // otherwise, the possible rotation can only be in the first half
+            } else if (nums[mid] <= target && target <= nums[hi]) {
+                // the target is in the second half only if it's included
+                lo = mid + 1
+            } else {
+                // between nums[hi] and nums[mid]
+                hi = mid - 1
+            }
+        }
+        return -1
+    }
+}

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

@@ -0,0 +1,37 @@
+33\. Search in Rotated Sorted Array
+
+Medium
+
+There is an integer array `nums` sorted in ascending order (with **distinct** values).
+
+Prior to being passed to your function, `nums` is **possibly rotated** at an unknown pivot index `k` (`1 <= k < nums.length`) such that the resulting array is `[nums[k], nums[k+1], ..., nums[n-1], nums[0], nums[1], ..., nums[k-1]]` (**0-indexed**). For example, `[0,1,2,4,5,6,7]` might be rotated at pivot index `3` and become `[4,5,6,7,0,1,2]`.
+
+Given the array `nums` **after** the possible rotation and an integer `target`, return _the index of_ `target` _if it is in_ `nums`_, or_ `-1` _if it is not in_ `nums`.
+
+You must write an algorithm with `O(log n)` runtime complexity.
+
+**Example 1:**
+
+**Input:** nums = [4,5,6,7,0,1,2], target = 0
+
+**Output:** 4
+
+**Example 2:**
+
+**Input:** nums = [4,5,6,7,0,1,2], target = 3
+
+**Output:** -1
+
+**Example 3:**
+
+**Input:** nums = [1], target = 0
+
+**Output:** -1
+
+**Constraints:**
+
+*   `1 <= nums.length <= 5000`
+*   <code>-10<sup>4</sup> <= nums[i] <= 10<sup>4</sup></code>
+*   All values of `nums` are **unique**.
+*   `nums` is an ascending array that is possibly rotated.
+*   <code>-10<sup>4</sup> <= target <= 10<sup>4</sup></code>

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

@@ -0,0 +1,15 @@
+package g0001_0100.s0026_remove_duplicates_from_sorted_array
+
+import org.hamcrest.CoreMatchers.equalTo
+import org.hamcrest.MatcherAssert.assertThat
+import org.junit.jupiter.api.Test
+import java.util.Arrays
+
+internal class SolutionTest {
+    @Test
+    fun removeDuplicates() {
+        val array = intArrayOf(1, 1, 2)
+        val end = Solution().removeDuplicates(array)
+        assertThat(Arrays.toString(Arrays.copyOfRange(array, 0, end)), equalTo("[1, 2]"))
+    }
+}

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

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