# 167. Two Sum II - Input Array Is Sorted

# Problem

Given a **1-indexed** array of integers `numbers`

that is already ** sorted in non-decreasing order**, find two numbers such that they add up to a specific

`target`

number. Let these two numbers be `numbers[index`_{1}]

and `numbers[index`_{2}]

where `1 <= index`_{1} < index_{2} <= numbers.length

.Return* the indices of the two numbers, *`index`

_{1}* and *`index`

_{2}*, added by one as an integer array *

`[index`_{1}, index_{2}]

*of length 2.*

The tests are generated such that there is **exactly one solution**. You **may not** use the same element twice.

Your solution must use only constant extra space.

**Example 1:**

**Input:** numbers = [__2__,__7__,11,15], target = 9 **Output:** [1,2] **Explanation:** The sum of 2 and 7 is 9. Therefore, index_{1} = 1, index_{2} = 2. We return [1, 2].

**Example 2:**

**Input:** numbers = [__2__,3,__4__], target = 6 **Output:** [1,3] **Explanation:** The sum of 2 and 4 is 6. Therefore index_{1} = 1, index_{2} = 3. We return [1, 3].

**Example 3:**

**Input:** numbers = [__-1__,__0__], target = -1 **Output:** [1,2] **Explanation:** The sum of -1 and 0 is -1. Therefore index_{1} = 1, index_{2} = 2. We return [1, 2].

**Constraints:**

`2 <= numbers.length <= 3 * 10`

^{4}`-1000 <= numbers[i] <= 1000`

`numbers`

is sorted in**non-decreasing order**.`-1000 <= target <= 1000`

- The tests are generated such that there is
**exactly one solution**.

# Solution

```
class Solution(object):
def twoSum(self, numbers, target):
"""
:type numbers: List[int]
:type target: int
:rtype: List[int]
"""
low = 0
high = len(numbers) - 1
# kinda like binary search
while low < high:
# this is our summation result
result = numbers[low] + numbers[high]
if result == target:
# because arrays are 0-indexed
# we need to + 1 to both indices to represent their position
# in the array
return [low + 1, high + 1]
elif result < target:
low += 1
else:
high -= 1
# Just in case
return [-1, -1]
```