 GeeksforGeeks App
Open App Browser
Continue

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

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`

Time Complexity: O(sqrt(n)+m2)  where m is the number of factors of n.

Auxiliary Space: O(m)

My Personal Notes arrow_drop_up