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

• Last Updated : 14 Feb, 2022

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.```

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 print those 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`

## Javascript

 ``

Output:

`The maximum product is 12500`

My Personal Notes arrow_drop_up
Recommended Articles
Page :