Related Articles

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

• Last Updated : 21 May, 2021

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

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++

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

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

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

## C#

 `// C# implementation of above approach``using` `System;``using` `System.Collections.Generic;` `class` `GFG``{` `// Function to find primes``static` `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``;``}` `static` `List > v = ``new` `List >();` `// 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[i].Add(j);` `                ``// otherwise push it's two divisors``                ``else``                ``{``                    ``v[i].Add(j);``                    ``v[i].Add(i / j);``                ``}``            ``}``        ``}` `        ``// sort the divisors``        ``v[i].Sort();``    ``}``}` `// 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` `List<``int``>());` `    ``// 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[n].Count > 2)``            ``{` `                ``// include last third factor``                ``int` `fac = v[n][v[n].Count - 3];` `                ``// nested loop to find other two factors``                ``for` `(``int` `i = v[n].Count - 1; i >= 0; i--)``                ``{``                    ``for` `(``int` `j = v[n].Count - 1; j >= 0; j--)``                    ``{``                        ``if` `((fac * 2) + (v[n][j] +``                                        ``v[n][i]) == n)``                            ``ans = Math.Max(ans, fac * fac *``                                        ``v[n][j] *``                                        ``v[n][i]);``                    ``}``                ``}``                ``return` `ans;``            ``}``        ``}``    ``}``    ``return` `0;``}` `// Driver code``public` `static` `void` `Main(String []args)``{``    ``int` `n = 24;` `    ``// function call``    ``Console.WriteLine( product(n));``}``}` `// This code is contributed by 29AjayKumar`

## Javascript

 ``
Output:
`1296`

Attention reader! Don’t stop learning now. Get hold of all the important mathematical concepts for competitive programming with the Essential Maths for CP Course at a student-friendly price. To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

My Personal Notes arrow_drop_up