Completed Binary Search 1 Problems

Exercise1.py

@@ -0,0 +1,36 @@
+#TC: O(log n) - used binary search
+#SC: O(1)
+
+class Solution(object):
+    def search(self, nums, target):
+        """
+        :type nums: List[int]
+        :type target: int
+        :rtype: int
+        """
+        left = 0
+        right = len(nums)-1
+
+        while left<=right:
+            mid = (left + right) //2
+
+            if nums[mid] == target:
+                return mid
+
+            #Check if left half is sorted
+            if nums[left] <= nums[mid]:
+                #target is in left half
+                if nums[left] <= target < nums[mid]:
+                    right = mid - 1
+                else: #target in right half
+                    left = mid + 1
+            #Check sorted right half
+            else:
+                #Target in right half
+                if nums[mid] < target <= nums[right]:
+                    left = mid + 1
+                #target in left half
+                else:
+                    right = mid - 1
+        return -1
+

Exercise2.py

@@ -0,0 +1,40 @@
+#TC: O(log m x n) = O(log n)
+#m: rows
+#n: columns
+#SC: O(1)
+class Solution(object):
+    def searchMatrix(self, matrix, target):
+        """
+        :type matrix: List[List[int]]
+        :type target: int
+        :rtype: bool
+        """
+        rows, cols = len(matrix), len(matrix[0])
+        top, bot = 0, rows-1
+
+        while(top<= bot):
+            row = (top+bot)//2
+            if(target > matrix[row][-1]):
+                top = row+1
+            elif(target < matrix[row][0]):
+                bot = row - 1 
+            else:
+                break
+        if not (top<= bot):
+            return False
+
+        row = (top+bot)//2
+        print(row)
+        l, r = 0, cols-1
+
+        while(l <= r):
+            mid = (l+r)//2
+            print(mid)
+            if(target > matrix[row][mid]):
+                l = mid+1
+            elif(target < matrix[row][mid]):
+                r = mid-1
+            else:
+                return True
+
+        return False

Exercise3.py

@@ -0,0 +1,46 @@
+
+# """
+# This is ArrayReader's API interface.
+# You should not implement it, or speculate about its implementation
+# """
+#class ArrayReader(object):
+#    def get(self, index):
+#        """
+#        :type index: int
+#        :rtype int
+#        """
+
+
+#TC: O(log n) + O(log n) = O(log n)
+# Finding the upper bound will take O(log n) because the search range grows exponentially and then we have to perform a binary search which also takes O(log n)
+#SC: O(1)
+
+class Solution(object):
+    def search(self, reader, target):
+        """
+        :type reader: ArrayReader
+        :type target: int
+        :rtype: int
+        """
+        low = 0
+        high = 1
+
+        #Find upper bound
+        while reader.get(high) < target:
+            low = high 
+            high *= 2 #Exponentially expand the search range
+
+        #Perform the binary search
+        while low<= high:
+            mid = (low+high)//2
+            val = reader.get(mid)
+
+            if val == target:
+                return mid
+            #If mid is out of bounds, shrink the search space
+            elif val > target or val == 2**31-1:
+                high = mid - 1
+            else:
+                low = mid + 1
+        return -1
+