# Find four factors of N with maximum product and sum equal to N | Set-2

Given an integer . The task is to find all factors of N and print the product of four factors of N such that:

• Sum of the four factors is equal to N.
• Product of the four factors is maximum.

If it is not possible to find 4 such factors then print “Not possible”.

Note: All the four factors can be equal to each other to maximize the product.

Examples:

```Input : N = 24
Output : Product -> 1296
All factors are -> 1 2 3 4 6 8 12 24
Choose the factor 6 four times,
Therefore, 6+6+6+6 = 24 and product is maximum.

Input : N = 100
Output : Product -> 390625
All the factors are -> 1 2 4 5 10 10 20 25 50 100
Choose the factor 25 four times.
```

## Recommended: Please try your approach on {IDE} first, before moving on to the solution.

An approach which takes a complexity of O(M^3), where M is the number of factors of N has been discussed in the previous post.

An efficient approach of time complexity O(N^2) can be obtained by following the below steps.

• Store all the factors of given number in a container.
• Iterate for all pairs and store their sum in a different container.
• Mark the index (element1 + element2) with pair(element1, element2 to get the elements by which the sum was obtained.
• Iterate for all the pair_sums, and check if n-pair_sum exists in the same container, then both the pairs form the quadruple.
• Use the pair hash array to get the elements by which the pair was formed.
• Store the maximum of all such quadruples, and print it at the end.

Below is the implementation of above approach:

## C++

 `// C++ program to find four factors of N ` `// with maximum product and sum equal to N ` `#include ` ` `  `using` `namespace` `std; ` ` `  `// Function to find factors ` `// and to print those four factors ` `void` `findfactors(``int` `n) ` `{ ` `    ``unordered_map<``int``, ``int``> mpp; ` ` `  `    ``vector<``int``> v, v1; ` ` `  `    ``// push all the factors in the container ` `    ``for` `(``int` `i = 1; i <= ``sqrt``(n); i++) { ` `        ``if` `(n % i == 0) { ` `            ``v.push_back(i); ` `            ``if` `(i != (n / i) && i != 1) ` `                ``v.push_back(n / i); ` `        ``} ` `    ``} ` ` `  `    ``// number of factors ` `    ``int` `s = v.size(); ` ` `  `    ``// Initial maximum ` `    ``int` `maxi = -1; ` ` `  `    ``// hash-array to mark the ` `    ``// pairs ` `    ``pair<``int``, ``int``> mp1[n + 5]; ` ` `  `    ``for` `(``int` `i = 0; i < s; i++) { ` ` `  `        ``// form all the pair sums ` `        ``for` `(``int` `j = i; j < s; j++) { ` ` `  `            ``// if the pair sum is less than n ` `            ``if` `(v[i] + v[j] < n) { ` ` `  `                ``// push in another container ` `                ``v1.push_back(v[i] + v[j]); ` ` `  `                ``// mark the sum with the elements  ` `                ``// formed ` `                ``mp1[v[i] + v[j]] = { v[i], v[j] }; ` ` `  `                ``// mark in the map that v[i]+v[j] ` `                ``// is present ` `                ``mpp[v[i] + v[j]] = 1; ` `            ``} ` `        ``} ` `    ``} ` ` `  `    ``// new size of all the pair sums ` `    ``s = v1.size(); ` ` `  `    ``// iterate for all pair sum ` `    ``for` `(``int` `i = 0; i < s; i++) { ` ` `  `        ``// the required part ` `        ``int` `el = n - (v1[i]); ` ` `  `        ``// if the required part is also  ` `        ``// present in pair sum ` `        ``if` `(mpp[el] == 1) { ` ` `  `            ``// find the elements with ` `            ``// which the first pair is formed ` `            ``int` `a = mp1[v1[i]].first; ` `            ``int` `b = mp1[v1[i]].second; ` ` `  `            ``// find the elements with ` `            ``// which the second pair is formed ` `            ``int` `c = mp1[n - v1[i]].first; ` `            ``int` `d = mp1[n - v1[i]].second; ` ` `  `            ``// check for previous maximum ` `            ``maxi = max(a * b * c * d, maxi); ` `        ``} ` `    ``} ` ` `  `    ``if` `(maxi == -1) ` `        ``cout << ``"Not Possible\n"``; ` `    ``else` `{ ` `        ``cout << ``"The maximum product is "` `<< maxi << endl; ` `    ``} ` `} ` ` `  `// Driver code ` `int` `main() ` `{ ` `    ``int` `n = 50; ` ` `  `    ``findfactors(n); ` ` `  `    ``return` `0; ` `} `

## Java

 `// Java program to find four factors of N ` `// with maximum product and sum equal to N ` `import` `java.util.*; ` `import` `java.lang.*; ` `import` `java.io.*; ` ` `  `class` `GFG ` `{ ` `     `  `// Function to find factors ` `// and to print those four factors ` `static` `void` `findfactors(``int` `n) ` `{ ` `    ``HashMap mpp = ``new` `HashMap<>(); ` ` `  `    ``Vector v = ``new` `Vector(), ` `                   ``v1 = ``new` `Vector(); ` ` `  `    ``// push all the factors in the container ` `    ``for` `(``int` `i = ``1``; i <= (``int``)Math.sqrt(n); i++)  ` `    ``{ ` `        ``if` `(n % i == ``0``) ` `        ``{ ` `            ``v.add(i); ` `            ``if` `(i != (n / i) && i != ``1``) ` `                ``v.add(n / i); ` `        ``} ` `    ``} ` ` `  `    ``// number of factors ` `    ``int` `s = v.size(); ` ` `  `    ``// Initial maximum ` `    ``int` `maxi = -``1``; ` ` `  `    ``// hash-array to mark the ` `    ``// pairs ` `    ``int` `mp1_first[] = ``new` `int``[n + ``5``],  ` `        ``mp1_second[] = ``new` `int``[n + ``5``]; ` ` `  `    ``for` `(``int` `i = ``0``; i < s; i++) ` `    ``{ ` ` `  `        ``// form all the pair sums ` `        ``for` `(``int` `j = i; j < s; j++) ` `        ``{ ` ` `  `            ``// if the pair sum is less than n ` `            ``if` `(v.get(i) + v.get(j) < n) ` `            ``{ ` ` `  `                ``// push in another container ` `                ``v1.add(v.get(i) + v.get(j)); ` ` `  `                ``// mark the sum with the elements  ` `                ``// formed ` `                ``mp1_first[v.get(i) +  ` `                          ``v.get(j)] = v.get(i); ` `                ``mp1_second[v.get(i) +  ` `                           ``v.get(j)] = v.get(j); ` ` `  `                ``// mark in the map that  ` `                ``// v.get(i)+v.get(j) is present ` `                ``mpp.put(v.get(i) + v.get(j), ``1``); ` `            ``} ` `        ``} ` `    ``} ` ` `  `    ``// new size of all the pair sums ` `    ``s = v1.size(); ` ` `  `    ``// iterate for all pair sum ` `    ``for` `(``int` `i = ``0``; i < s; i++)  ` `    ``{ ` ` `  `        ``// the required part ` `        ``int` `el = n - (v1.get(i)); ` ` `  `        ``// if the required part is also  ` `        ``// present in pair sum ` `        ``if` `(mpp.get(el) != ``null``)  ` `        ``{ ` ` `  `            ``// find the elements with ` `            ``// which the first pair is formed ` `            ``int` `a = mp1_first[v1.get(i)]; ` `            ``int` `b = mp1_second[v1.get(i)]; ` ` `  `            ``// find the elements with ` `            ``// which the second pair is formed ` `            ``int` `c = mp1_first[n - v1.get(i)]; ` `            ``int` `d = mp1_second[n - v1.get(i)]; ` ` `  `            ``// check for previous maximum ` `            ``maxi = Math.max(a * b * c * d, maxi); ` `        ``} ` `    ``} ` ` `  `    ``if` `(maxi == -``1``) ` `        ``System.out.println(``"Not Possible"``); ` `    ``else`  `    ``{ ` `        ``System.out.println(``"The maximum product"` `+  ` `                                   ``" is "` `+ maxi); ` `    ``} ` `} ` ` `  `// Driver code ` `public` `static` `void` `main(String args[]) ` `{ ` `    ``int` `n = ``50``; ` ` `  `    ``findfactors(n); ` `} ` `} ` ` `  `// This code is contributed by Arnab Kundu `

## Python3

 `# Python3 program to find four factors of N ` `# with maximum product and sum equal to N ` `from` `math ``import` `sqrt, ceil, floor ` ` `  `# Function to find factors ` `# and to prthose four factors ` `def` `findfactors(n): ` `    ``mpp ``=` `dict``() ` ` `  `    ``v ``=` `[] ` `    ``v1 ``=` `[] ` ` `  `    ``# push all the factors in the container ` `    ``for` `i ``in` `range``(``1``,ceil(sqrt(n)) ``+` `1``): ` `        ``if` `(n ``%` `i ``=``=` `0``): ` `            ``v.append(i) ` `            ``if` `(i !``=` `(n ``/``/` `i) ``and` `i !``=` `1``): ` `                ``v.append(n ``/``/` `i) ` ` `  `    ``# number of factors ` `    ``s ``=` `len``(v) ` ` `  `    ``# Initial maximum ` `    ``maxi ``=` `-``1` ` `  `    ``# hash-array to mark the ` `    ``# pairs ` `    ``mp1 ``=` `[``0``]``*``(n ``+` `5``) ` ` `  `    ``for` `i ``in` `range``(s): ` ` `  `        ``# form all the pair sums ` `        ``for` `j ``in` `range``(i, s): ` ` `  `            ``# if the pair sum is less than n ` `            ``if` `(v[i] ``+` `v[j] < n): ` ` `  `                ``# push in another container ` `                ``v1.append(v[i] ``+` `v[j]) ` ` `  `                ``# mark the sum with the elements ` `                ``# formed ` `                ``mp1[v[i] ``+` `v[j]] ``=``[v[i], v[j]] ` ` `  `                ``# mark in the map that v[i]+v[j] ` `                ``# is present ` `                ``mpp[v[i] ``+` `v[j]] ``=` `1` ` `  ` `  `    ``# new size of all the pair sums ` `    ``s ``=` `len``(v1) ` ` `  `    ``# iterate for all pair sum ` `    ``for` `i ``in` `range``(s): ` ` `  `        ``# the required part ` `        ``el ``=` `n ``-` `(v1[i]) ` ` `  `        ``# if the required part is also ` `        ``# present in pair sum ` `        ``if` `(el ``in` `mpp): ` ` `  `            ``# find the elements with ` `            ``# which the first pair is formed ` `            ``a ``=` `mp1[v1[i]][``0``] ` `            ``b ``=` `mp1[v1[i]][``1``] ` ` `  `            ``# find the elements with ` `            ``# which the second pair is formed ` `            ``c ``=` `mp1[n ``-` `v1[i]][``0``] ` `            ``d ``=` `mp1[n ``-` `v1[i]][``1``] ` ` `  `            ``# check for previous maximum ` `            ``maxi ``=` `max``(a ``*` `b ``*` `c ``*` `d, maxi) ` ` `  `    ``if` `(maxi ``=``=` `-``1``): ` `        ``print``(``"Not Possible"``) ` `    ``else` `: ` `        ``print``(``"The maximum product is "``, maxi) ` ` `  `# Driver code ` `n ``=` `50` ` `  `findfactors(n) ` ` `  `# This code is contributed by mohit kumar 29 `

## C#

 `// C# program to find four factors of N ` `// with maximum product and sum equal to N ` `using` `System; ` `using` `System.Collections.Generic; ` ` `  `class` `GFG ` `{ ` `     `  `// Function to find factors ` `// and to print those four factors ` `static` `void` `findfactors(``int` `n) ` `{ ` `    ``Dictionary<``int``, ` `            ``int``> mpp = ``new` `Dictionary<``int``,``int``>(); ` ` `  `    ``List<``int``> v = ``new` `List<``int``>(), ` `                ``v1 = ``new` `List<``int``>(); ` ` `  `    ``// push all the factors in the container ` `    ``for` `(``int` `i = 1; i <= (``int``)Math.Sqrt(n); i++)  ` `    ``{ ` `        ``if` `(n % i == 0) ` `        ``{ ` `            ``v.Add(i); ` `            ``if` `(i != (n / i) && i != 1) ` `                ``v.Add(n / i); ` `        ``} ` `    ``} ` ` `  `    ``// number of factors ` `    ``int` `s = v.Count; ` ` `  `    ``// Initial maximum ` `    ``int` `maxi = -1; ` ` `  `    ``// hash-array to mark the ` `    ``// pairs ` `    ``int` `[]mp1_first = ``new` `int``[n + 5];  ` `    ``int` `[]mp1_second = ``new` `int``[n + 5]; ` ` `  `    ``for` `(``int` `i = 0; i < s; i++) ` `    ``{ ` ` `  `        ``// form all the pair sums ` `        ``for` `(``int` `j = i; j < s; j++) ` `        ``{ ` ` `  `            ``// if the pair sum is less than n ` `            ``if` `(v[i] + v[j] < n) ` `            ``{ ` ` `  `                ``// push in another container ` `                ``v1.Add(v[i] + v[j]); ` ` `  `                ``// mark the sum with the elements  ` `                ``// formed ` `                ``mp1_first[v[i] +  ` `                        ``v[j]] = v[i]; ` `                ``mp1_second[v[i] +  ` `                        ``v[j]] = v[j]; ` ` `  `                ``// mark in the map that  ` `                ``// v[i]+v[j] is present ` `                ``mpp.Add(v[i] + v[j], 1); ` `            ``} ` `        ``} ` `    ``} ` ` `  `    ``// new size of all the pair sums ` `    ``s = v1.Count; ` ` `  `    ``// iterate for all pair sum ` `    ``for` `(``int` `i = 0; i < s; i++)  ` `    ``{ ` ` `  `        ``// the required part ` `        ``int` `el = n - (v1[i]); ` ` `  `        ``// if the required part is also  ` `        ``// present in pair sum ` `        ``if` `(mpp.ContainsKey(el))  ` `        ``{ ` ` `  `            ``// find the elements with ` `            ``// which the first pair is formed ` `            ``int` `a = mp1_first[v1[i]]; ` `            ``int` `b = mp1_second[v1[i]]; ` ` `  `            ``// find the elements with ` `            ``// which the second pair is formed ` `            ``int` `c = mp1_first[n - v1[i]]; ` `            ``int` `d = mp1_second[n - v1[i]]; ` ` `  `            ``// check for previous maximum ` `            ``maxi = Math.Max(a * b * c * d, maxi); ` `        ``} ` `    ``} ` ` `  `    ``if` `(maxi == -1) ` `        ``Console.WriteLine(``"Not Possible"``); ` `    ``else` `    ``{ ` `        ``Console.WriteLine(``"The maximum product"` `+  ` `                                ``" is "` `+ maxi); ` `    ``} ` `} ` ` `  `// Driver code ` `public` `static` `void` `Main(String []args) ` `{ ` `    ``int` `n = 50; ` ` `  `    ``findfactors(n); ` `} ` `} ` ` `  `// This code is contributed by PrinciRaj1992 `

Output:

```The maximum product is 12500
```

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.

My Personal Notes arrow_drop_up Striver(underscore)79 at Codechef and codeforces D

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.

Article Tags :

2

Please write to us at contribute@geeksforgeeks.org to report any issue with the above content.