Two Sum Less Than K - Practice Coding Problems

Two Sum Less Than K - Problem

Imagine you're at a casino with a limited budget! 🎰 Given an array nums of integers and an integer k, you need to find two different numbers whose sum is as close to k as possible, but strictly less than k.

Your task is to return the maximum sum such that there exists i < j with nums[i] + nums[j] = sum and sum < k. If no such pair exists, return -1.

Example: If nums = [34,23,1,24,75,33,54,8] and k = 60, you want to find the pair that gives you the highest sum without going over 60. The answer would be 58 (from 34 + 24).

Input & Output

example_1.py — Basic Case

$ Input: nums = [34,23,1,24,75,33,54,8], k = 60

› Output: 58

💡 Note: We can choose the pair (34, 24) which gives us 34 + 24 = 58 < 60. This is the maximum possible sum less than 60.

example_2.py — Small Array

$ Input: nums = [10,20,30], k = 15

› Output: -1

💡 Note: No pair of numbers can sum to less than 15. The smallest possible sum is 10 + 20 = 30, which is ≥ 15.

example_3.py — Edge Case

$ Input: nums = [1,1,1,1], k = 3

› Output: 2

💡 Note: Any pair of 1's will give us 1 + 1 = 2 < 3. Since all pairs have the same sum, we return 2.

Visualization

Tap to expand

Understanding the Visualization

Sort your chips by value

Arrange all chips from lowest to highest value for systematic selection

Use two-ended selection

Start with cheapest and most expensive chips available

Adjust selection intelligently

If total is under budget, try more expensive cheap chip. If over budget, try cheaper expensive chip

Track best combination

Remember the highest valid combination found during the process

Key Takeaway

🎯 Key Insight: Sorting enables intelligent navigation - when sum is too high, we need a smaller number (move right pointer left), when sum is too low, we need a larger number (move left pointer right). This systematic approach guarantees we find the optimal solution efficiently.

Time & Space Complexity

Time Complexity

⏱️

O(n log n)

Sorting takes O(n log n), and the two-pointer traversal takes O(n)

⚡ Linearithmic

Space Complexity

O(1)

Only using constant extra space (if we sort in-place)

✓ Linear Space

Constraints

1 ≤ nums.length ≤ 100
1 ≤ nums[i] ≤ 1000
1 ≤ k ≤ 2000
Must find exactly two different elements (i < j)

Asked in

a Amazon 45 G Google 38 ⊞ Microsoft 32 f Meta 28

The optimal approach uses sorting + two pointers technique. After sorting the array, use two pointers from both ends and move them based on the current sum: if sum < k, try to increase by moving left pointer right; if sum ≥ k, decrease by moving right pointer left. This achieves O(n log n) time complexity.

Common Approaches

Approach	Time	Space	Notes
✓ Two Pointers (Sorted Array)	O(n log n)	O(1)	Sort array and use two pointers from both ends to efficiently find the maximum sum
Brute Force (Nested Loops)	O(n²)	O(1)	Check every possible pair of numbers to find the maximum sum less than k
Sorting + Binary Search	O(n log n)	O(1)	Sort array, then for each element, binary search for the best complement

Two Pointers (Sorted Array) — Algorithm Steps

Sort the array in ascending order
Initialize left pointer at index 0, right pointer at last index
Initialize maxSum to -1
While left < right:
Calculate sum = nums[left] + nums[right]
If sum < k: update maxSum if sum is larger, move left pointer right
Otherwise: move right pointer left
Return maxSum

Visualization

Tap to expand

Step-by-Step Walkthrough

Sort the array

Arrange elements in ascending order

Initialize pointers

Place left at start, right at end

Move pointers based on sum

Move left right if sum < k, move right left if sum >= k

Code -

solution.c — C

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

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

int max(int a, int b) {
    return (a > b) ? a : b;
}

int twoSumLessThanK(int* nums, int numsSize, int k) {
    qsort(nums, numsSize, sizeof(int), compare);
    int left = 0, right = numsSize - 1;
    int maxSum = -1;
    
    while (left < right) {
        int currentSum = nums[left] + nums[right];
        if (currentSum < k) {
            maxSum = max(maxSum, currentSum);
            left++;
        } else {
            right--;
        }
    }
    
    return maxSum;
}

int main() {
    int nums[] = {34, 23, 1, 24, 75, 33, 54, 8};
    int k = 60;
    int size = sizeof(nums) / sizeof(nums[0]);
    printf("%d\n", twoSumLessThanK(nums, size, k));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n log n)

Sorting takes O(n log n), and the two-pointer traversal takes O(n)

⚡ Linearithmic

Space Complexity

O(1)

Only using constant extra space (if we sort in-place)

✓ Linear Space

Constraints

1 ≤ nums.length ≤ 100
1 ≤ nums[i] ≤ 1000
1 ≤ k ≤ 2000
Must find exactly two different elements (i < j)

58.2K Views

Medium Frequency

~15 min Avg. Time

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

Two Pointers (Sorted Array) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler