# Find four elements that sum to a given value (4Sum) | Set 1 (n^3 solution)

Given an array of integers, find all combination of four elements in the array whose sum is equal to a given value X.

Example:

Input: array = {10, 2, 3, 4, 5, 9, 7, 8}, X = 23
Output: 3 5 7 8
Explanation: 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
Explanation: Sum of output is equal to 16, i.e. 1 + 3 + 5 + 7 = 16.

Recommended Practice

## 4Sum using Four Nested loop

A Naive Solution is to generate all possible quadruples and compare the sum of every quadruple with X. The following code implements this simple method using four nested loops

## C++

 `// C++ program for naive solution to` `// print all combination of 4 elements` `// in A[] with sum equal to X ` `#include ` `using` `namespace` `std;`   `/* A naive solution to print all combination ` `of 4 elements in A[]with sum equal to X */` `void` `findFourElements(``int` `A[], ``int` `n, ``int` `X)` `{` `    `  `// Fix the first element and find other three` `for` `(``int` `i = 0; i < n - 3; i++)` `{` `    ``// Fix the second element and find other two` `    ``for` `(``int` `j = i + 1; j < n - 2; j++)` `    ``{` `        `  `        ``// Fix the third element and find the fourth` `        ``for` `(``int` `k = j + 1; k < n - 1; k++)` `        ``{` `            ``// find the fourth` `            ``for` `(``int` `l = k + 1; l < n; l++)` `            ``if` `(A[i] + A[j] + A[k] + A[l] == X)` `                ``cout << A[i] <<``", "` `<< A[j] ` `                     ``<< ``", "` `<< A[k] << ``", "` `<< A[l];` `        ``} ` `    ``}` `}` `}`   `// Driver Code` `int` `main()` `{` `    ``int` `A[] = {10, 20, 30, 40, 1, 2};` `    ``int` `n = ``sizeof``(A) / ``sizeof``(A[0]);` `    ``int` `X = 91;` `    ``findFourElements (A, n, X);` `    ``return` `0;` `}`   `// This code is contributed` `// by Akanksha Rai`

## C

 `// C implementation of above approach`   `#include `   `/* A naive solution to print all combination of 4 elements in A[]` `  ``with sum equal to X */` `void` `findFourElements(``int` `A[], ``int` `n, ``int` `X)` `{` `  ``// Fix the first element and find other three` `  ``for` `(``int` `i = 0; i < n-3; i++)` `  ``{` `    ``// Fix the second element and find other two` `    ``for` `(``int` `j = i+1; j < n-2; j++)` `    ``{` `      ``// Fix the third element and find the fourth` `      ``for` `(``int` `k = j+1; k < n-1; k++)` `      ``{` `        ``// find the fourth` `        ``for` `(``int` `l = k+1; l < n; l++)` `           ``if` `(A[i] + A[j] + A[k] + A[l] == X)` `              ``printf``(``"%d, %d, %d, %d"``, A[i], A[j], A[k], A[l]);` `      ``}` `    ``}` `  ``}` `}`   `// Driver program to test above function` `int` `main()` `{` `    ``int` `A[] = {10, 20, 30, 40, 1, 2};` `    ``int` `n = ``sizeof``(A) / ``sizeof``(A[0]);` `    ``int` `X = 91;` `    ``findFourElements (A, n, X);` `    ``return` `0;` `}`

## Java

 `// Java implementation of above approach`   `class` `FindFourElements ` `{`   `    ``/* A naive solution to print all combination of 4 elements in A[]` `       ``with sum equal to X */` `    ``void` `findFourElements(``int` `A[], ``int` `n, ``int` `X) ` `    ``{` `        ``// Fix the first element and find other three` `        ``for` `(``int` `i = ``0``; i < n - ``3``; i++) ` `        ``{` `            ``// Fix the second element and find other two` `            ``for` `(``int` `j = i + ``1``; j < n - ``2``; j++) ` `            ``{` `                ``// Fix the third element and find the fourth` `                ``for` `(``int` `k = j + ``1``; k < n - ``1``; k++) ` `                ``{` `                    ``// find the fourth` `                    ``for` `(``int` `l = k + ``1``; l < n; l++) ` `                    ``{` `                        ``if` `(A[i] + A[j] + A[k] + A[l] == X) ` `                            ``System.out.print(A[i]+``" "``+A[j]+``" "``+A[k] ` `                                                                 ``+``" "``+A[l]);` `                    ``}` `                ``}` `            ``}` `        ``}` `    ``}`   `    ``// Driver program to test above functions` `    ``public` `static` `void` `main(String[] args) ` `    ``{` `        ``FindFourElements findfour = ``new` `FindFourElements();` `        ``int` `A[] = {``10``, ``20``, ``30``, ``40``, ``1``, ``2``};` `        ``int` `n = A.length;` `        ``int` `X = ``91``;` `        ``findfour.findFourElements(A, n, X);` `    ``}` `}`

## Python3

 `#Python 3 implementation of above approach`   `# A naive solution to print all combination` `# of 4 elements in A[] with sum equal to X ` `def` `findFourElements(A, n, X):` `    `  `    ``# Fix the first element and find ` `    ``# other three` `    ``for` `i ``in` `range``(``0``,n``-``3``):` `        `  `        ``# Fix the second element and ` `        ``# find other two` `        ``for` `j ``in` `range``(i``+``1``,n``-``2``):` `            `  `            ``# Fix the third element ` `            ``# and find the fourth` `            ``for` `k ``in` `range``(j``+``1``,n``-``1``):` `                `  `                ``# find the fourth` `                ``for` `l ``in` `range``(k``+``1``,n):` `                    `  `                    ``if` `A[i] ``+` `A[j] ``+` `A[k] ``+` `A[l] ``=``=` `X:` `                        ``print` `(``"%d, %d, %d, %d"` `                        ``%``( A[i], A[j], A[k], A[l]))`   `# Driver program to test above function` `A ``=` `[``10``, ``2``, ``3``, ``4``, ``5``, ``9``, ``7``, ``8``]` `n ``=` `len``(A)` `X ``=` `23` `findFourElements (A, n, X)`   `# This code is contributed by shreyanshi_arun`

## C#

 `// C# program for naive solution to` `// print all combination of 4 elements` `// in A[] with sum equal to X ` `using` `System;`   `class` `FindFourElements ` `{` `    ``void` `findFourElements(``int` `[]A, ``int` `n, ``int` `X) ` `    ``{` `        ``// Fix the first element and find other three` `        ``for` `(``int` `i = 0; i < n - 3; i++) ` `        ``{` `            ``// Fix the second element and find other two` `            ``for` `(``int` `j = i + 1; j < n - 2; j++) ` `            ``{` `                ``// Fix the third element and find the fourth` `                ``for` `(``int` `k = j + 1; k < n - 1; k++) ` `                ``{` `                    ``// find the fourth` `                    ``for` `(``int` `l = k + 1; l < n; l++) ` `                    ``{` `                        ``if` `(A[i] + A[j] + A[k] + A[l] == X) ` `                        ``Console.Write(A[i] + ``" "` `+ A[j] +` `                                ``" "` `+ A[k] + ``" "` `+ A[l]);` `                    ``}` `                ``}` `            ``}` `        ``}` `    ``}`   `    ``// Driver program to test above functions` `    ``public` `static` `void` `Main() ` `    ``{` `        ``FindFourElements findfour = ``new` `FindFourElements();` `        ``int` `[]A = {10, 20, 30, 40, 1, 2};` `        ``int` `n = A.Length;` `        ``int` `X = 91;` `        ``findfour.findFourElements(A, n, X);` `    ``}` `}`   `// This code is contributed by nitin mittal`

## Javascript

 ``

## PHP

 ``

Output

```20, 30, 40, 1
```

Time Complexity: O(n^4)
Auxiliary Space: O(1)

## 4Sum using Sorting

The time complexity can be improved to O(n^3) with the use of sorting as a preprocessing step, and then using method 1 of this post to reduce a loop.

• Sort the input array.
• Fix the first element as A[i] where i is from 0 to nâ€“3. After fixing the first element of quadruple, fix the second element as A[j] where j varies from i+1 to n-2. Find remaining two elements in O(n) time, using the method 1 of this post

Below is the implementation of the above approach:

## C++

 `// C++ program for to  print all combination` `// of 4 elements in A[] with sum equal to X` `#include ` `using` `namespace` `std;`   `/* Following function is needed` `for library function qsort(). */` `int` `compare(``const` `void``* a, ``const` `void``* b)` `{` `    ``return` `(*(``int``*)a - *(``int``*)b);` `}`   `/* A sorting based solution to print` `all combination of 4 elements in A[]` `with sum equal to X */` `void` `find4Numbers(``int` `A[], ``int` `n, ``int` `X)` `{` `    ``int` `l, r;`   `    ``// Sort the array in increasing` `    ``// order, using library function` `    ``// for quick sort` `    ``qsort``(A, n, ``sizeof``(A[0]), compare);`   `    ``/* Now fix the first 2 elements` `    ``one by one and find` `    ``the other two elements */` `    ``for` `(``int` `i = 0; i < n - 3; i++) {` `        ``for` `(``int` `j = i + 1; j < n - 2; j++) {` `            ``// Initialize two variables as` `            ``// indexes of the first and last` `            ``// elements in the remaining elements` `            ``l = j + 1;` `            ``r = n - 1;`   `            ``// To find the remaining two` `            ``// elements, move the index` `            ``// variables (l & r) toward each other.` `            ``while` `(l < r) {` `                ``if` `(A[i] + A[j] + A[l] + A[r] == X) {` `                    ``cout << A[i] << ``", "` `<< A[j] << ``", "` `                         ``<< A[l] << ``", "` `<< A[r];` `                    ``l++;` `                    ``r--;` `                ``}` `                ``else` `if` `(A[i] + A[j] + A[l] + A[r] < X)` `                    ``l++;` `                ``else` `// A[i] + A[j] + A[l] + A[r] > X` `                    ``r--;` `            ``} ``// end of while` `        ``} ``// end of inner for loop` `    ``} ``// end of outer for loop` `}`   `/* Driver code */` `int` `main()` `{` `    ``int` `A[] = { 1, 4, 45, 6, 10, 12 };` `    ``int` `X = 21;` `    ``int` `n = ``sizeof``(A) / ``sizeof``(A[0]);` `    ``find4Numbers(A, n, X);` `    ``return` `0;` `}`   `// This code is contributed by rathbhupendra`

## C

 `# include ` `# include `   `/* Following function is needed for library function qsort(). Refer` `   ``http://www.cplusplus.com/reference/clibrary/cstdlib/qsort/ */` `int` `compare (``const` `void` `*a, ``const` `void` `* b)` `{  ``return` `( *(``int` `*)a - *(``int` `*)b ); }`   `/* A sorting based solution to print all combination of 4 elements in A[]` `   ``with sum equal to X */` `void` `find4Numbers(``int` `A[], ``int` `n, ``int` `X)` `{` `    ``int` `l, r;`   `    ``// Sort the array in increasing order, using library` `    ``// function for quick sort` `    ``qsort` `(A, n, ``sizeof``(A[0]), compare);`   `    ``/* Now fix the first 2 elements one by one and find` `       ``the other two elements */` `    ``for` `(``int` `i = 0; i < n - 3; i++)` `    ``{` `        ``for` `(``int` `j = i+1; j < n - 2; j++)` `        ``{` `            ``// Initialize two variables as indexes of the first and last ` `            ``// elements in the remaining elements` `            ``l = j + 1;` `            ``r = n-1;`   `            ``// To find the remaining two elements, move the index ` `            ``// variables (l & r) toward each other.` `            ``while` `(l < r)` `            ``{` `                ``if``( A[i] + A[j] + A[l] + A[r] == X)` `                ``{` `                   ``printf``(``"%d, %d, %d, %d"``, A[i], A[j],` `                                           ``A[l], A[r]);` `                   ``l++; r--;` `                ``}` `                ``else` `if` `(A[i] + A[j] + A[l] + A[r] < X)` `                    ``l++;` `                ``else` `// A[i] + A[j] + A[l] + A[r] > X` `                    ``r--;` `            ``} ``// end of while` `        ``} ``// end of inner for loop` `    ``} ``// end of outer for loop` `}`   `/* Driver program to test above function */` `int` `main()` `{` `    ``int` `A[] = {1, 4, 45, 6, 10, 12};` `    ``int` `X = 21;` `    ``int` `n = ``sizeof``(A)/``sizeof``(A[0]);` `    ``find4Numbers(A, n, X);` `    ``return` `0;` `}`

## Java

 `import` `java.util.Arrays;`     `class` `FindFourElements` `{` `    ``/* A sorting based solution to print all combination of 4 elements in A[]` `       ``with sum equal to X */` `    ``void` `find4Numbers(``int` `A[], ``int` `n, ``int` `X) ` `    ``{` `        ``int` `l, r;`   `        ``// Sort the array in increasing order, using library` `        ``// function for quick sort` `        ``Arrays.sort(A);`   `        ``/* Now fix the first 2 elements one by one and find` `           ``the other two elements */` `        ``for` `(``int` `i = ``0``; i < n - ``3``; i++) ` `        ``{` `            ``for` `(``int` `j = i + ``1``; j < n - ``2``; j++) ` `            ``{` `                ``// Initialize two variables as indexes of the first and last ` `                ``// elements in the remaining elements` `                ``l = j + ``1``;` `                ``r = n - ``1``;`   `                ``// To find the remaining two elements, move the index ` `                ``// variables (l & r) toward each other.` `                ``while` `(l < r) ` `                ``{` `                    ``if` `(A[i] + A[j] + A[l] + A[r] == X) ` `                    ``{` `                        ``System.out.println(A[i]+``" "``+A[j]+``" "``+A[l]+``" "``+A[r]);` `                        ``l++;` `                        ``r--;` `                    ``} ` `                    ``else` `if` `(A[i] + A[j] + A[l] + A[r] < X)` `                        ``l++;` `                    ``else` `// A[i] + A[j] + A[l] + A[r] > X` `                        ``r--;` `                ``} ``// end of while` `            ``} ``// end of inner for loop` `        ``} ``// end of outer for loop` `    ``}`   `    ``// Driver program to test above functions` `    ``public` `static` `void` `main(String[] args) ` `    ``{` `        ``FindFourElements findfour = ``new` `FindFourElements();` `        ``int` `A[] = {``1``, ``4``, ``45``, ``6``, ``10``, ``12``};` `        ``int` `n = A.length;` `        ``int` `X = ``21``;` `        ``findfour.find4Numbers(A, n, X);` `    ``}` `}`   `// This code has been contributed by Mayank Jaiswal`

## Python 3

 `# A sorting based solution to print all combination ` `# of 4 elements in A[] with sum equal to X ` `def` `find4Numbers(A, n, X):`   `    ``# Sort the array in increasing order, ` `    ``# using library function for quick sort` `    ``A.sort()`   `    ``# Now fix the first 2 elements one by ` `    ``# one and find the other two elements ` `    ``for` `i ``in` `range``(n ``-` `3``):` `        ``for` `j ``in` `range``(i ``+` `1``, n ``-` `2``):` `            `  `            ``# Initialize two variables as indexes ` `            ``# of the first and last elements in ` `            ``# the remaining elements` `            ``l ``=` `j ``+` `1` `            ``r ``=` `n ``-` `1`   `            ``# To find the remaining two elements, ` `            ``# move the index variables (l & r)` `            ``# toward each other.` `            ``while` `(l < r):` `                ``if``(A[i] ``+` `A[j] ``+` `A[l] ``+` `A[r] ``=``=` `X):` `                    ``print``(A[i], ``","``, A[j], ``","``, ` `                          ``A[l], ``","``, A[r])` `                    ``l ``+``=` `1` `                    ``r ``-``=` `1` `                `  `                ``elif` `(A[i] ``+` `A[j] ``+` `A[l] ``+` `A[r] < X):` `                    ``l ``+``=` `1` `                ``else``: ``# A[i] + A[j] + A[l] + A[r] > X` `                    ``r ``-``=` `1`   `# Driver Code` `if` `__name__ ``=``=` `"__main__"``:` `    `  `    ``A ``=` `[``1``, ``4``, ``45``, ``6``, ``10``, ``12``]` `    ``X ``=` `21` `    ``n ``=` `len``(A)` `    ``find4Numbers(A, n, X)`   `# This code is contributed by ita_c`

## C#

 `// C# program for to  print all combination ` `// of 4 elements in A[] with sum equal to X ` `using` `System; `   `class` `FindFourElements` `{` `    ``// A sorting based solution to print all` `    ``// combination of 4 elements in A[] with` `    ``// sum equal to X ` `    ``void` `find4Numbers(``int` `[]A, ``int` `n, ``int` `X) ` `    ``{` `        ``int` `l, r;`   `        ``// Sort the array in increasing order, ` `        ``// using library function for quick sort` `        ``Array.Sort(A);`   `        ``/* Now fix the first 2 elements one by one ` `           ``and find the other two elements */` `        ``for` `(``int` `i = 0; i < n - 3; i++) ` `        ``{` `            ``for` `(``int` `j = i + 1; j < n - 2; j++) ` `            ``{` `                ``// Initialize two variables as indexes of ` `                ``// the first and last elements in the ` `                ``// remaining elements` `                ``l = j + 1;` `                ``r = n - 1;`   `                ``// To find the remaining two elements, move the ` `                ``// index variables (l & r) toward each other.` `                ``while` `(l < r) ` `                ``{` `                    ``if` `(A[i] + A[j] + A[l] + A[r] == X) ` `                    ``{` `                        ``Console.Write(A[i] + ``" "` `+ A[j] +` `                                ``" "` `+ A[l] + ``" "` `+ A[r]);` `                        ``l++;` `                        ``r--;` `                    ``} ` `                    ``else` `if` `(A[i] + A[j] + A[l] + A[r] < X)` `                        ``l++;` `                        `  `                    ``else` `// A[i] + A[j] + A[l] + A[r] > X` `                        ``r--;` `                        `  `                ``} ``// end of while` `                `  `            ``} ``// end of inner for loop` `            `  `        ``} ``// end of outer for loop` `    ``}`   `    ``// Driver program to test above functions` `    ``public` `static` `void` `Main() ` `    ``{` `        ``FindFourElements findfour = ``new` `FindFourElements();` `        ``int` `[]A = {1, 4, 45, 6, 10, 12};` `        ``int` `n = A.Length;` `        ``int` `X = 21;` `        ``findfour.find4Numbers(A, n, X);` `    ``}` `}`   `// This code has been contributed by nitin mittal`

## Javascript

 ``

## PHP

 ` X` `                ``else` `                    ``\$r``--;` `                    `  `            ``} ` `        ``} ` `    ``} ` `}`   `// Driver Code` `\$A` `= ``array``(1, 4, 45, 6, 10, 12);` `\$n` `= ``count``(``\$A``);` `\$X` `= 21;` `find4Numbers(``\$A``, ``\$n``, ``\$X``);`   `// This code is contributed` `// by nitin mittal` `?>`

Output

```1, 4, 6, 10
```

Time Complexity : O(n^3)
Auxiliary Space: O(1)

This problem can also be solved in O(n^2Logn) complexity. Please refer below post for details
Find four elements that sum to a given value | Set 2 ( O(n^2Logn) Solution)

Feeling lost in the world of random DSA topics, wasting time without progress? It's time for a change! Join our DSA course, where we'll guide you on an exciting journey to master DSA efficiently and on schedule.
Ready to dive in? Explore our Free Demo Content and join our DSA course, trusted by over 100,000 geeks!

Previous
Next