Pair with largest sum which is less than K in the array
Last Updated :
31 Oct, 2022
Given an array arr of size N and an integer K. The task is to find the pair of integers such that their sum is maximum and but less than K
Examples:
Input : arr = {30, 20, 50} , K = 70
Output : 30, 20
30 + 20 = 50, which is the maximum possible sum which is less than K
Input : arr = {5, 20, 110, 100, 10}, K = 85
Output : 20, 10
Approach :
An efficient approach is to sort the given array and find the element which is greater than or equal to K. If found at index p, we have to find pairs only between arr[0, …, p-1]. Run nested loops. One to take care of the first element in the pair and the other to take care of the second element in the pair. Maintain a variable maxsum and two other variables a and b to keep track of the possible solution. Initialize maxsum to 0. Find A[i] + A[j] (assuming i runs in the outer loop and j in the inner loop). If it is greater than maxsum then update maxsum with this sum and change a and b to the i’th and j’th elements of this array.
Below is the implementation of the above approach :
C++
#include <bits/stdc++.h>
using namespace std;
void Max_Sum( int arr[], int n, int k)
{
int p = n;
sort(arr, arr + n);
for ( int i = 0; i < n; i++)
{
if (arr[i] >= k) {
p = i;
break ;
}
}
int maxsum = 0, a, b;
for ( int i = 0; i < p; i++)
{
for ( int j = i + 1; j < p; j++)
{
if (arr[i] + arr[j] < k and arr[i] + arr[j] >
maxsum)
{
maxsum = arr[i] + arr[j];
a = arr[i];
b = arr[j];
}
}
}
cout << a << " " << b;
}
int main()
{
int arr[] = {5, 20, 110, 100, 10}, k = 85;
int n = sizeof (arr) / sizeof (arr[0]);
Max_Sum(arr, n, k);
return 0;
}
|
Java
import java.util.Arrays;
class GFG
{
static void Max_Sum( int arr[], int n, int k)
{
int p = n;
Arrays.sort(arr);
for ( int i = 0 ; i < n; i++)
{
if (arr[i] >= k)
{
p = i;
break ;
}
}
int maxsum = 0 , a = 0 , b = 0 ;
for ( int i = 0 ; i < p; i++)
{
for ( int j = i + 1 ; j < p; j++)
{
if (arr[i] + arr[j] < k &&
arr[i] + arr[j] > maxsum)
{
maxsum = arr[i] + arr[j];
a = arr[i];
b = arr[j];
}
}
}
System.out.print( a + " " + b);
}
public static void main (String[] args)
{
int []arr = { 5 , 20 , 110 , 100 , 10 };
int k = 85 ;
int n = arr.length;
Max_Sum(arr, n, k);
}
}
|
Python3
def Max_Sum(arr, n, k):
p = n
arr.sort()
for i in range ( 0 , n):
if (arr[i] > = k):
p = i
break
maxsum = 0
a = 0
b = 0
for i in range ( 0 , p):
for j in range (i + 1 , p):
if (arr[i] + arr[j] < k and
arr[i] + arr[j] > maxsum):
maxsum = arr[i] + arr[j]
a = arr[i]
b = arr[j]
print (a, b)
arr = [ 5 , 20 , 110 , 100 , 10 ]
k = 85
n = len (arr)
Max_Sum(arr, n, k)
|
C#
using System;
class GFG
{
static void Max_Sum( int []arr, int n, int k)
{
int p = n;
Array.Sort(arr);
for ( int i = 0; i < n; i++)
{
if (arr[i] >= k)
{
p = i;
break ;
}
}
int maxsum = 0, a = 0, b = 0;
for ( int i = 0; i < p; i++)
{
for ( int j = i + 1; j < p; j++)
{
if (arr[i] + arr[j] < k &&
arr[i] + arr[j] > maxsum)
{
maxsum = arr[i] + arr[j];
a = arr[i];
b = arr[j];
}
}
}
Console.WriteLine( a + " " + b);
}
public static void Main ()
{
int []arr = {5, 20, 110, 100, 10};
int k = 85;
int n = arr.Length;
Max_Sum(arr, n, k);
}
}
|
Javascript
<script>
function Max_Sum(arr, n, k)
{
let p = n;
arr.sort( function (a, b){ return a - b});
for (let i = 0; i < n; i++)
{
if (arr[i] >= k)
{
p = i;
break ;
}
}
let maxsum = 0, a = 0, b = 0;
for (let i = 0; i < p; i++)
{
for (let j = i + 1; j < p; j++)
{
if (arr[i] + arr[j] < k &&
arr[i] + arr[j] > maxsum)
{
maxsum = arr[i] + arr[j];
a = arr[i];
b = arr[j];
}
}
}
document.write( a + " " + b + "</br>" );
}
let arr = [5, 20, 110, 100, 10];
let k = 85;
let n = arr.length;
Max_Sum(arr, n, k);
</script>
|
Time complexity: O(N^2)
Auxiliary Space: O(1)
Efficient Approach: Two Pointer Method
After sorting, we can place two pointers at the left and right extremes of the array. The desired pair can be found by the following steps:
- Find the current sum of the values at both the pointers.
- If the sum is lesser than k:
- update the answer with the maximum of the previous answer and the current sum.
- increase the left pointer.
- Else Decrease the right pointer.
C++
#include <bits/stdc++.h>
using namespace std;
int maxSum(vector< int > arr, int k)
{
sort(arr.begin(), arr.end());
int n = arr.size(), l = 0, r = n - 1, ans = 0;
while (l < r) {
if (arr[l] + arr[r] < k) {
ans = max(ans, arr[l] + arr[r]);
l++;
}
else {
r--;
}
}
return ans;
}
int main()
{
vector< int > A = { 20, 10, 30, 100, 110 };
int k = 85;
cout << maxSum(A, k) << endl;
}
|
Java
import java.util.Arrays;
class GFG
{
static int maxSum( int arr[], int k)
{
Arrays.sort(arr);
int n = arr.length, l = 0 , r = n - 1 , ans = 0 ;
while (l < r) {
if (arr[l] + arr[r] < k) {
ans = Math.max(ans, arr[l] + arr[r]);
l++;
}
else {
r--;
}
}
return ans;
}
public static void main (String[] args)
{
int []A = { 20 , 10 , 30 , 100 , 110 };
int k = 85 ;
System.out.print(maxSum(A, k));
}
}
|
Python3
def maxSum(arr, k):
arr.sort()
n,l = len (arr), 0
r,ans = n - 1 , 0
while (l < r):
if (arr[l] + arr[r] < k):
ans = max (ans, arr[l] + arr[r])
l + = 1
else :
r - = 1
return ans
A = [ 20 , 10 , 30 , 100 , 110 ]
k = 85
print (maxSum(A, k))
|
C#
using System;
class GFG
{
static int maxSum( int [] arr, int k)
{
Array.Sort(arr);
int n = arr.Length, l = 0, r = n - 1, ans = 0;
while (l < r) {
if (arr[l] + arr[r] < k) {
ans = Math.Max(ans, arr[l] + arr[r]);
l++;
}
else {
r--;
}
}
return ans;
}
public static void Main ()
{
int [] A = { 20, 10, 30, 100, 110 };
int k = 85;
Console.WriteLine(maxSum(A, k));
}
}
|
Javascript
<script>
function maxSum(arr, k)
{
arr.sort((a,b)=>a-b);
var n = arr.length, l = 0, r = n - 1, ans = 0;
while (l < r) {
if (arr[l] + arr[r] < k) {
ans = Math.max(ans, arr[l] + arr[r]);
l++;
}
else {
r--;
}
}
return ans;
}
var A = [20, 10, 30, 100, 110];
var k = 85;
document.write( maxSum(A, k));
</script>
|
Time complexity: O(NlogN)
Auxiliary Space: O(1)
Like Article
Suggest improvement
Share your thoughts in the comments
Please Login to comment...