## 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 = 9Output:[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 = 6Output:[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 = -1Output:[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

First attempt : Brute force (Can be optimized further)

```
/**
* @param {number[]} numbers
* @param {number} target
* @return {number[]}
*/
var twoSum = function(numbers, target) {
let output = [];
for(let i = 0; i <numbers.length ; i++){
for(let k = i+1; k < numbers.length; k++){
if((numbers[i] + numbers[k]) == target){
output.push(i+1,k+1);
break;
}
}
}
return output;
};
```

Second attempt : Two pointer method

```
/**
* @param {number[]} numbers
* @param {number} target
* @return {number[]}
*/
var twoSum = function(numbers, target) {
let output = [];
let leftPointer = 0;
let rightPointer = numbers.length - 1;
while(rightPointer > leftPointer){
let sum = numbers[rightPointer] + numbers[leftPointer];
if(sum == target){
return [leftPointer+1, rightPointer+1]
}
else if( sum > target){
rightPointer--;
}
else{
leftPointer++;
}
}
return output;
};
```

A freelance web developer with a decade of experience in creating high-quality, scalable web solutions. His expertise spans PHP, WordPress, Node.js, MySQL, MongoDB, and e-commerce development, ensuring a versatile approach to each project. Aadi’s commitment to client satisfaction is evident in his track record of over 200 successful projects, marked by innovation, efficiency, and a customer-centric philosophy.

As a professional who values collaboration and open communication, Aadi has built a reputation for delivering projects that exceed expectations while adhering to time and budget constraints. His proactive and problem-solving mindset makes him an ideal partner for anyone looking to navigate the digital landscape with a reliable and skilled developer.