3Sum Smaller - Practice Coding Problems

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.py — 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.py — 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.py — All Negative Numbers

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

› Output: 2

💡 Note: Valid triplets are: (-5, -3, -2) with sum -10 < -5, and (-5, -3, -1) with sum -9 < -5. Count = 2.

Visualization

Tap to expand

Understanding the Visualization

Sort by Cost

Arrange people by their salary costs: [-2, 0, 1, 3]

Fix Team Leader

Choose team leader (first person), then find pairs for remaining budget

Two Pointer Search

Use two pointers to efficiently find all valid team combinations

Count in Bulk

When we find one valid team, count all teams with same leader and assistant but different specialists

Key Takeaway

🎯 Key Insight: After sorting by cost, when we find one valid team, we can count multiple teams in bulk by leveraging the sorted order - if person X works as the third member, everyone cheaper than X also works!

Time & Space Complexity

Time Complexity

⏱️

O(n² log n)

O(n log n) for sorting plus O(n²) for nested loops, each doing O(log n) binary search

⚠ Quadratic Growth

Space Complexity

O(1)

Only using constant extra space besides the input array

✓ Linear Space

Constraints

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

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
✓ 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)	O(n²)	O(1) or O(n)	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 — Algorithm Steps

Sort the array to enable binary search
For each pair (i, j) where i < j, calculate the required sum for third element
Use binary search to find the rightmost position where elements are less than required
Count all valid positions and add to total
Return the final count

Visualization

Tap to expand

Step-by-Step Walkthrough

Fix Two Elements

Choose i=0, j=1: nums[0]=-2, nums[1]=0

Calculate Need

need = target - nums[i] - nums[j] = 2 - (-2) - 0 = 4

Binary Search

Find rightmost position where element < 4

Count Valid

Count all valid positions from j+1 to found position

Code -

solution.c — C

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

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

int binarySearch(int* arr, int left, int right, int x) {
    int result = -1;
    while (left <= right) {
        int mid = left + (right - left) / 2;
        if (arr[mid] < x) {
            result = mid;
            left = mid + 1;
        } else {
            right = mid - 1;
        }
    }
    return result;
}

int threeSumSmaller(int* nums, int numsSize, int target) {
    qsort(nums, numsSize, sizeof(int), compare);  // Sort the array
    int count = 0;
    
    for (int i = 0; i < numsSize - 2; i++) {
        for (int j = i + 1; j < numsSize - 1; j++) {
            int need = target - nums[i] - nums[j];
            int pos = binarySearch(nums, j + 1, numsSize - 1, need);
            if (pos != -1) {
                count += pos - j;
            }
        }
    }
    
    return count;
}

int main() {
    int nums[] = {-2, 0, 1, 3};
    int target = 2;
    printf("%d\n", threeSumSmaller(nums, 4, target));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n² log n)

O(n log n) for sorting plus O(n²) for nested loops, each doing O(log n) binary search

⚠ Quadratic Growth

Space Complexity

O(1)

Only using constant extra space besides the input array

✓ Linear Space

Constraints

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

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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Binary Search Approach — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler