8/26/23

- search_entry_equal_to_index.py
- search_first_key.py
- search_shifted_sorted_array.py
- int_square_root.py
- search_row_col_sorted_matrix.py

Author: jsgoller1

elements-of-programming-interviews/problem_mapping.js

@@ -1308,7 +1308,7 @@ problem_mapping = {
                 "total": 314
             },
             "Python: search_first_key.py": {
-                "passed": 0,
+                "passed": 314,
                 "total": 314
             }
         },
@@ -1322,7 +1322,7 @@ problem_mapping = {
                 "total": 501
             },
             "Python: search_entry_equal_to_index.py": {
-                "passed": 0,
+                "passed": 501,
                 "total": 501
             }
         },
@@ -1336,7 +1336,7 @@ problem_mapping = {
                 "total": 307
             },
             "Python: search_shifted_sorted_array.py": {
-                "passed": 0,
+                "passed": 307,
                 "total": 307
             }
         },
@@ -1350,7 +1350,7 @@ problem_mapping = {
                 "total": 2000
             },
             "Python: int_square_root.py": {
-                "passed": 0,
+                "passed": 2000,
                 "total": 2000
             }
         },
@@ -1378,7 +1378,7 @@ problem_mapping = {
                 "total": 194
             },
             "Python: search_row_col_sorted_matrix.py": {
-                "passed": 0,
+                "passed": 194,
                 "total": 194
             }
         },

elements-of-programming-interviews/python/int_square_root.py

@@ -1,9 +1,30 @@
 from test_framework import generic_test
 
 
+"""
+Adapt binary search
+if m*m > k, choose lower, no solution
+if m*m == k, return m
+if m*m < k choose upper, but m might be candidate
+"""
+
+
 def square_root(k: int) -> int:
-    # TODO - you fill in here.
-    return 0
+    lo, hi = 0, k
+    # ensures we examine all possible candidates
+    while lo <= hi:
+        m = (hi + lo) // 2
+        if m*m > k:
+            # m is definitely not a solution
+            hi = m-1
+        elif m*m == k:
+            return m
+        else:  # m*m < k
+            # m might be a solution; we exclude it for
+            # now, but hi will pick it up when hi < lo
+            # if it's the best solution.
+            lo = m+1
+    return hi
 
 
 if __name__ == '__main__':

elements-of-programming-interviews/python/search_entry_equal_to_index.py

@@ -6,9 +6,31 @@
 from test_framework.test_utils import enable_executor_hook
 
 
-def search_entry_equal_to_its_index(A: List[int]) -> int:
-    # TODO - you fill in here.
-    return 0
+"""
+Suppose i < j < k
+If arr[j] > j, we know that every subsequent arr[k] > k, so no candidates are there. 
+If arr[j] > j, we know nothing about arr[i] and i, unless the array is contiguous (which it isn't)
+
+If arr[j] < j, then this is also true for every arr[i] and i, but we know nothing about arr[k] and k.
+
+So do a standard binary search but:
+    if arr[mid] > mid: pick lower
+    if arr[mid] == mid, that's our answer.
+    if arr[mid] < mid, pick higher.
+"""
+
+
+def search_entry_equal_to_its_index(arr: List[int]) -> int:
+    l, r = 0, len(arr)-1
+    while l <= r:
+        mid = l + ((r-l) // 2)
+        if arr[mid] > mid:
+            r = mid - 1
+        elif arr[mid] == mid:
+            return mid
+        else:  # arr[mid] < mid
+            l = mid + 1
+    return -1
 
 
 @enable_executor_hook

elements-of-programming-interviews/python/search_first_key.py

@@ -3,12 +3,79 @@
 from test_framework import generic_test
 
 
+"""
+Approaches
+- Linear search
+- Binary search to first element, linear search
+  left from there.
+- Modified binary search?
+"""
+
+import random
+
+
+def linear_search(A: List[int], k: int) -> int:
+    i = 0
+    while i < len(A):
+        if A[i] == k:
+            return i
+        i += 1
+    return -1
+
+
+def bin_then_linear_search(A: List[int], k: int) -> int:
+    l, r = 0, len(A)-1
+    while l <= r:
+        m = (l+r) // 2
+        if A[m] > k:
+            r = m-1
+        elif A[m] < k:
+            l = m+1
+        elif A[m] == k:
+            while m > 0 and A[m-1] == k:
+                m -= 1
+            return m
+    return -1
+
+
 def search_first_of_k(A: List[int], k: int) -> int:
-    # TODO - you fill in here.
-    return 0
+    if not A:
+        return -1
+    l, r = 0, len(A)-1
+    m = -1
+    while l < r:
+        m = (l+r) // 2
+        if A[m] > k:
+            r = m-1
+        elif A[m] == k:
+            r = m
+        else:  # A[m] < k:
+            l = m+1
+    return -1 if A[l] != k else l
+
+
+def binary_search(A: List[int], k: int) -> int:
+    l, r = 0, len(A)-1
+    while l <= r:
+        # l + r can overflow, but not in Python
+        m = l + ((r-l) // 2)
+        if A[m] > k:
+            r = m-1
+        elif A[m] == k:
+            return m
+        else:  # A[m] < k:
+            l = m+1
+    return -1
 
 
 if __name__ == '__main__':
+    """
+    arr = sorted([random.randint(-100, 100) for _ in range(random.randint(0, 100))])
+    k = arr[random.randint(0, len(arr)-1)]
+    expected = linear_search(arr, k)
+    actual = search_first_of_k(arr, k)
+    assert expected == actual, f"{actual} != {expected}\nk = {k}\n{arr}"
+    """
     exit(
         generic_test.generic_test_main('search_first_key.py',
                                        'search_first_key.tsv',

elements-of-programming-interviews/python/search_row_col_sorted_matrix.py

@@ -3,9 +3,20 @@
 from test_framework import generic_test
 
 
-def matrix_search(A: List[List[int]], x: int) -> bool:
-    # TODO - you fill in here.
-    return True
+def matrix_search(A: List[List[int]], tgt: int) -> bool:
+    y = 0
+    x = len(A[0])-1
+
+    while y < len(A) and x >= 0:
+        curr = A[y][x]
+        if curr == tgt:
+            return True
+        elif curr > tgt:
+            x -= 1
+        else:  # curr < tgt
+            y += 1
+
+    return False
 
 
 if __name__ == '__main__':

elements-of-programming-interviews/python/search_shifted_sorted_array.py

@@ -2,10 +2,32 @@
 
 from test_framework import generic_test
 
+"""
+- In sorted array, arr[0] is smallest element 
+- Rotating the array moves smallest elsewhere. 
+- If arr[l] > arr[r], the smallest is somewhere in the middle. 
+
+[9,0,1,2,3,4,5,6,7,8] 
+"""
+
 
 def search_smallest(A: List[int]) -> int:
-    # TODO - you fill in here.
-    return 0
+    l, r = 0, len(A)-1
+    if A[l] <= A[r]:
+        return 0
+
+    # if l == r, we found the only candidate
+    while l < r:
+        m = l + ((r-l) // 2)
+
+        if A[m] > A[r]:
+            # A[m] is definitely not the minimum element.
+            l = m+1
+        else:
+            # A[m] <= A[r]; A[m] might be the
+            # min element, but we don't know yet.
+            r = m
+    return l
 
 
 if __name__ == '__main__':