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

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

1. Sum of the four factors is equal to N.
2. The 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 and there can be a large number of queries.

Examples:

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

The idea is to find factors of all numbers from 1 to N ( which is the maximum value of n ).

• An answer will be Not possible if the given is prime.
• And if the given n is divisible by 4 then answer will be pow(q, 4) where q is a quotient when n is divided by 4.
• If it is possible to find the answer then, the answer must include third last factor two times. And run a nested loop for other two factors.

Below is the implementation of the above approach:

 `// C++ implementation of above approach ` `#include ` `using` `namespace` `std; ` ` `  `// Function to find primes ` `bool` `isPrime(``int` `n) ` `{ ` `    ``// Corner cases ` `    ``if` `(n <= 1) ` `        ``return` `false``; ` `    ``if` `(n <= 3) ` `        ``return` `true``; ` ` `  `    ``// This is checked so that we can skip ` `    ``// middle five numbers in below loop ` `    ``if` `(n % 2 == 0 || n % 3 == 0) ` `        ``return` `false``; ` ` `  `    ``for` `(``int` `i = 5; i * i <= n; i = i + 6) ` `        ``if` `(n % i == 0 || n % (i + 2) == 0) ` `            ``return` `false``; ` ` `  `    ``return` `true``; ` `} ` ` `  `// Function to find factors ` `void` `factors(``int` `N, vector<``int``>& v[]) ` `{ ` `    ``for` `(``int` `i = 2; i < N; i++) { ` ` `  `        ``// run a loop upto square root of that number ` `        ``for` `(``int` `j = 1; j * j <= i; j++) { ` `            ``if` `(i % j == 0) { ` ` `  `                ``// if the n is perfect square ` `                ``if` `(i / j == j) ` `                    ``v[i].push_back(j); ` ` `  `                ``// otherwise push it's two divisors ` `                ``else` `{ ` `                    ``v[i].push_back(j); ` `                    ``v[i].push_back(i / j); ` `                ``} ` `            ``} ` `        ``} ` ` `  `        ``// sort the divisors ` `        ``sort(v[i].begin(), v[i].end()); ` `    ``} ` `} ` ` `  `// Function to find max product ` `int` `product(``int` `n) ` `{ ` `    ``// To store factors of 'n' ` `    ``vector<``int``> v[n + 100]; ` ` `  `    ``// find factors ` `    ``factors(n + 100, v); ` ` `  `    ``// if it is divisible by 4. ` `    ``if` `(n % 4 == 0) { ` `        ``int` `x = n / 4; ` `        ``x *= x; ` `        ``return` `x * x; ` `    ``} ` ` `  `    ``else` `{ ` ` `  `        ``// if it is prime ` `        ``if` `(isPrime[n]) ` `            ``return` `-1; ` ` `  `        ``// otherwise answer will be possible ` `        ``else` `{ ` `            ``int` `ans = -1; ` `            ``if` `(v[n].size() > 2) { ` ` `  `                ``// include last third factor ` `                ``int` `fac = v[n][v[n].size() - 3]; ` ` `  `                ``// nested loop to find other two factors ` `                ``for` `(``int` `i = v[n].size() - 1; i >= 0; i--) { ` `                    ``for` `(``int` `j = v[n].size() - 1; j >= 0; j--) { ` `                        ``if` `((fac * 2) + (v[n][j] + v[n][i]) == n) ` `                            ``ans = max(ans, fac * fac * v[n][j] * v[n][i]); ` `                    ``} ` `                ``} ` ` `  `                ``return` `ans; ` `            ``} ` `        ``} ` `    ``} ` `} ` ` `  `// Driver code ` `int` `main() ` `{ ` ` `  `    ``int` `n = 24; ` ` `  `    ``// function call ` `    ``cout << product(n); ` ` `  `    ``return` `0; ` `} `

 `// Java implementation of above approach ` `import` `java.util.*; ` `import` `java.lang.*; ` `import` `java.io.*; ` ` `  `class` `GFG ` `{ ` ` `  `// Function to find primes ` `static` `boolean` `isPrime(``int` `n) ` `{ ` `    ``// Corner cases ` `    ``if` `(n <= ``1``) ` `        ``return` `false``; ` `    ``if` `(n <= ``3``) ` `        ``return` `true``; ` ` `  `    ``// This is checked so that we can skip ` `    ``// middle five numbers in below loop ` `    ``if` `(n % ``2` `== ``0` `|| n % ``3` `== ``0``) ` `        ``return` `false``; ` ` `  `    ``for` `(``int` `i = ``5``; i * i <= n; i = i + ``6``) ` `        ``if` `(n % i == ``0` `|| n % (i + ``2``) == ``0``) ` `            ``return` `false``; ` ` `  `    ``return` `true``; ` `} ` ` `  `static` `Vector > v = ``new` `Vector >(); ` ` `  `// Function to find factors ` `static` `void` `factors(``int` `N ) ` `{ ` `    ``for` `(``int` `i = ``2``; i < N; i++) ` `    ``{ ` ` `  `        ``// run a loop upto square root of that number ` `        ``for` `(``int` `j = ``1``; j * j <= i; j++) ` `        ``{ ` `            ``if` `(i % j == ``0``)  ` `            ``{ ` ` `  `                ``// if the n is perfect square ` `                ``if` `(i / j == j) ` `                    ``v.get(i).add(j); ` ` `  `                ``// otherwise push it's two divisors ` `                ``else`  `                ``{ ` `                    ``v.get(i).add(j); ` `                    ``v.get(i).add(i / j); ` `                ``} ` `            ``} ` `        ``} ` ` `  `        ``// sort the divisors ` `        ``Collections.sort(v.get(i)); ` `    ``} ` `} ` ` `  `// Function to find max product ` `static` `int` `product(``int` `n) ` `{ ` `    ``// To store factors of 'n' ` `    ``v.clear(); ` `    ``for``(``int` `i = ``0``; i < n + ``100``; i++) ` `        ``v.add(``new` `Vector()); ` ` `  `    ``// find factors ` `    ``factors(n + ``100``); ` ` `  `    ``// if it is divisible by 4. ` `    ``if` `(n % ``4` `== ``0``)   ` `    ``{ ` `        ``int` `x = n / ``4``; ` `        ``x *= x; ` `        ``return` `x * x; ` `    ``} ` ` `  `    ``else` `    ``{ ` ` `  `        ``// if it is prime ` `        ``if` `(isPrime(n)) ` `            ``return` `-``1``; ` ` `  `        ``// otherwise answer will be possible ` `        ``else`  `        ``{ ` `            ``int` `ans = -``1``; ` `            ``if` `(v.get(n).size() > ``2``)  ` `            ``{ ` ` `  `                ``// include last third factor ` `                ``int` `fac = v.get(n).get(v.get(n).size() - ``3``); ` ` `  `                ``// nested loop to find other two factors ` `                ``for` `(``int` `i = v.get(n).size() - ``1``; i >= ``0``; i--) ` `                ``{ ` `                    ``for` `(``int` `j = v.get(n).size() - ``1``; j >= ``0``; j--)  ` `                    ``{ ` `                        ``if` `((fac * ``2``) + (v.get(n).get(j) +  ` `                                         ``v.get(n).get(i)) == n) ` `                            ``ans = Math.max(ans, fac * fac *  ` `                                          ``v.get(n).get(j) *  ` `                                          ``v.get(n).get(i)); ` `                    ``} ` `                ``} ` `                ``return` `ans; ` `            ``} ` `        ``} ` `    ``} ` `    ``return` `0``; ` `} ` ` `  `// Driver code ` `public` `static` `void` `main(String args[]) ` `{ ` `    ``int` `n = ``24``; ` ` `  `    ``// function call ` `    ``System.out.println( product(n)); ` `} ` `} ` ` `  `// This code is contributed by Arnab Kundu `

 `# Python3 implementation of above approach ` ` `  `from` `math ``import` `sqrt, ceil, floor ` ` `  `# Function to find primes ` `def` `isPrime(n): ` `     `  `    ``# Corner cases ` `    ``if` `(n <``=` `1``): ` `        ``return` `False` `    ``if` `(n <``=` `3``): ` `        ``return` `True` ` `  `    ``# This is checked so that we can skip ` `    ``# middle five numbers in below loop ` `    ``if` `(n ``%` `2` `=``=` `0` `or` `n ``%` `3` `=``=` `0``): ` `        ``return` `False` ` `  `    ``for` `i ``in` `range``(``5``, ceil(sqrt(n)), ``6``): ` `        ``if` `(n ``%` `i ``=``=` `0` `or` `n ``%` `(i ``+` `2``) ``=``=` `0``): ` `            ``return` `False` ` `  `    ``return` `True` ` `  `# Function to find factors ` `def` `factors(N, v): ` `    ``for` `i ``in` `range``(``2``, N): ` ` `  `        ``# run a loop upto square root of that number ` `        ``for` `j ``in` `range``(``1``,ceil(sqrt(i)) ``+` `1``): ` `            ``if` `(i ``%` `j ``=``=` `0``): ` ` `  `                ``# if the n is perfect square ` `                ``if` `(i ``/``/` `j ``=``=` `j): ` `                    ``v[i].append(j) ` ` `  `                ``# otherwise push it's two divisors ` `                ``else``: ` `                    ``v[i].append(j) ` `                    ``v[i].append(i ``/``/` `j) ` ` `  `        ``# sort the divisors ` `        ``v ``=` `sorted``(v) ` ` `  `# Function to find max product ` `def` `product(n): ` `     `  `    ``# To store factors of 'n' ` `    ``v ``=` `[[]] ``*` `(n ``+` `100``) ` ` `  `    ``# find factors ` `    ``factors(n ``+` `100``, v) ` ` `  `    ``# if it is divisible by 4. ` `    ``if` `(n ``%` `4` `=``=` `0``): ` `        ``x ``=` `n ``/``/` `4` `        ``x ``*``=` `x ` `        ``return` `x ``*` `x ` ` `  `    ``else` `: ` ` `  `        ``# if it is prime ` `        ``if` `(isPrime[n]): ` `            ``return` `-``1` ` `  `        ``# otherwise answer will be possible ` `        ``else` `: ` `            ``ans ``=` `-``1` `            ``if` `(``len``(v[n]) > ``2``): ` ` `  `                ``# include last third factor ` `                ``fac ``=` `v[n][``len``(v[n]) ``-` `3``] ` ` `  `                ``# nested loop to find other two factors ` `                ``for` `i ``in` `range``(``len``(v[n] ``-` `1``), ``-``1``, ``-``1``): ` `                    ``for` `j ``in` `range``(``len``(v[n] ``-` `1``), ``-``1``, ``-``1``): ` `                        ``if` `((fac ``*` `2``) ``+` `(v[n][j] ``+` `v[n][i]) ``=``=` `n): ` `                            ``ans ``=` `max``(ans, fac ``*` `fac ``*` `v[n][j] ``*` `v[n][i]) ` ` `  `                ``return` `ans ` ` `  `# Driver code ` `n ``=` `24` ` `  `# function call ` `print``(product(n)) ` ` `  `# This code is contributed by mohit kumar 29 `

Output:
```1296
```

pawanasipugmailcom

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.

Improved By : andrew1234, mohit kumar 29

Article Tags :
Practice Tags :