Codestin Search App

3Sum Smaller - Problem

3Sum Smaller is a challenging array problem that asks you to count triplets with a sum below a target threshold.

You're given an array of n integers nums and a target integer. Your task is to find the total count of index triplets (i, j, k) where:

0 ≤ i < j < k < n (distinct indices in ascending order)
nums[i] + nums[j] + nums[k] < target

For example, with nums = [-2, 0, 1, 3] and target = 2, the valid triplets are (-2, 0, 1) and (-2, 0, 3), giving us a count of 2.

Note: We only count the number of valid triplets, not the triplets themselves.

Input & Output

Example 1 — Basic Case

$ Input: nums = [-2, 0, 1, 3], target = 2

› Output: 2

💡 Note: The two valid triplets are: (-2, 0, 1) with sum -1 < 2, and (-2, 0, 3) with sum 1 < 2. Total count = 2.

Example 2 — No Valid Triplets

$ Input: nums = [3, 4, 5, 6], target = 10

› Output: 0

💡 Note: The smallest possible sum is 3 + 4 + 5 = 12, which is greater than target = 10. No valid triplets exist.

Example 3 — All Negative Numbers

$ Input: nums = [-5, -3, -2, -1], target = -5

› Output: 4

💡 Note: All 4 triplets have sum < -5: (-5,-3,-2)=-10, (-5,-3,-1)=-9, (-5,-2,-1)=-8, (-3,-2,-1)=-6. Count = 4.

Constraints

1 ≤ nums.length ≤ 100
-100 ≤ nums[i] ≤ 100
-100 ≤ target ≤ 100
The array contains at least 3 elements

Visualization

Tap to expand

Understanding the Visualization

Sort Array

Arrange elements in ascending order: [-2, 0, 1, 3]

Fix First Element

Choose first element (i=0), set left=i+1 and right=n-1

Two Pointer Search

Use two pointers to efficiently find all valid pairs

Count in Bulk

When sum < target, count += (right - left), then move left pointer

Key Takeaway

🎯 Key Insight: After sorting, when we find one valid triplet with sum < target, we can count multiple triplets at once! If nums[i] + nums[left] + nums[right] < target, then all elements between left and right also form valid triplets with nums[i] and nums[left].

Asked in

f Facebook 45 G Google 38 a Amazon 32 ⊞ Microsoft 28 Apple 22

The optimal solution uses the two pointers technique after sorting the array. For each fixed first element, we use two pointers to efficiently count all valid triplets in O(n²) time. The key insight is that when we find a valid triplet, all elements between our pointers also form valid combinations, allowing us to count multiple triplets at once.

Common Approaches

Approach	Time	Space	Notes
✓ Two Pointers (Optimal)	O(n²)	O(1)	Sort array first, then use two pointers technique for efficient counting
Brute Force (Triple Nested Loops)	O(n³)	O(1)	Check every possible triplet combination with three nested loops
Binary Search Approach	O(n² log n)	O(1)	Sort array, then for each pair use binary search to count valid third elements

Two Pointers (Optimal) — Algorithm Steps

Sort the array to enable two-pointer technique
For each element as the first element of triplet (i from 0 to n-3)
Set left pointer to i+1 and right pointer to n-1
While left < right: if sum < target, count all valid triplets and move left; else move right
Return total count

Visualization

Tap to expand

Step-by-Step Walkthrough

Sort Array

First sort: [-2, 0, 1, 3]

Fix First Element

i=0 (nums[0]=-2), left=1, right=3

Check Sum

If sum < target, count all valid combinations

Move Pointers

Adjust pointers based on sum comparison

Code -

solution.c — C

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

int compare(const void *a, const void *b) {
    return (*(int*)a - *(int*)b);
}

int threeSumSmaller(int* nums, int numsSize, int target) {
    qsort(nums, numsSize, sizeof(int), compare);
    int count = 0;
    
    for (int i = 0; i < numsSize - 2; i++) {
        int left = i + 1;
        int right = numsSize - 1;
        
        while (left < right) {
            int currentSum = nums[i] + nums[left] + nums[right];
            
            if (currentSum < target) {
                count += right - left;
                left++;
            } else {
                right--;
            }
        }
    }
    
    return count;
}

int parseArray(char *line, int *arr) {
    int count = 0;
    char *ptr = line;
    while (*ptr && *ptr != '[') ptr++;
    if (*ptr == '[') ptr++;
    while (*ptr) {
        while (*ptr && *ptr != '-' && (*ptr < '0' || *ptr > '9')) {
            if (*ptr == ']') return count;
            ptr++;
        }
        if (*ptr == ']' || *ptr == '\0') break;
        arr[count++] = atoi(ptr);
        if (*ptr == '-') ptr++;
        while (*ptr >= '0' && *ptr <= '9') ptr++;
    }
    return count;
}

int main() {
    char line1[10000], line2[10000];
    int nums[3000], numsSize = 0, target = 0;
    
    if (!fgets(line1, sizeof(line1), stdin)) return 0;
    if (!fgets(line2, sizeof(line2), stdin)) return 0;
    
    if (strchr(line1, '[')) {
        numsSize = parseArray(line1, nums);
        target = atoi(line2);
    } else {
        target = atoi(line1);
        numsSize = parseArray(line2, nums);
    }
    
    printf("%d\n", threeSumSmaller(nums, numsSize, target));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

O(n log n) for sorting plus O(n²) for the nested loops with two pointers

⚠ Quadratic Growth

Space Complexity

O(1)

O(1) extra space if sorting in place

✓ Linear Space

42.6K Views

Medium-High Frequency

~25 min Avg. Time

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

Two Pointers (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler