Find four elements that sum to a given value | Set 2

08 Jul, 2022
Given an array of integers, find anyone combination of four elements in the array whose sum is equal to a given value X.
For example, 
Input: array = {10, 2, 3, 4, 5, 9, 7, 8} 
       X = 23 
Output: 3 5 7 8
Sum of output is equal to 23, 
i.e. 3 + 5 + 7 + 8 = 23.

Input: array = {1, 2, 3, 4, 5, 9, 7, 8}
       X = 16 
Output: 1 3 5 7
Sum of output is equal to 16, 
i.e. 1 + 3 + 5 + 7 = 16.
We have discussed an O(n3) algorithm in the previous post on this topic. The problem can be solved in O(n2 Logn) time with the help of auxiliary space. Thanks to itsnimish for suggesting this method. Following is the detailed process.
Method 1: Two Pointers Algorithm. Approach: Let the input array be A[].  
Create an auxiliary array aux[] and store sum of all possible pairs in aux[]. The size of aux[] will be n*(n-1)/2 where n is the size of A[].Sort the auxiliary array aux[].Now the problem reduces to find two elements in aux[] with sum equal to X. We can use method 1 of this post to find the two elements efficiently. There is following important point to note though: An element of aux[] represents a pair from A[]. While picking two elements from aux[], we must check whether the two elements have an element of A[] in common. For example, if first element sum of A[1] and A[2], and second element is sum of A[2] and A[4], then these two elements of aux[] don’t represent four distinct elements of input array A[].
Create an auxiliary array aux[] and store sum of all possible pairs in aux[]. The size of aux[] will be n*(n-1)/2 where n is the size of A[].
Sort the auxiliary array aux[].
Now the problem reduces to find two elements in aux[] with sum equal to X. We can use method 1 of this post to find the two elements efficiently. There is following important point to note though: An element of aux[] represents a pair from A[]. While picking two elements from aux[], we must check whether the two elements have an element of A[] in common. For example, if first element sum of A[1] and A[2], and second element is sum of A[2] and A[4], then these two elements of aux[] don’t represent four distinct elements of input array A[].
Below is the implementation of the above approach: 
C++
C
Java
C#
Javascript
Python3
// C++ program to find 4 elements// with given sum#include <bits/stdc++.h>using namespace std; // The following structure is needed// to store pair sums in aux[]class pairSum {public:    // index (int A[]) of first element in pair    int first;     // index of second element in pair    int sec;     // sum of the pair    int sum;}; // Following function is needed// for library function qsort()int compare(const void* a, const void* b){    return ((*(pairSum*)a).sum - (*(pairSum*)b).sum);} // Function to check if two given pairs// have any common element or notbool noCommon(pairSum a, pairSum b){    if (a.first == b.first || a.first == b.sec        || a.sec == b.first || a.sec == b.sec)        return false;    return true;} // The function finds four// elements with given sum Xvoid findFourElements(int arr[], int n, int X){    int i, j;     // Create an auxiliary array    // to store all pair sums    int size = (n * (n - 1)) / 2;    pairSum aux[size];     // Generate all possible pairs    // from A[] and store sums    // of all possible pairs in aux[]    int k = 0;    for (i = 0; i < n - 1; i++) {        for (j = i + 1; j < n; j++) {            aux[k].sum = arr[i] + arr[j];            aux[k].first = i;            aux[k].sec = j;            k++;        }    }     // Sort the aux[] array using    // library function for sorting    qsort(aux, size, sizeof(aux[0]), compare);     // Now start two index variables    // from two corners of array    // and move them toward each other.    i = 0;    j = size - 1;    while (i < size && j >= 0) {        if ((aux[i].sum + aux[j].sum == X)            && noCommon(aux[i], aux[j])) {            cout << arr[aux[i].first] << ", "                 << arr[aux[i].sec] << ", "                 << arr[aux[j].first] << ", "                 << arr[aux[j].sec] << endl;            return;        }        else if (aux[i].sum + aux[j].sum < X)            i++;        else            j--;    }} // Driver codeint main(){    int arr[] = { 10, 20, 30, 40, 1, 2 };    int n = sizeof(arr) / sizeof(arr[0]);    int X = 91;       // Function Call    findFourElements(arr, n, X);    return 0;} // This is code is contributed by rathbhupendra
// C program to find 4 elements// with given sum#include <stdio.h>#include <stdlib.h> // The following structure is// needed to store pair sums in aux[]struct pairSum {     // index (int A[]) of first element in pair    int first;     // index of second element in pair    int sec;     // sum of the pair    int sum;}; // Following function is needed// for library function qsort()int compare(const void* a, const void* b){    return ((*(pairSum*)a).sum - (*(pairSum*)b).sum);} // Function to check if two given// pairs have any common element or notbool noCommon(struct pairSum a, struct pairSum b){    if (a.first == b.first || a.first == b.sec        || a.sec == b.first || a.sec == b.sec)        return false;    return true;} // The function finds four// elements with given sum Xvoid findFourElements(int arr[], int n, int X){    int i, j;     // Create an auxiliary array    // to store all pair sums    int size = (n * (n - 1)) / 2;    struct pairSum aux[size];     // Generate all possible pairs    // from A[] and store sums    // of all possible pairs in aux[]    int k = 0;    for (i = 0; i < n - 1; i++) {        for (j = i + 1; j < n; j++) {            aux[k].sum = arr[i] + arr[j];            aux[k].first = i;            aux[k].sec = j;            k++;        }    }     // Sort the aux[] array using    // library function for sorting    qsort(aux, size, sizeof(aux[0]), compare);     // Now start two index variables    // from two corners of array    // and move them toward each other.    i = 0;    j = size - 1;    while (i < size && j >= 0) {        if ((aux[i].sum + aux[j].sum == X)            && noCommon(aux[i], aux[j])) {            printf("%d, %d, %d, %d\n", arr[aux[i].first],                   arr[aux[i].sec], arr[aux[j].first],                   arr[aux[j].sec]);            return;        }        else if (aux[i].sum + aux[j].sum < X)            i++;        else            j--;    }} // Driver codeint main(){    int arr[] = { 10, 20, 30, 40, 1, 2 };    int n = sizeof(arr) / sizeof(arr[0]);    int X = 91;        // Function call    findFourElements(arr, n, X);    return 0;}
// Java program to find 4 elements// with given sumimport java.util.*;class GFG {   // The following structure is needed  // to store pair sums in aux[]  static class pairSum {     // Index (int A[]) of first element in pair    public int first;     // Index of second element in pair    public int sec;     // Sum of the pair    public int sum;  }   // Function to check if two given pairs  // have any common element or not  static boolean noCommon(pairSum a, pairSum b)  {    if (a.first == b.first || a.first == b.sec        || a.sec == b.first || a.sec == b.sec)      return false;     return true;  }   // The function finds four  // elements with given sum X  static void findFourElements(int[] myArr, int sum)  {    int i, j;    int length = myArr.length;     // Create an auxiliary array to    // store all pair sums    int size = (length * (length - 1)) / 2;    pairSum[] aux = new pairSum[size];     // Generate all possible pairs    // from A[] and store sums    // of all possible pairs in aux[]    int k = 0;    for (i = 0; i < length - 1; i++) {      for (j = i + 1; j < length; j++) {        aux[k] = new pairSum();        aux[k].sum = myArr[i] + myArr[j];        aux[k].first = i;        aux[k].sec = j;        k++;      }    }     // Sort the aux[] array using    // library function for sorting    Arrays.sort(aux, new Comparator<pairSum>() {      // Following function is needed for sorting      // pairSum array      public int compare(pairSum a, pairSum b)      {        return (a.sum - b.sum);      }    });     // Now start two index variables    // from two corners of array    // and move them toward each other.    i = 0;    j = size - 1;    while (i < size && j >= 0) {      if ((aux[i].sum + aux[j].sum == sum)          && noCommon(aux[i], aux[j])) {        String output = myArr[aux[i].first] + ", "          + myArr[aux[i].sec] + ", "          + myArr[aux[j].first] + ", "          + myArr[aux[j].sec];        System.out.println(output);        return;      }      else if (aux[i].sum + aux[j].sum < sum)        i++;      else        j--;    }  }   public static void main(String[] args)  {    int[] arr = { 10, 20, 30, 40, 1, 2 };    int X = 91;     // Function call    findFourElements(arr, X);  }} // This code is contributed by phasing17
// C# program to find 4 elements// with given sumusing System; class GFG{ // The following structure is needed// to store pair sums in aux[]class pairSum{         // Index (int A[]) of first element in pair    public int first;     // Index of second element in pair    public int sec;     // Sum of the pair    public int sum;} // Function to check if two given pairs// have any common element or notstatic bool noCommon(pairSum a, pairSum b){    if (a.first == b.first || a.first == b.sec ||        a.sec == b.first || a.sec == b.sec)        return false;             return true;} // Following function is needed for sorting// pairSum arraystatic int compare(pairSum a, pairSum b){    return (a.sum - b.sum);} // The function finds four// elements with given sum Xstatic void findFourElements(int[] myArr, int sum){    int i, j;    int length = myArr.Length;     // Create an auxiliary array to    // store all pair sums    int size = (length * (length - 1)) / 2;    pairSum[] aux = new pairSum[size];     // Generate all possible pairs    // from A[] and store sums    // of all possible pairs in aux[]    int k = 0;    for(i = 0; i < length - 1; i++)    {        for(j = i + 1; j < length; j++)        {            aux[k] = new pairSum();            aux[k].sum = myArr[i] + myArr[j];            aux[k].first = i;            aux[k].sec = j;            k++;        }    }     // Sort the aux[] array using    // library function for sorting    Array.Sort(aux, compare);     // Now start two index variables    // from two corners of array    // and move them toward each other.    i = 0;    j = size - 1;    while (i < size && j >= 0)    {        if ((aux[i].sum + aux[j].sum == sum) &&            noCommon(aux[i], aux[j]))        {            string output = myArr[aux[i].first] + ", " +                            myArr[aux[i].sec] + ", " +                            myArr[aux[j].first] + ", " +                            myArr[aux[j].sec];            Console.WriteLine(output);            return;        }        else if (aux[i].sum + aux[j].sum < sum)            i++;        else            j--;    }} // Driver codestatic public void Main(){    int[] arr = { 10, 20, 30, 40, 1, 2 };    int X = 91;     // Function call    findFourElements(arr, X);}} // This code is contributed by srastog
// JavaScript program to find 4 elements// with given sum // The following structure is needed// to store pair sums in aux[]let pairSum = {     // Index (int A[]) of first element in pair    first : "",     // Index of second element in pair    sec : "",     // Sum of the pair    sum : ""}; // Function to check if two given pairs// have any common element or notfunction noCommon(a, b){    if (a.first == b.first || a.first == b.sec        || a.sec == b.first || a.sec == b.sec)        return false;     return true;} // The function finds four// elements with given sum Xfunction findFourElements(myArr, sum){    let i, j;    let length = myArr.length;     // Create an auxiliary array to    // store all pair sums    let size = Math.floor((length * (length - 1)) / 2);    let aux = new Array(size);     // Generate all possible pairs    // from A[] and store sums    // of all possible pairs in aux[]    let k = 0;    for (i = 0; i < length - 1; i++) {        for (j = i + 1; j < length; j++) {            aux[k] = new Object();            aux[k].sum = myArr[i] + myArr[j];            aux[k].first = i;            aux[k].sec = j;            k++;        }    }     // Sort the aux[] array using    // library function for sorting    aux.sort(        // Following function is needed for sorting        // pairSum array        function(x, y) { return x.sum - y.sum; });     // Now start two index variables    // from two corners of array    // and move them toward each other.    i = 0;    j = size - 1;    while (i < size && j >= 0) {        if ((aux[i].sum + aux[j].sum == sum)            && noCommon(aux[i], aux[j])) {            let output = myArr[aux[i].first] + ", "                         + myArr[aux[i].sec] + ", "                         + myArr[aux[j].first] + ", "                         + myArr[aux[j].sec];            console.log(output);            return;        }        else if (aux[i].sum + aux[j].sum < sum)            i++;        else            j--;    }} let arr = [ 10, 20, 30, 40, 1, 2 ];let X = 91; // Function callfindFourElements(arr, X); // This code is contributed by phasing17
# Python3 program to find 4 elements# with given sum # The following structure is needed# to store pair sums in aux[]  class pairSum:     def __init__(self):        # Index (int A[]) of first element in pair        self.first = ""         # Index of second element in pair        self.sec = ""         # Sum of the pair        self.sum = ""  # Function to check if two given pairs# have any common element or notdef noCommon(a, b):    if (a.first == b.first or a.first == b.sec or a.sec == b.first or a.sec == b.sec):        return False     return True  # The function finds four# elements with given sum Xdef findFourElements(myArr, sum):     length = len(myArr)     # Create an auxiliary array to    # store all pair sums    size = ((length * (length - 1)) // 2)    aux = [None for _ in range(size)]     # Generate all possible pairs    # from A[] and store sums    # of all possible pairs in aux[]    k = 0    for i in range(length - 1):        for j in range(i + 1, length):            aux[k] = pairSum()            aux[k].sum = myArr[i] + myArr[j]            aux[k].first = i            aux[k].sec = j            k += 1     # Sort the aux[] array using    # library function for sorting    aux.sort(key=lambda x: x.sum)     # Now start two index variables    # from two corners of array    # and move them toward each other.    i = 0    j = size - 1    while (i < size and j >= 0):        if ((aux[i].sum + aux[j].sum == sum)                and noCommon(aux[i], aux[j])):            print(myArr[aux[i].first], myArr[aux[i].sec],                  myArr[aux[j].first], myArr[aux[j].sec], sep=", ")            return         elif (aux[i].sum + aux[j].sum < sum):            i += 1        else:            j -= 1  # Driver Codearr = [10, 20, 30, 40, 1, 2]X = 91 # Function callfindFourElements(arr, X)  # This code is contributed by phasing17
Chapters
descriptions off, selected
captions settings, opens captions settings dialog
captions off, selected
English
This is a modal window.
Beginning of dialog window. Escape will cancel and close the window.
End of dialog window.
20, 1, 30, 40
Please note that the above code prints only one quadruple. If we remove the return statement and add statements “i++; j–;”, then it prints same quadruple five times. The code can modified to print all quadruples only once. It has been kept this way to keep it simple. Complexity Analysis: 
Time complexity: O(n^2Logn). The step 1 takes O(n^2) time. The second step is sorting an array of size O(n^2). Sorting can be done in O(n^2Logn) time using merge sort or heap sort or any other O(nLogn) algorithm. The third step takes O(n^2) time. So overall complexity is O(n^2Logn).
Auxiliary Space: O(n^2). The size of the auxiliary array is O(n^2). The big size of the auxiliary array can be a concern in this method.
Method 2: Hashing Based Solution[O(n2)] 
Approach: 
Store sums of all pairs in a hash tableTraverse through all pairs again and search for X – (current pair sum) in the hash table.If a pair is found with the required sum, then make sure that all elements are distinct array elements and an element is not considered more than once.
Store sums of all pairs in a hash table
Traverse through all pairs again and search for X – (current pair sum) in the hash table.
If a pair is found with the required sum, then make sure that all elements are distinct array elements and an element is not considered more than once.
Below image is a dry run of the above approach: 
Below is the implementation of the above approach: 
C++
Java
Python3
C#
Javascript
// A hashing based  CPP program// to find if there are// four elements with given sum.#include <bits/stdc++.h>using namespace std; // The function finds four// elements with given sum Xvoid findFourElements(int arr[], int n, int X){    // Store sums of all pairs    // in a hash table    unordered_map<int, pair<int, int> > mp;    for (int i = 0; i < n - 1; i++)        for (int j = i + 1; j < n; j++)            mp[arr[i] + arr[j]] = { i, j };     // Traverse through all pairs and search    // for X - (current pair sum).    for (int i = 0; i < n - 1; i++) {        for (int j = i + 1; j < n; j++) {            int sum = arr[i] + arr[j];             // If X - sum is present in hash table,            if (mp.find(X - sum) != mp.end()) {                 // Making sure that all elements are                // distinct array elements and an element                // is not considered more than once.                pair<int, int> p = mp[X - sum];                if (p.first != i && p.first != j                    && p.second != i && p.second != j) {                    cout << arr[i] << ", " << arr[j] << ", "                         << arr[p.first] << ", "                         << arr[p.second];                    return;                }            }        }    }} // Driver codeint main(){    int arr[] = { 10, 20, 30, 40, 1, 2 };    int n = sizeof(arr) / sizeof(arr[0]);    int X = 91;        // Function call    findFourElements(arr, n, X);    return 0;}
// A hashing based Java program to find// if there are four elements with given sum.import java.util.HashMap;class GFG {    static class pair {        int first, second;        public pair(int first, int second)        {            this.first = first;            this.second = second;        }    }     // The function finds four elements    // with given sum X    static void findFourElements(int arr[], int n, int X)    {        // Store sums of all pairs in a hash table        HashMap<Integer, pair> mp            = new HashMap<Integer, pair>();        for (int i = 0; i < n - 1; i++)            for (int j = i + 1; j < n; j++)                mp.put(arr[i] + arr[j], new pair(i, j));         // Traverse through all pairs and search        // for X - (current pair sum).        for (int i = 0; i < n - 1; i++) {            for (int j = i + 1; j < n; j++) {                int sum = arr[i] + arr[j];                 // If X - sum is present in hash table,                if (mp.containsKey(X - sum)) {                     // Making sure that all elements are                    // distinct array elements and an                    // element is not considered more than                    // once.                    pair p = mp.get(X - sum);                    if (p.first != i && p.first != j                        && p.second != i && p.second != j) {                        System.out.print(                            arr[i] + ", " + arr[j] + ", "                            + arr[p.first] + ", "                            + arr[p.second]);                        return;                    }                }            }        }    }     // Driver Code    public static void main(String[] args)    {        int arr[] = { 10, 20, 30, 40, 1, 2 };        int n = arr.length;        int X = 91;               // Function call        findFourElements(arr, n, X);    }} // This code is contributed by Princi Singh
# A hashing based Python program to find if there are# four elements with given summ. # The function finds four elements with given summ X  def findFourElements(arr, n, X):     # Store summs of all pairs in a hash table    mp = {}    for i in range(n - 1):        for j in range(i + 1, n):            mp[arr[i] + arr[j]] = [i, j]     # Traverse through all pairs and search    # for X - (current pair summ).    for i in range(n - 1):        for j in range(i + 1, n):            summ = arr[i] + arr[j]             # If X - summ is present in hash table,            if (X - summ) in mp:                 # Making sure that all elements are                # distinct array elements and an element                # is not considered more than once.                p = mp[X - summ]                if (p[0] != i and p[0] != j and p[1] != i and p[1] != j):                    print(arr[i], ", ", arr[j], ", ",                          arr[p[0]], ", ", arr[p[1]], sep="")                    return  # Driver codearr = [10, 20, 30, 40, 1, 2]n = len(arr)X = 91 # Function callfindFourElements(arr, n, X) # This is code is contributed by shubhamsingh10
// A hashing based C# program to find// if there are four elements with given sum.using System;using System.Collections.Generic; class GFG {    public class pair {        public int first, second;        public pair(int first, int second)        {            this.first = first;            this.second = second;        }    }     // The function finds four elements    // with given sum X    static void findFourElements(int[] arr, int n, int X)    {        // Store sums of all pairs in a hash table        Dictionary<int, pair> mp            = new Dictionary<int, pair>();        for (int i = 0; i < n - 1; i++)            for (int j = i + 1; j < n; j++)                if (mp.ContainsKey(arr[i] + arr[j]))                    mp[arr[i] + arr[j]] = new pair(i, j);                else                    mp.Add(arr[i] + arr[j], new pair(i, j));         // Traverse through all pairs and search        // for X - (current pair sum).        for (int i = 0; i < n - 1; i++) {            for (int j = i + 1; j < n; j++) {                int sum = arr[i] + arr[j];                 // If X - sum is present in hash table,                if (mp.ContainsKey(X - sum)) {                     // Making sure that all elements are                    // distinct array elements and an                    // element is not considered more than                    // once.                    pair p = mp[X - sum];                    if (p.first != i && p.first != j                        && p.second != i && p.second != j) {                        Console.Write(arr[i] + ", " + arr[j]                                      + ", " + arr[p.first]                                      + ", "                                      + arr[p.second]);                        return;                    }                }            }        }    }     // Driver Code    public static void Main(String[] args)    {        int[] arr = { 10, 20, 30, 40, 1, 2 };        int n = arr.Length;        int X = 91;               // Function call        findFourElements(arr, n, X);    }} // This code is contributed by 29AjayKumar
<script>// A hashing based Javascript program to find// if there are four elements with given sum. // The function finds four elements// with given sum Xfunction findFourElements(arr,n,X){    // Store sums of all pairs in a hash table        let mp = new Map();        for (let i = 0; i < n - 1; i++)            for (let j = i + 1; j < n; j++)                mp.set(arr[i] + arr[j], [i, j]);          // Traverse through all pairs and search        // for X - (current pair sum).        for (let i = 0; i < n - 1; i++) {            for (let j = i + 1; j < n; j++) {                let sum = arr[i] + arr[j];                  // If X - sum is present in hash table,                if (mp.has(X - sum)) {                      // Making sure that all elements are                    // distinct array elements and an                    // element is not considered more than                    // once.                    let p = mp.get(X - sum);                    if (p[0] != i && p[0] != j                        && p[1] != i && p[1] != j) {                        document.write(                            arr[i] + ", " + arr[j] + ", "                            + arr[p[0]] + ", "                            + arr[p[1]]);                        return;                    }                }            }        }} // Driver Codelet arr=[ 10, 20, 30, 40, 1, 2];let  n = arr.length;let  X = 91; // Function callfindFourElements(arr, n, X); // This code is contributed by rag2127</script>
20, 30, 40, 1
Complexity Analysis: 
Time complexity: O(n^2). Nested traversal is needed to store all pairs in the hash Map.
Auxiliary Space: O(n^2). All n*(n-1) pairs are stored in hash Map so the space required is O(n^2)Please write comments if you find any of the above codes/algorithms incorrect, or find other ways to solve the same problem.
Method 3: Solution having no duplicate elements
Approach:
Store sums of all pairs in a hash tableTraverse through all pairs again and search for X – (current pair sum) in the hash table.Consider a temp array that is initially stored with zeroes. It is changed to 1 when we get 4 elements that sum up to the required value.If a pair is found with the required sum, then make sure that all elements are distinct array elements and check if the value in temp array is 0 so that duplicates are not considered.
Store sums of all pairs in a hash table
Traverse through all pairs again and search for X – (current pair sum) in the hash table.
Consider a temp array that is initially stored with zeroes. It is changed to 1 when we get 4 elements that sum up to the required value.
If a pair is found with the required sum, then make sure that all elements are distinct array elements and check if the value in temp array is 0 so that duplicates are not considered.
Below is the implementation of the code: 
C++
Java
Python3
C#
Javascript
// C++ program to find four // elements with the given sum#include <bits/stdc++.h>using namespace std; // Function to find 4 elements that add up to// given sumvoid fourSum(int X, int arr[], map<int,             pair<int, int>> Map, int N){    int temp[N];     // Iterate from 0 to temp.length    for (int i = 0; i < N; i++)        temp[i] = 0;     // Iterate from 0 to arr.length    for (int i = 0; i < N - 1; i++)    {         // Iterate from i + 1 to arr.length        for (int j = i + 1; j < N; j++)        {             // Store curr_sum = arr[i] + arr[j]            int curr_sum = arr[i] + arr[j];             // Check if X - curr_sum if present            // in map            if (Map.find(X - curr_sum) != Map.end())            {                 // Store pair having map value                // X - curr_sum                pair<int, int> p = Map[X - curr_sum];                 if (p.first != i && p.second != i                    && p.first != j && p.second != j                    && temp[p.first] == 0                    && temp[p.second] == 0 && temp[i] == 0                    && temp[j] == 0)                {                     // Print the output                    cout << arr[i] << "," << arr[j] <<                      "," << arr[p.first] << "," << arr[p.second];                    temp[p.second] = 1;                    temp[i] = 1;                    temp[j] = 1;                    break;                }            }        }    }} // Program for two Summap<int, pair<int, int>> twoSum(int nums[], int N){    map<int, pair<int, int>> Map;    for (int i = 0; i < N - 1; i++)    {        for (int j = i + 1; j < N; j++)        {            Map[nums[i] + nums[j]].first = i;            Map[nums[i] + nums[j]].second = j;        }    }    return Map;} // Driver codeint main(){    int arr[] = { 10, 20, 30, 40, 1, 2 };    int n = sizeof(arr) / sizeof(arr[0]);    int X = 91;    map<int, pair<int, int>> Map = twoSum(arr, n);         // Function call    fourSum(X, arr, Map, n);     return 0;} // This code is contributed by divyesh072019
// Java program to find four// elements with the given sumimport java.util.*; class fourElementWithSum {     // Function to find 4 elements that add up to    // given sum    public static void fourSum(int X, int[] arr,                               Map<Integer, pair> map)    {        int[] temp = new int[arr.length];         // Iterate from 0 to temp.length        for (int i = 0; i < temp.length; i++)            temp[i] = 0;         // Iterate from 0 to arr.length        for (int i = 0; i < arr.length - 1; i++) {             // Iterate from i + 1 to arr.length            for (int j = i + 1; j < arr.length; j++) {                 // Store curr_sum = arr[i] + arr[j]                int curr_sum = arr[i] + arr[j];                 // Check if X - curr_sum if present                // in map                if (map.containsKey(X - curr_sum)) {                     // Store pair having map value                    // X - curr_sum                    pair p = map.get(X - curr_sum);                     if (p.first != i && p.sec != i                        && p.first != j && p.sec != j                        && temp[p.first] == 0                        && temp[p.sec] == 0 && temp[i] == 0                        && temp[j] == 0) {                         // Print the output                        System.out.printf(                            "%d,%d,%d,%d", arr[i], arr[j],                            arr[p.first], arr[p.sec]);                        temp[p.sec] = 1;                        temp[i] = 1;                        temp[j] = 1;                        break;                    }                }            }        }    }     // Program for two Sum    public static Map<Integer, pair> twoSum(int[] nums)    {        Map<Integer, pair> map = new HashMap<>();        for (int i = 0; i < nums.length - 1; i++) {            for (int j = i + 1; j < nums.length; j++) {                map.put(nums[i] + nums[j], new pair(i, j));            }        }        return map;    }     // to store indices of two sum pair    public static class pair {        int first, sec;         public pair(int first, int sec)        {            this.first = first;            this.sec = sec;        }    }     // Driver Code    public static void main(String args[])    {        int[] arr = { 10, 20, 30, 40, 1, 2 };        int n = arr.length;        int X = 91;        Map<Integer, pair> map = twoSum(arr);               // Function call        fourSum(X, arr, map);    }} // This code is contributed by Likhita avl.
# Python3 program to find four # elements with the given sum # Function to find 4 elements that# add up to given sumdef fourSum(X, arr, Map, N):         temp = [0 for i in range(N)]         # Iterate from 0 to length of arr    for i in range(N - 1):                 # Iterate from i + 1 to length of arr        for j in range(i + 1, N):                         # Store curr_sum = arr[i] + arr[j]            curr_sum = arr[i] + arr[j]             # Check if X - curr_sum if present            # in map            if (X - curr_sum) in Map:                                 # Store pair having map value                # X - curr_sum                p = Map[X - curr_sum]                 if (p[0] != i and p[1] != i and                    p[0] != j and p[1] != j and                    temp[p[0]] == 0 and temp[p[1]] == 0 and                    temp[i] == 0 and temp[j] == 0):                                             # Print the output                    print(arr[i], ",", arr[j], ",",                          arr[p[0]], ",", arr[p[1]],                          sep = "")                                               temp[p[1]] = 1                    temp[i] = 1                    temp[j] = 1                    break # Function for two Sumdef twoSum(nums, N):         Map = {}         for i in range(N - 1):        for j in range(i + 1, N):            Map[nums[i] + nums[j]] = []            Map[nums[i] + nums[j]].append(i)            Map[nums[i] + nums[j]].append(j)     return Map # Driver codearr = [ 10, 20, 30, 40, 1, 2 ]n = len(arr)X = 91Map = twoSum(arr, n) # Function callfourSum(X, arr, Map, n) # This code is contributed by avanitrachhadiya2155
// C# program to find four // elements with the given sumusing System;using System.Collections.Generic; class GFG{         // Function to find 4 elements that add up to    // given sum    static void fourSum(int X, int[] arr, Dictionary<int,                        Tuple<int, int>> Map, int N)    {        int[] temp = new int[N];              // Iterate from 0 to temp.length        for (int i = 0; i < N; i++)            temp[i] = 0;              // Iterate from 0 to arr.length        for (int i = 0; i < N - 1; i++)        {                  // Iterate from i + 1 to arr.length            for (int j = i + 1; j < N; j++)            {                      // Store curr_sum = arr[i] + arr[j]                int curr_sum = arr[i] + arr[j];                      // Check if X - curr_sum if present                // in map                if (Map.ContainsKey(X - curr_sum))                {                          // Store pair having map value                    // X - curr_sum                    Tuple<int, int> p = Map[X - curr_sum];                          if (p.Item1 != i && p.Item2 != i                        && p.Item1 != j && p.Item2 != j                        && temp[p.Item1] == 0                        && temp[p.Item2] == 0 && temp[i] == 0                        && temp[j] == 0)                    {                              // Print the output                        Console.Write(arr[i] + "," + arr[j] +                                      "," + arr[p.Item1] + "," +                                      arr[p.Item2]);                        temp[p.Item2] = 1;                        temp[i] = 1;                        temp[j] = 1;                        break;                    }                }            }        }    }          // Program for two Sum    static Dictionary<int, Tuple<int, int>> twoSum(int[] nums, int N)    {        Dictionary<int, Tuple<int, int>> Map =          new Dictionary<int, Tuple<int, int>>();        for (int i = 0; i < N - 1; i++)        {            for (int j = i + 1; j < N; j++)            {                Map[nums[i] + nums[j]] = new Tuple<int, int>(i, j);            }        }        return Map;    }   // Driver code  static void Main()  {    int[] arr = { 10, 20, 30, 40, 1, 2 };    int n = arr.Length;    int X = 91;    Dictionary<int, Tuple<int, int>> Map = twoSum(arr, n);          // Function call    fourSum(X, arr, Map, n);  }} // This code is contributed by divyeshrabadiya07
<script>// Javascript program to find four// elements with the given sum class pair{    constructor(first, sec)    {        this.first = first;        this.sec = sec;    }} // Function to find 4 elements that add up to    // given sumfunction fourSum(X, arr, map){    let temp = new Array(arr.length);          // Iterate from 0 to temp.length        for (let i = 0; i < temp.length; i++)            temp[i] = 0;          // Iterate from 0 to arr.length        for (let i = 0; i < arr.length - 1; i++) {              // Iterate from i + 1 to arr.length            for (let j = i + 1; j < arr.length; j++) {                  // Store curr_sum = arr[i] + arr[j]                let curr_sum = arr[i] + arr[j];                  // Check if X - curr_sum if present                // in map                if (map.has(X - curr_sum)) {                      // Store pair having map value                    // X - curr_sum                    let p = map.get(X - curr_sum);                      if (p.first != i && p.sec != i                        && p.first != j && p.sec != j                        && temp[p.first] == 0                        && temp[p.sec] == 0 && temp[i] == 0                        && temp[j] == 0) {                          // Print the output                        document.write( arr[i]+","+arr[j]+","+                            arr[p.first]+"," +arr[p.sec]);                        temp[p.sec] = 1;                        temp[i] = 1;                        temp[j] = 1;                        break;                    }                }            }        }} // Program for two Sumfunction twoSum(nums){     let map = new Map();        for (let i = 0; i < nums.length - 1; i++) {            for (let j = i + 1; j < nums.length; j++) {                map.set(nums[i] + nums[j], new pair(i, j));            }        }        return map;} // Driver Codelet arr=[10, 20, 30, 40, 1, 2];let n = arr.length;let X = 91;let map = twoSum(arr); // Function callfourSum(X, arr, map);                                 // This code is contributed by patel2127.</script>
20,30,40,1
Complexity Analysis:
Time complexity: O(n^2).Nested traversal is needed to store all pairs in the hash Map.
Auxiliary Space: O(n^2).All n*(n-1) pairs are stored in hash Map so the space required is O(n^2) and the temp array takes O(n) so space comes to O(n^2).
Mrinal Tak
ImStark
rathbhupendra
princi singh
29AjayKumar
SHUBHAMSINGH10
andrew1234
avllikhita
divyesh072019
divyeshrabadiya07
avanitrachhadiya2155
himanshu6003
simmytarika5
rag2127
patel2127
aadarsh baid
srastog
hardikkoriintern
phasing17
Amazon
Google
Microsoft
Arrays
Hash
Sorting
Amazon
Microsoft
Google
Arrays
Hash
Sorting
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.