# Divide N into K unique parts such that gcd of those parts is maximum

Given a positive integer N, the task is to divide it into K unique parts such that the sum of these parts is equal to the original number and the gcd of all the parts is maximum. Print the maximum gcd if such a division exists else print -1.

Examples:

Input: N = 6, K = 3
Output: 1
Only possible division with unique
elements is (1, 2, 3) and gcd(1, 2, 3) = 1.

Input: N = 18, K = 3
Output: 3

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

Naive approach: Find all the possible divisions of N and compute the maximum gcd of them. But this approach will take exponential time and space.

Efficient approach: Let the divisions of N be A1, A2……..AK
Now, it is known that gcd(a, b) = gcd(a, b, a + b) and hence, gcd(A1, A2….AK) = gcd(A1, A2….AK, A1 + A2…. + AK)
But A1 + A2…. + AK = N and hence, the gcd of the divisions will be one of the factors of N.
Let a be the factor of N which can be the possible answer:
Since a is the gcd, all the division will be the multiples of a and hence, for K unique Bi,
a * B1 + a * B2……. + a * BK = N
a * (B1 + B2…….+ BK) = N
Since all the Bi are unique,
B1 + B2…….+ BK ≥ 1 + 2 + 3 ….. + K
B1 + B2…….+ BK ≥ K * (K + 1) / 2
Hence, all the factors of N whose complementary factor is greater than or equal to K * (K + 1) / 2 can be one of the possible answers and we have take to the maximum of all the possible answers.

Below is the implementation of the above approach:

## CPP

 `// C++ implementation of the approach ` `#include ` `using` `namespace` `std; ` ` `  `// Function to calculate maximum GCD ` `int` `maxGCD(``int` `N, ``int` `K) ` `{ ` ` `  `    ``// Minimum possible sum for ` `    ``// K unique positive integers ` `    ``int` `minSum = (K * (K + 1)) / 2; ` ` `  `    ``// It is not possible to divide ` `    ``// N into K unique parts ` `    ``if` `(N < minSum) ` `        ``return` `-1; ` ` `  `    ``// All the factors greater than sqrt(N) ` `    ``// are complementary of the factors less ` `    ``// than sqrt(N) ` `    ``int` `i = ``sqrt``(N); ` `    ``int` `res = 1; ` `    ``while` `(i >= 1) { ` ` `  `        ``// If i is a factor of N ` `        ``if` `(N % i == 0) { ` `            ``if` `(i >= minSum) ` `                ``res = max(res, N / i); ` ` `  `            ``if` `(N / i >= minSum) ` `                ``res = max(res, i); ` `        ``} ` `        ``i--; ` `    ``} ` ` `  `    ``return` `res; ` `} ` ` `  `// Driver code ` `int` `main() ` `{ ` `    ``int` `N = 18, K = 3; ` ` `  `    ``cout << maxGCD(N, K); ` ` `  `    ``return` `0; ` `} `

## Java

 `// Java implementation of the approach ` `import` `java.io.*; ` `import` `java.lang.Math;  ` ` `  `class` `GFG ` `{ ` `    ``// Function to calculate maximum GCD ` `    ``static` `int` `maxGCD(``int` `N, ``int` `K) ` `    ``{ ` ` `  `        ``// Minimum possible sum for ` `        ``// K unique positive integers ` `        ``int` `minSum = (K * (K + ``1``)) / ``2``; ` ` `  `        ``// It is not possible to divide ` `        ``// N into K unique parts ` `        ``if` `(N < minSum) ` `            ``return` `-``1``; ` ` `  `        ``// All the factors greater than sqrt(N) ` `        ``// are complementary of the factors less ` `        ``// than sqrt(N) ` `        ``int` `i = (``int``) Math.sqrt(N); ` `        ``int` `res = ``1``; ` `        ``while` `(i >= ``1``) ` `        ``{ ` ` `  `            ``// If i is a factor of N ` `            ``if` `(N % i == ``0``) ` `            ``{ ` `                ``if` `(i >= minSum) ` `                    ``res = Math.max(res, N / i); ` ` `  `                ``if` `(N / i >= minSum) ` `                    ``res = Math.max(res, i); ` `            ``} ` `            ``i--; ` `        ``} ` ` `  `        ``return` `res; ` `    ``} ` ` `  `    ``// Driver code ` `    ``public` `static` `void` `main (String[] args) ` `    ``{ ` `        ``int` `N = ``18``, K = ``3``; ` ` `  `        ``System.out.println(maxGCD(N, K)); ` `    ``} ` `} ` ` `  `// This code is contributed by ApurvaRaj `

## Python

 `# Python3 implementation of the approach ` `from` `math ``import` `sqrt,ceil,floor ` ` `  `# Function to calculate maximum GCD ` `def` `maxGCD(N, K): ` ` `  `    ``# Minimum possible sum for ` `    ``# K unique positive integers ` `    ``minSum ``=` `(K ``*` `(K ``+` `1``)) ``/` `2` ` `  `    ``# It is not possible to divide ` `    ``# N into K unique parts ` `    ``if` `(N < minSum): ` `        ``return` `-``1` ` `  `    ``# All the factors greater than sqrt(N) ` `    ``# are complementary of the factors less ` `    ``# than sqrt(N) ` `    ``i ``=` `ceil(sqrt(N)) ` `    ``res ``=` `1` `    ``while` `(i >``=` `1``): ` ` `  `        ``# If i is a factor of N ` `        ``if` `(N ``%` `i ``=``=` `0``): ` `            ``if` `(i >``=` `minSum): ` `                ``res ``=` `max``(res, N ``/` `i) ` ` `  `            ``if` `(N ``/` `i >``=` `minSum): ` `                ``res ``=` `max``(res, i) ` ` `  `        ``i``-``=``1` ` `  `    ``return` `res ` ` `  `# Driver code ` ` `  `N ``=` `18` `K ``=` `3` ` `  `print``(maxGCD(N, K)) ` ` `  `# This code is contributed by mohit kumar 29 `

## C#

 `// C# implementation of the approach ` `using` `System; ` ` `  `class` `GFG ` `{ ` `    ``// Function to calculate maximum GCD ` `    ``static` `int` `maxGCD(``int` `N, ``int` `K) ` `    ``{ ` ` `  `        ``// Minimum possible sum for ` `        ``// K unique positive integers ` `        ``int` `minSum = (K * (K + 1)) / 2; ` ` `  `        ``// It is not possible to divide ` `        ``// N into K unique parts ` `        ``if` `(N < minSum) ` `            ``return` `-1; ` ` `  `        ``// All the factors greater than sqrt(N) ` `        ``// are complementary of the factors less ` `        ``// than sqrt(N) ` `        ``int` `i = (``int``) Math.Sqrt(N); ` `        ``int` `res = 1; ` `        ``while` `(i >= 1) ` `        ``{ ` ` `  `            ``// If i is a factor of N ` `            ``if` `(N % i == 0) ` `            ``{ ` `                ``if` `(i >= minSum) ` `                    ``res = Math.Max(res, N / i); ` ` `  `                ``if` `(N / i >= minSum) ` `                    ``res = Math.Max(res, i); ` `            ``} ` `            ``i--; ` `        ``} ` `        ``return` `res; ` `    ``} ` ` `  `    ``// Driver code ` `    ``public` `static` `void` `Main() ` `    ``{ ` `        ``int` `N = 18, K = 3; ` ` `  `        ``Console.WriteLine(maxGCD(N, K)); ` `    ``} ` `} ` ` `  `// This code is contributed by AnkitRai01 `

Output:

```3
``` My Personal Notes arrow_drop_up Check out this Author's contributed articles.

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.