Two Sum II - Input Array Is Sorted

Two Sum II - Input Array Is Sorted - 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[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.

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.

Input & Output

Example 1 — Basic Case

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

› Output: [1,2]

💡 Note: numbers[1] + numbers[2] = 2 + 7 = 9, so return indices [1,2] in 1-indexed format

Example 2 — Later Position

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

› Output: [1,3]

💡 Note: numbers[1] + numbers[3] = 2 + 4 = 6, indices are [1,3] in 1-indexed format

Example 3 — Minimum Size

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

› Output: [1,2]

💡 Note: numbers[1] + numbers[2] = -1 + 0 = -1, return [1,2] for minimum array size

Constraints

2 ≤ numbers.length ≤ 3 × 10⁴
-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

Visualization

Tap to expand

Asked in

a Amazon 45 M Microsoft 38 A Apple 32 G Google 28

The key insight is leveraging the sorted property with two pointers. Start from both ends and move pointers based on sum comparison. Two pointers approach is optimal: Time O(n), Space O(1).

Common Approaches

✓ Brute Force

⏱️ Time: O(n²) Space: O(1)

Try every combination of two numbers in the array to see if they sum to the target. Since we need 1-indexed results, add 1 to both indices before returning.

Hash Map

⏱️ Time: O(n) Space: O(n)

Use a hash map to store each number and its index as we iterate. For each number, check if (target - current number) exists in the map. This gives us O(n) time but uses extra space.

Two Pointers

⏱️ Time: O(n) Space: O(1)

Since the array is sorted, use two pointers: one at the beginning and one at the end. If the sum is less than target, move left pointer right. If sum is greater than target, move right pointer left. This achieves O(n) time with O(1) space.

Brute Force — Algorithm Steps

Iterate through each element as first number
For each first number, iterate through remaining elements as second number
Check if sum equals target, return 1-indexed positions

Visualization

Tap to expand

Step-by-Step Walkthrough

Start

Check first element with all others

Continue

Check second element with remaining

Found

Return 1-indexed positions when sum matches

Code -

solution.c — C

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

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

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    // Parse array - remove brackets and parse numbers
    int numbers[1000];
    int numbersSize = 0;
    
    // Find the content between [ and ]
    char* start = strchr(line, '[');
    char* end = strchr(line, ']');
    if (start && end && start < end) {
        start++; // Skip '['
        *end = '\0'; // Terminate at ']'
        
        char* token = strtok(start, ",");
        while (token != NULL) {
            numbers[numbersSize++] = atoi(token);
            token = strtok(NULL, ",");
        }
    }
    
    int target;
    scanf("%d", &target);
    
    int returnSize;
    int* result = solution(numbers, numbersSize, target, &returnSize);
    
    printf("[");
    for (int i = 0; i < returnSize; i++) {
        printf("%d", result[i]);
        if (i < returnSize - 1) printf(",");
    }
    printf("]\n");
    
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

Nested loops iterate through all pairs, n×(n-1)/2 comparisons

⚠ Quadratic Growth

Space Complexity

O(1)

Only using constant extra variables for loop counters

✓ Linear Space

185.0K 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

Constraints

Visualization

Related Problems

Common Approaches

Brute Force — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler