# Leetcode Two Sum II - Input array is sorted problem solution

In this Leetcode Two Sum II - Input array is sorted problem solution we have Given an array of integers numbers that are already sorted in non-decreasing order, find two numbers such that they add up to a specific target number.

Return the indices of the two numbers (1-indexed) as an integer array answer of size 2, where 1 <= answer[0] < answer[1] <= numbers.length. The tests are generated such that there is exactly one solution. You may not use the same element twice.

## Problem solution in Python.

```class Solution(object):
def twoSum(self, numbers, target):
tail = len(numbers) - 1
while numbers[head] + numbers[tail] != target:
if numbers[head] + numbers[tail] > target:
tail -= 1
else:
return [head + 1, tail + 1]
```

## Problem solution in Java.

```class Solution {
public int[] twoSum(int[] numbers, int target) {
int[]a=new int[2];
int start=0,end=numbers.length-1;
while(start<end)
{
if(numbers[start]+numbers[end]==target)
{
return new int[]{start+1,end+1};

}
else  if(numbers[start]+numbers[end]>target)
{
end--;
}
else

{
start++;
}

}
return new int[2];

}
}
```

## Problem solution in C++.

```class Solution
{
public:
vector<int> twoSum(vector<int>& numbers, int target)
{
int start = 0, end = (numbers.size() - 1);
while (start < end)
{
if ((numbers[start] + numbers[end]) > target) end--;
else if ((numbers[start] + numbers[end]) < target) start++;
else return {++start, ++end};
}
return {};
}
};
```

## Problem solution in C.

```int* twoSum(int* numbers, int numbersSize, int target, int* returnSize){

while(i<j){
sum = numbers[i]+numbers[j];
if(sum<target) i++;
else if(sum>target) j--;
else break;
}

int *dst = (int*)malloc(2*sizeof(int));
dst[0]=i+1;
dst[1]=j+1;
*returnSize=2;
return dst;
}
```