Search Insert Position


Given a sorted array, nums, and a value, target, return the index if the target is found. Otherwise, return the index where it would be if it were inserted in order.

You may assume no duplicates in the array.

Example 1:

nums   = [1,3,5,6]
target = 5

return 2

Example 2:

nums   = [1,3,5,6]
target = 2

return 1

Solution A

When reading an algorithm prompt, pay attention if an input is a sorted list. Usually this means we can use some tricks so we don’t have to check all the values of the list.

In this case, we only need to know where to insert our target. If we check a value in the middle of the list, we know whether target should be in the bottom half or the top half of the list. We do not need to check any other values, and can ignore the other half of the list entirely!

In this solution we store a l_i (left index) and r_i (right index). These represent the index range of a subsection of our nums list. At first, this is the entire list range. But as we continue to check the values between these indexes, we update either l_i or r_i to narrow in on the location of the list where we expect to find our target.

from typing import List

def search_insert(nums:List[int], target:int) -> int:
  l_i = 0
  r_i = len(nums) - 1

  # first check if `target` is even in the range of `nums` values
  if target < nums[l_i]:
    return 0  # insert at start if target < minimum
  elif nums[r_i] < target:
    return len(nums)  # insert at end if target > maximum

  while True:
    # Check if we found our target at l_i
    if nums[l_i] == target:
      return l_i

    # Check if we found our target at r_i
    elif nums[r_i] == target:
      return r_i

    # If `l_i` and `r_i` are consecutive integers the `target` is not
    # at either position already (checked above), then we know
    # the `target` must go between these values. We use a Python
    # trick to add integer `l_i` to a boolean to figure out where.
    elif r_i - l_i == 1:
      return l_i + (target > nums[l_i])

    # If the above checks fail, we get the middle position between
    # `l_i` and `r_i`, and check whether our `target` should be less
    # than or greater than the middle value. Then we update either `l_i`
    # or `r_i` to narrow down the search, and we return to the top
    # of the `While` loop above.
      mid_i = (l_i + r_i) // 2
      if nums[mid_i] <= target:
        l_i = mid_i
        r_i = mid_i

Solution B

Python actually includes a module, bisect, in the standand library that contains an algorithm for this solution. If you know about it, definitely mention that in an interview! The solution would be:

import bisect.bisect_left

def search_insert(nums, target):
  return bisect.bisect_left(nums, target)

However, we still need to write the algorithm itself in an interview. Below is the algorithm used by bisect.bisect_left, with minor modifications for our problem. This algorithm performs the same as Solution A.

def search_insert(nums, target):
  lo = 0
  hi = len(nums)

  while lo < hi:
    mid = (lo + hi) // 2
    if nums[mid] < target:
      lo = mid+1
      hi = mid

  return lo


Comment on GitHub