# 2022-05-15

### Description

Given an array of integers `nums` which is sorted in ascending order, and an integer `target`, write a function to search `target` in `nums`. If `target` exists, then return its index. Otherwise, return `-1`.
You must write an algorithm with `O(log n)` runtime complexity.
Example 1:
Input: nums = [-1,0,3,5,9,12], target = 9
Output: 4
Explanation: 9 exists in nums and its index is 4
Example 2:
Input: nums = [-1,0,3,5,9,12], target = 2
Output: -1
Explanation: 2 does not exist in nums so return -1
Constraints:
• `1 <= nums.length <= 10^4`
• `-10^4 < nums[i], target < 10^4`
• All the integers in `nums` are unique.
• `nums` is sorted in ascending order.

### Solution

func search(nums []int, target int) int {
low := 0
high := len(nums) - 1
for low <= high {
mid := (low + high) / 2
if nums[mid] == target {
return mid
}
if nums[mid] > target {
high = mid - 1
} else {
low = mid + 1
}
}
return -1
}

### Description

You are a product manager and currently leading a team to develop a new product. Unfortunately, the latest version of your product fails the quality check. Since each version is developed based on the previous version, all the versions after a bad version are also bad.
Suppose you have `n` versions `[1, 2, ..., n]` and you want to find out the first bad one, which causes all the following ones to be bad.
You are given an API `bool isBadVersion(version)` which returns whether `version` is bad. Implement a function to find the first bad version. You should minimize the number of calls to the API.
Example 1:
Input: n = 5, bad = 4
Output: 4
Explanation:
Then 4 is the first bad version.
Example 2:
Input: n = 1, bad = 1
Output: 1
Constraints:
• `1 <= bad <= n <= 2^31 - 1`

### Solution

#### Approach #0

/**
* Forward declaration of isBadVersion API.
* @return true if current version is bad
* false if current version is good
*/
low := 1
high := n
for low < high {
mid := (low + high) / 2
high = mid
continue
} else {
low = mid + 1
}
}
return high
}

#### Approach #1

Using package `sort`:
/**
* Forward declaration of isBadVersion API.
* @return true if current version is bad
* false if current version is good
*/
return sort.Search(n, func(version int) bool { return isBadVersion(version) }
}
In this problem, the giving constraints define the range of `n` will not over `2^31-1`. However, in the real world, the value of `mid` may probably overflow. The official sort package shows a way to avoid overflow when computing mid with `int(uint(i+j) >> 1)`.
Deep into the source code of `Search`, and we can know it also uses binary search:
package sort
// Search uses binary search to find and return the smallest index i
// in [0, n) at which f(i) is true, assuming that on the range [0, n),
// f(i) == true implies f(i+1) == true. That is, Search requires that
// f is false for some (possibly empty) prefix of the input range [0, n)
// and then true for the (possibly empty) remainder; Search returns
// the first true index. If there is no such index, Search returns n.
// (Note that the "not found" return value is not -1 as in, for instance,
// strings.Index.)
// Search calls f(i) only for i in the range [0, n).
//
// A common use of Search is to find the index i for a value x in
// a sorted, indexable data structure such as an array or slice.
// In this case, the argument f, typically a closure, captures the value
// to be searched for, and how the data structure is indexed and
// ordered.
//
// For instance, given a slice data sorted in ascending order,
// the call Search(len(data), func(i int) bool { return data[i] >= 23 })
// returns the smallest index i such that data[i] >= 23. If the caller
// wants to find whether 23 is in the slice, it must test data[i] == 23
// separately.
//
// Searching data sorted in descending order would use the <=
// operator instead of the >= operator.
//
// To complete the example above, the following code tries to find the value
// x in an integer slice data sorted in ascending order:
//
// x := 23
// i := sort.Search(len(data), func(i int) bool { return data[i] >= x })
// if i < len(data) && data[i] == x {
// // x is present at data[i]
// } else {
// // x is not present in data,
// // but i is the index where it would be inserted.
// }
//
// As a more whimsical example, this program guesses your number:
//
// func GuessingGame() {
// var s string
// fmt.Printf("Pick an integer from 0 to 100.\n")
// answer := sort.Search(100, func(i int) bool {
// fmt.Printf("Is your number <= %d? ", i)
// fmt.Scanf("%s", &s)
// return s != "" && s == 'y'
// })
// }
//
func Search(n int, f func(int) bool) int {
// Define f(-1) == false and f(n) == true.
// Invariant: f(i-1) == false, f(j) == true.
i, j := 0, n
for i < j {
h := int(uint(i+j) >> 1) // avoid overflow when computing h
// i ≤ h < j
if !f(h) {
i = h + 1 // preserves f(i-1) == false
} else {
j = h // preserves f(j) == true
}
}
// i == j, f(i-1) == false, and f(j) (= f(i)) == true => answer is i.
return i
}

## ​35. Search Insert Position​

### Description

Given a sorted array of distinct integers and a target value, return the index if the target is found. If not, return the index where it would be if it were inserted in order.
You must write an algorithm with `O(log n)` runtime complexity.
Example 1:
Input: nums = [1,3,5,6], target = 5
Output: 2
Example 2:
Input: nums = [1,3,5,6], target = 2
Output: 1
Example 3:
Input: nums = [1,3,5,6], target = 7
Output: 4
Constraints:
• `1 <= nums.length <= 10^4`
• `-10^4 <= nums[i] <= 10^4`
• `nums` contains distinct values sorted in ascending order.
• `-10^4 <= target <= 10^4`

### Solution

func searchInsert(nums []int, target int) int {
low, high := 0, len(nums)-1
for low <= high {
mid := int(uint(low+high) >> 1)
if nums[mid] == target {
return mid
}
if nums[mid] > target {
high = mid - 1
} else {
low = mid + 1
}
}
return low
}