## Challenge Statement

- 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. - This challenge corresponds to LeetCode #704.

### 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.

**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
```

**Example 3:**

```
Input: head = []
Output: []
```

## Solution

Below is my solution and some test cases. This solution has a** logarithmic time complexity O(log n) and a constant space complexity O(1)**, where n is the length of the input list*.*