Two Sum II - Input Array Is Sorted - Practice Coding Problems

Two Sum II - Input Array Is Sorted - Problem

You're given a sorted array of integers and need to find two numbers that add up to a specific target. This is a classic problem that tests your ability to leverage the sorted property of the input.

Given a 1-indexed array 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, added by one as an integer array [index1, index2] of length 2.

Key constraints:

The tests guarantee that there is exactly one solution
You may not use the same element twice
Your solution must use only constant extra space

Example: If numbers = [2,7,11,15] and target = 9, return [1,2] because numbers[1] + numbers[2] = 2 + 7 = 9.

Input & Output

example_1.py — Basic Case

$ Input: numbers = [2,7,11,15], target = 9

› Output: [1,2]

💡 Note: The sum of 2 and 7 is 9. Since we are looking for 1-indexed positions, we return [1,2].

example_2.py — Middle Elements

$ Input: numbers = [2,3,4], target = 6

› Output: [1,3]

💡 Note: The sum of 2 and 4 is 6. The 1-indexed positions are [1,3].

example_3.py — Adjacent Elements

$ Input: numbers = [-1,0], target = -1

› Output: [1,2]

💡 Note: The sum of -1 and 0 is -1. The 1-indexed positions are [1,2].

Visualization

Tap to expand

Understanding the Visualization

Setup

Place one pointer at the smallest element (left) and another at the largest (right)

Calculate

Add the values at both pointers and compare with target

Adjust

If sum is too small, move left pointer right (increase). If too large, move right pointer left (decrease)

Success

When sum equals target, we've found our answer!

Key Takeaway

🎯 Key Insight: The sorted property allows us to make intelligent decisions about which pointer to move, converging to the solution in linear time without extra space!

Time & Space Complexity

Time Complexity

⏱️

O(n²)

We potentially check every pair of elements, leading to n×(n-1)/2 comparisons

⚠ Quadratic Growth

Space Complexity

O(1)

Only using a few variables, no additional data structures

✓ Linear Space

Constraints

2 ≤ numbers.length ≤ 3 * 10⁴
-1000 ≤ numbers[i] ≤ 1000
-1000 ≤ target ≤ 1000
The array is sorted in non-decreasing order
Exactly one solution exists
You cannot use the same element twice

Asked in

a Amazon 67 G Google 45 ⊞ Microsoft 38 f Meta 29

The optimal solution uses the two pointers technique to achieve O(n) time complexity with O(1) space. Since the array is sorted, we can start with pointers at both ends and move them strategically based on whether the current sum is greater than or less than the target, eliminating the need for additional data structures.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Nested Loops)	O(n²)	O(1)	Check all possible pairs of numbers until we find the target sum
Two Pointers (Optimal)	O(n)	O(1)	Use two pointers from both ends, moving based on sum comparison
Binary Search Approach	O(n log n)	O(1)	For each element, binary search for its complement in the remaining array

Brute Force (Nested Loops) — Algorithm Steps

Start with the first element
Check it against every element that comes after it
If any pair sums to target, return their 1-indexed positions
Continue until we find the solution

Visualization

Tap to expand

Step-by-Step Walkthrough

Start with first element

Begin with numbers[0] and check against all following elements

Check all pairs

For each element, check it with every element to its right

Find target sum

When sum equals target, return the 1-indexed positions

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>

int* twoSum(int* numbers, int numbersSize, int target, int* returnSize) {
    *returnSize = 2;
    int* result = (int*)malloc(2 * sizeof(int));
    
    for (int i = 0; i < numbersSize; i++) {
        for (int j = i + 1; j < numbersSize; j++) {
            if (numbers[i] + numbers[j] == target) {
                result[0] = i + 1; // Convert to 1-indexed
                result[1] = j + 1;
                return result;
            }
        }
    }
    return result; // Should never reach here
}

int main() {
    int numbers[] = {2, 7, 11, 15};
    int target = 9;
    int returnSize;
    int* result = twoSum(numbers, 4, target, &returnSize);
    printf("[%d, %d]\n", result[0], result[1]);
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

We potentially check every pair of elements, leading to n×(n-1)/2 comparisons

⚠ Quadratic Growth

Space Complexity

O(1)

Only using a few variables, no additional data structures

✓ Linear Space

Constraints

2 ≤ numbers.length ≤ 3 * 10⁴
-1000 ≤ numbers[i] ≤ 1000
-1000 ≤ target ≤ 1000
The array is sorted in non-decreasing order
Exactly one solution exists
You cannot use the same element twice

89.7K Views

High Frequency

~15 min Avg. Time

2.8K Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Brute Force (Nested Loops) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler