You are 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.

Return the indices of the two numbers, index1 and index2, as a integer array [index1, index2] of length 2.

You may assume that each input would have exactly one solution, and 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 index1 = 1, index2 = 2. 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. 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. Return [1, 2].

Constraints:

• 2 <= numbers.length <= 3 * 10<sup>4</sup>
• -1000 <= numbers[i] <= 1000
• numbers is sorted in non-decreasing order.
• -1000 <= target <= 1000
• Exactly one valid answer exists.

Since the input array is already sorted, we can use a two-pointer approach. Initialize left to the first element (index 0) and right to the last element (index numbers.size() - 1). At each step, compare the sum numbers[left] + numbers[right] with target:

• If the sum is less than target, encrement left to increase the sum.
• If the sum is greater than target, decrement right to decrease the sum.
• If the sum equals target, we have found the answer.

This works because the array is sorted. When the sum is too small, moving left forward is the only way to increase the sum while keeping right fixed; similarly, when the sum is too large, decreasing right reduces the sum. The algorithm guarantees that the correct pair will be found before the pionters cross. Since indices are 1-based in the output, add 1 to both left and right before returning.

Below is an implementation in C++:

class Solution {
public:
   vector<int> twoSum(vector<int>& numbers, int target) {
       int low = 0, high = numbers.size() - 1;
       while (low < high) {
           int sum = numbers[low] + numbers[high];
           if (sum < target) {
               ++low;
           } else if (sum > target) {
               --high;
           } else {
               return {low + 1, high + 1};
           }
       }
       // Execution should never reach here because a solution is guaranteed.
       return {};
   }
};