Find the one pair of values in a sorted array that adds up to a target, returning their 1-based positions. Try it free and read the solution.

Two Sum II - Input Array Is Sorted

Koko Eating Bananas

Reverse Words in a String

Find the one pair of values in a sorted array that adds up to a target, returning their 1-based positions.

Given a **1-indexed** array of integers `numbers` that is already sorted in non-decreasing order, find two distinct numbers that add up to a specific `target`.

Return the positions of the two numbers, `index1` and `index2`, **added by one** (so they are 1-based), as an array `[index1, index2]` with `index1 < index2`.

The tests are generated so that there is **exactly one solution**, and you may not use the same element twice.

**Input / output**
- Input: `numbers: int[]` (sorted, 1-indexed), `target: int`
- Output: `int[]` of length 2 — the two 1-based positions, smaller first

## Examples
```
Input: {"numbers":[2,7,11,15],"target":9}
Output: [1,2]
```

```
Input: {"numbers":[2,3,4],"target":6}
Output: [1,3]
```

```
Input: {"numbers":[-1,0],"target":-1}
Output: [1,2]
```

## Constraints
- `2 <= numbers.length <= 30000`
- `-1000 <= numbers[i] <= 1000`
- `numbers` is sorted in non-decreasing order.
- `-2000 <= target <= 2000`
- Exactly one valid answer exists.

## Follow-up
Can you solve it using only `O(1)` extra space? The sorted order is the key that lets you avoid the hash map needed for the unsorted Two Sum.

- The unsorted Two Sum needs a hash map, but here the array is already sorted.
- A sorted array lets two converging pointers decide, in one comparison, whether the current pair is too small or too large.
- Remember the required output is **1-based**, so add one to each final index.

Use the sorted order

- Start `lo` at the first element and `hi` at the last.
- If `numbers[lo] + numbers[hi]` equals the target, you found the unique answer.
- If the sum is too small, the only way to grow it is to move `lo` right; if it is too large, move `hi` left.

Converge two pointers

- If the sum is too small, every pair using the current `lo` with a smaller `hi` is even smaller, so `lo` can never pair with anything left of `hi` — safe to advance `lo`.
- The symmetric argument justifies decrementing `hi`.
- Because exactly one answer exists, the pointers are guaranteed to meet it before crossing.

Why moving a pointer never skips the answer

- Checking every pair also works and needs no extra space, but costs `O(n^2)` time.
- It is a useful correctness reference for the two-pointer version.

Brute-force baseline

- Walk the two pointers toward each other, returning the 1-based indices on a match.
- Time is `O(n)` and extra space is `O(1)`.

Optimal two-pointer solution

- Returning 0-based indices instead of adding one for the 1-based contract.
- Returning `[hi + 1, lo + 1]` — the smaller index must come first.
- Using a nested loop when the sorted input makes the linear scan available.