leetcode

Author: ayoubzulfiqar

SearchInRotatedSortedArrayIi/search_in_rotated_sorted_array_ii.dart

@@ -0,0 +1,71 @@
+/*
+
+-* 81. Search in Rotated Sorted Array II *-
+
+There is an integer array nums sorted in non-decreasing order (not necessarily with distinct values).
+
+Before being passed to your function, nums is rotated at an unknown pivot index k (0 <= 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,4,4,5,6,6,7] might be rotated at pivot index 5 and become [4,5,6,6,7,0,1,2,4,4].
+
+Given the array nums after the rotation and an integer target, return true if target is in nums, or false if it is not in nums.
+
+You must decrease the overall operation steps as much as possible.
+
+ 
+
+Example 1:
+
+Input: nums = [2,5,6,0,0,1,2], target = 0
+Output: true
+Example 2:
+
+Input: nums = [2,5,6,0,0,1,2], target = 3
+Output: false
+ 
+
+Constraints:
+
+1 <= nums.length <= 5000
+-104 <= nums[i] <= 104
+nums is guaranteed to be rotated at some pivot.
+-104 <= target <= 104
+ 
+
+Follow up: This problem is similar to Search in Rotated Sorted Array, but nums may contain duplicates. Would this affect the runtime complexity? How and why?
+
+
+*/
+
+
+
+class Solution {
+  bool search(List<int> nums, int target) {
+    for (int i = 0; i < nums.length; i++) {
+      if ((nums[i] ^ target) == 0) {
+        return true;
+      }
+    }
+
+    return false;
+  }
+}
+
+class A {
+  bool search(List<int> nums, int target) {
+    int n = nums.length;
+    if (target > nums[n - 1]) {
+      int i = 0;
+      do {
+        if (nums[i] == target) return true;
+        i++;
+      } while (i < n && nums[i] >= nums[i - 1]);
+    } else {
+      int i = n - 1;
+      do {
+        if (nums[i] == target) return true;
+        i--;
+      } while (i >= 0 && nums[i] <= nums[i + 1]);
+    }
+    return false;
+  }
+}
+

SearchInRotatedSortedArrayIi/search_in_rotated_sorted_array_ii.go

@@ -0,0 +1,50 @@
+package main
+
+import (
+	"sort"
+)
+
+func search(nums []int, target int) bool {
+	// Order the array in order to search
+	ordered := append([]int{}, nums...)
+	sort.Ints(ordered)
+
+	init := 0
+	end := len(ordered) - 1
+
+	// To memoize the computed values
+	memo := make(map[int]int)
+
+	for {
+		// Change the middle index based on the last init/end index value
+		mid := (end + init) / 2
+
+		// Memoize the computed indexes to avoid infinite loop
+		// If they were computed before, it means the value does not exist in the array
+		// If the value doesn't exist, break the loop and return false
+		if _, ok := memo[mid]; ok {
+			return false
+		} else {
+			memo[mid] = 0
+		}
+
+		// Regular binary search
+		if ordered[mid] == target {
+			return true
+		} else if ordered[mid] < target {
+			init = mid + 1
+		} else {
+			end = mid - 1
+		}
+	}
+}
+
+
+func searchONE(nums []int, target int) bool {
+    for _, num := range nums {
+        if num == target {
+            return true
+        }
+    }
+    return false
+}

SearchInRotatedSortedArrayIi/search_in_rotated_sorted_array_ii.md

@@ -0,0 +1,5 @@
+# Doc
+
+## [GO](https://leetcode.com/problems/search-in-rotated-sorted-array-ii/solutions/3890111/go-xor-memoization-simple-fast-and-easy-with-explanation/)
+
+## [DART](https://leetcode.com/problems/search-in-rotated-sorted-array-ii/solutions/3890102/3-solutions-simple-fast-and-easy-with-explanation/)