leetcode/apps/docs/content/(01-linear-structures)/two-pointers/167-two-sum-ii-input-array-is-sorted.mdx

---
title: '167. Two Sum II - Input Array Is Sorted'
description: 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[index1] and numbers[index2] where 1 <= index1 < index2 <= numbers.length
icon: dot
topics:
  - { name: "Array", slug: "array" }
  - { name: "Two Pointers", slug: "two-pointers" }
  - { name: "Binary Search", slug: "binary-search" }
video: "cQ1Oz4ckceM"
issue: "https://github.com/prdlk/leetcode/issues/42"
sidebar:
  label: 'Two Sum II - Input Array Is Sorted'
  badge: 'Medium'
---

::::warning
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, `index1 = 1`, `index2 = 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 `index1 = 1`, `index2 = 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 `index1 = 1`, `index2 = 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.

## Approach

```mermaid
flowchart TD
  S(["twoSum(numbers, target)"]) --> I["i = 0, j = len - 1"]
  I --> W{"i < j?"}
  W -- no --> E(["return []"])
  W -- yes --> C["c = numbers[i] + numbers[j]"]
  C --> Q{"c vs target"}
  Q -- equal --> R(["return [i+1, j+1] — 1-indexed"])
  Q -- "c < target" --> L["i += 1 — grow the sum"]
  L --> W
  Q -- "c > target" --> H["j -= 1 — shrink the sum"]
  H --> W
```

## Solution

```py
class Solution:
    def twoSum(self, numbers: List[int], target: int) -> List[int]:
        i = 0
        j = len(numbers) - 1

        while i < j:
            c = numbers[i] + numbers[j]
            if c == target:
                return [i + 1, j + 1]
            elif c < target:
                i+=1
            else:
                j-=1
        return []
```