Given an array A[] and a number x, check for pair in A[] with sum as x (aka Two Sum)

Create a programme that checks whether there are two entries in the array A[] whose total is exactly x given an array A[] of n numbers and another number x.

EXAMPLES

Example-1

Output:

Pair with a given sum -2 is (-3, 1)
 Valid pair exists

If we add the outputs, 1 + (-3) = -2 will result.

Example-2

Output:

No valid pair exists for 0

Method: Using simple logic by calculating the array's elements themselves.

CODE

Check for pairs in array A[] with sum as x in C++ given an array A[] and a number x.

// C++ program for the above approach
#include <bits/stdc++.h>

using namespace std;

// Function to find and print pair
bool chkPair(int A[], int size, int x) {
for (int i = 0; i < (size - 1); i++) {
	for (int j = (i + 1); j < size; j++) {
	if (A[i] + A[j] == x) {
		cout << "Pair with a given sum " << x << +
		" is (" << A[i] << ", " << A[j] << ")" <<
		endl;

		return 1;
	}
	}
}

return 0;
}

int main() {
int A[] = {
	0,
	-1,
	2,
	-3,
	1
};
int x = -2;
int size = sizeof(A) / sizeof(A[0]);

if (chkPair(A, size, x)) {
	cout << "Valid pair exists" << endl;
} else {
	cout << "No valid pair exists for " << x << endl;
}

return 0;
}

Output:

Pair with a given sum -2 is (-3, 1)
Valid pair exists

Time Complexity: O(n2)

Auxiliary Space: O(1)

Method 1: Sorting and Two-Pointers technique.

Using the two-pointer method to tackle this problem can be challenging. However, the array needs to be sorted before utilising the two pointer strategy. The two pointers that mark the beginning and end of the array can be taken once the array has been sorted. Shift the left pointer to increase the value of the necessary sum if the sum is less than the needed value and the right pointer to reduce it if the sum is more than the sum of the two elements. Let's use an example to better grasp this.

Give the array 1, 4, 45, 6, 10, -8, and the sum to be determined as 16.

Array is sorted after that
A = {-8, 1, 4, 6, 10, 45}

Now, increase "l" when the pair's sum is less than the necessary sum and decrease "r" when the pair's sum is more than the necessary amount.
This is due to the fact that travelling from left to right (while also sorting the array) in order to find the number that might enhance the total of a pair when the sum is smaller than the needed sum results in "l++" and vice versa.

Start with l = 0 and r = 5.
   • A[l] + A[r] (-8 + 45) > 16 resulting in r reduction Now r = 4
   • A[l] + A[r] (-8 + 10) add l. I is now equal to 1.
   • A[l] + A[r] (1 + 10) add l. At this point, l equals 2.
   • A[l] + A[r] (4 + 10) raise l, making l equal to 3.
   • A[l] + A[r] (6 + 10) == 16 => selected candidates (return 1)

Note: This algorithm only reports one pair if there are multiple pairs with the provided amount. nonetheless, readily adapted for this.

Algorithm:

hasArrayTwoCandidates (A[], ar_size, sum)
Sort the array in non-decreasing order.
Initialize two index variables to find the candidate elements in the sorted array.
- Initialize first to the leftmost index: l = 0
- Initialize second the rightmost index: r = ar_size-1
Loop while l < r.
- If (A[l] + A[r] == sum) then return 1
- Else if( A[l] + A[r] < sum ) then l++
- Else r-
No candidates in the whole array - return 0

The application of the aforementioned strategy is seen below:

CODE

// C++ program to check if given array
// has 2 elements whose sum is equal
// to the given value

#include <bits/stdc++.h>
using namespace std;

// Function to check if array has 2 elements
// whose sum is equal to the given value
bool hasArrayTwoCandidates(int A[], int arr_size,
						int sum)
{
	int l, r;

	/* Sort the elements */
	sort(A, A + arr_size);

	/* Now look for the two candidates in
	the sorted array*/
	l = 0;
	r = arr_size - 1;
	while (l < r) {
		if (A[l] + A[r] == sum)
			return 1;
		else if (A[l] + A[r] < sum)
			l++;
		else // A[i] + A[j] > sum
			r--;
	}
	return 0;
}

/* Driver program to test above function */
int main()
{
	int A[] = { 1, 4, 45, 6, 10, -8 };
	int n = 16;
	int arr_size = sizeof(A) / sizeof(A[0]);

	// Function calling
	if (hasArrayTwoCandidates(A, arr_size, n))
		cout << "Array has two elements"
				" with given sum";
	else
		cout << "Array doesn't have two"
				" elements with given sum";

	return 0;
}

Output:

Array has two elements with given sum

Complexity Analysis:

Time Complexity: Depends on what sorting algorithm we use.

If Merge Sort or Heap Sort is used then (-)(nlogn) in the worst case.

If Quick Sort is used then O(n^2) in the worst case.

Auxiliary Space: This too depends on sorting algorithm. The auxiliary space is O(n) for merge sort and O(1) for Heap Sort.

Method 2: Hashing

Approach: By employing the hashing method, this issue can be effectively resolved. Use a hash map to see whether there is a value target sum-x that can be added to the current array value x(let) to produce target sum. Continuous time can be used to do this. Let's examine the next illustration.

arr[] = {0, -1, 2, -3, 1}

total = -2

Now begin your traverse:
   • '-2' is not an acceptable number for '0,' thus store '0' in the hash map in step 1.
   • Since "-1" is not a valid number, "-1" should be stored in the hash map.
   • Store "2" in hash map because the integer "-4" is not a valid value for "2".
   • Since there is no acceptable number "1" for "-3," store "-3" in hash map.
   • The answer is 1, -3 because "1" is a valid number.

Algorithm:

Initialize an empty hash table s.
Do following for each element A[i] in A[]
- If s[x - A[i]] is set then print the pair (A[i], x - A[i])
- Insert A[i] into s.

Pseudocode

unordered_set s
for(i=0 to end)
	if(s.find(target_sum - arr[i]) == s.end)
    		insert(arr[i] into s)
  	else 
   		 print arr[i], target-arr[i]

CODE

// C++ program to check if given array
// has 2 elements whose sum is equal
// to the given value
#include <bits/stdc++.h>

using namespace std;

void printPairs(int arr[], int arr_size, int sum)
{
	unordered_set<int> s;
	for (int i = 0; i < arr_size; i++)
	{
		int temp = sum - arr[i];

		if (s.find(temp) != s.end())
			cout << "Pair with given sum "
				<< sum << " is (" << arr[i] << ","
					<< temp << ")" << endl;

		s.insert(arr[i]);
	}
}

/* Driver Code */
int main()
{
	int A[] = { 1, 4, 45, 6, 10, 8 };
	int n = 16;
	int arr_size = sizeof(A) / sizeof(A[0]);

	// Function calling
	printPairs(A, arr_size, n);

	return 0;
}

Output:

Pair with given sum 16 is (10,6)

Complexity Analysis:

Time Complexity: O(n).

As the whole array is needed to be traversed only once.

Auxiliary Space: O(n).

A hash map has been used to store array elements.

If the pair is made up of numbers that appear twice in the array, for example: array = [3,4,3]; pair = (3,3); target sum = 6, the answer will still be valid.

Method 3: Using remainders of the elements less than x.

The goal is to add up all the elements that leave behind remainders when multiplied by x, from 0 to x-1. If x is 6, then the sum of the numbers that are less than 6 and have remainders that add up to 6 is 6. For instance, the array contains the entries 2, 4, and the remainders 2%6 = 2 and 4%6 = 4, which together equal 6. In a similar manner, we must search for pairs with the remainders (1,5),(2,4). (3,3). If we have at least one element with a residual of 1 and at least one element with a remainder of 5, we will undoubtedly obtain a sum of 6. Since the elements for the resulting pair should be less than 6, we do not take (0,6) into consideration here. In the case of (3,3), we must first determine if there are any elements with a remainder of 3, after which we can state that "There exists a pair whose total equals x."

Algorithm:

Create an array with size x.
Initialize all rem elements to zero.
Traverse the given array
- Do the following if arr[i] is less than x:
  - r=arr[i]%x which is done to get the remainder.
  - rem[r]=rem[r]+1 i.e. increasing the count of elements that have remainder r when divided with x.
Now, traverse the rem array from 1 to x/2.
- If(rem[i]> 0 and rem[x-i]>0) then print "YES" and come out of the loop. This means that we have a pair that results in x upon doing.
Now when we reach at x/2 in the above loop
- If x is even, for getting a pair we should have two elements with remainder x/2.
  - If rem[x/2]>1 then print "YES" else print "NO"
- If it is not satisfied that is x is odd, it will have a separate pair with x-x/2.
  - If rem[x/2]>1 and rem[x-x/2]>1 , then print "Yes" else, print"No";

CODE

// Code in cpp to tell if there exists a pair in array whose
// sum results in x.
#include <iostream>
using namespace std;

// Function to print pairs
void printPairs(int a[], int n, int x)
{
	int i;
	int rem[x];
	// initializing the rem values with 0's.
	for (i = 0; i < x; i++)
		rem[i] = 0;
	// Perform the remainder operation only if the element
	// is x, as numbers greater than x can't be used to get
	// a sum x. Updating the count of remainders.
	for (i = 0; i < n; i++)
		if (a[i] < x)
			rem[a[i] % x]++;

	// Traversing the remainder list from start to middle to
	// find pairs
	for (i = 1; i < x / 2; i++) {
		if (rem[i] > 0 && rem[x - i] > 0) {
			// The elements with remainders i and x-i will
			// result to a sum of x. Once we get two
			// elements which add up to x , we print x and
			// break.
			cout << "Yes\n";
			break;
		}
	}

	// Once we reach middle of remainder array, we have to
	// do operations based on x.
	if (i >= x / 2) {
		if (x % 2 == 0) {
			// if x is even and we have more than 1 elements
			// with remainder x/2, then we will have two
			// distinct elements which add up to x. if we
			// dont have more than 1 element, print "No".
			if (rem[x / 2] > 1)
				cout << "Yes\n";
			else
				cout << "No\n";
		}
		else {
			// When x is odd we continue the same process
			// which we did in previous loop.
			if (rem[x / 2] > 0 && rem[x - x / 2] > 0)
				cout << "Yes\n";
			else
				cout << "No\n";
		}
	}
}

/* Driver Code */
int main()
{
	int A[] = { 1, 4, 45, 6, 10, 8 };
	int n = 16;
	int arr_size = sizeof(A) / sizeof(A[0]);

	// Function calling
	printPairs(A, arr_size, n);

	return 0;
}

Output:

Yes

Complexity Analysis:

Time Complexity: O(n+x).

Auxiliary Space: O(x).

An unordered map can also determine the indices of a pair that add up to a specified amount. The only modification required in this case is the addition of storing element indices as values alongside each element's key.

CODE

#include <bits/stdc++.h>
using namespace std;

pair<int,int> findSum(int *arr,int& n,int& target)
{
	int i,findElement;
	unordered_map<int,int>mp;
	pair<int,int>result;
	for(i=0;i<n;i++)
	{
		findElement=target-arr[i];
		if(mp.find(findElement) != mp.end())
		{
			result.first=mp[findElement];
			result.second=i;
		break;
		}
		else mp.insert({arr[i],i});
	}
	return result;
}

int main()
{
	int arr[]={1,5,4,3,7,9,2};
	int n=sizeof(arr)/sizeof(arr[0]);
	int search=7;
	pair<int,int>ans=findSum(arr,n,search);
	cout<<min(ans.first,ans.second)<<" "<<max(ans.first,ans.second);
	return 0;
}

Output: