Related Articles
Series with largest GCD and sum equals to n
• Difficulty Level : Hard
• Last Updated : 26 Mar, 2021

Given an integer n, print m increasing numbers such that the sum of m numbers is equal to n and the GCD of m numbers is maximum among all series possible. If no series is possible then print “-1”.
Examples :

```Input  : n = 24,
m = 3
Output : 4 8 12
Explanation : (3, 6, 15) is also a series
of m numbers which sums to N, but gcd = 3
(4, 8, 12) has gcd = 4 which is the maximum
possible.

Input  : n = 6
m = 4
Output : -1
Explanation: It is not possible as the
least GCD sequence will be 1+2+3+4 which
is greater then n, hence print -1.```

Approach:
The most common observation is that the gcd of the series will always be a divisor of n. The maximum gcd possible (say b) will be n/sum, where sum is the sum of 1+2+..m.
If b turns out to be 0, then the sum of 1+2+3..+k exceeds n which is invalid, hence output “-1”.
Traverse to find out all the divisors possible, a loop till sqrt(n). If the current divisor is i, the best possible way to take the series will be to consider i, 2*i, 3*i, …(m-1)*i, and their sum is s which is equal to i * (m*(m-1))/2 . The last number will be n-s.
Along with i being the divisor, n/i will be the other divisor so check for that also.
Take maximum of possible divisor possible (say r) which should be less then or equals to b and print the sequence as r, 2*r, … (m-1)*r, n—s.
If no such divisors are found simply output “-1”.

## C++

 `// CPP program to find the series with largest``// GCD and sum equals to n``#include ``using` `namespace` `std;` `// function to generate and print the sequence``void` `print_sequence(``int` `n, ``int` `k)``{``    ``// stores the maximum gcd that can be``    ``// possible of sequence.``    ``int` `b = n / (k * (k + 1) / 2);` `    ``// if maximum gcd comes out to be``    ``// zero then not possible``    ``if` `(b == 0) {``        ``cout << -1 << endl;` `    ``} ``else` `{` `        ``// the smallest gcd possible is 1``        ``int` `r = 1;` `        ``// traverse the array to find out``        ``// the max gcd possible``        ``for` `(``int` `x = 1; x * x <= n; x++) {` `            ``// checks if the number is``            ``// divisible or not``            ``if` `(n % x != 0)``                ``continue``;` `            ``// checks if x is smaller then``            ``// the max gcd possible and x``            ``// is greater then the resultant``            ``// gcd till now, then r=x``            ``if` `(x <= b && x > r)``                ``r = x;` `            ``// checks if n/x is smaller than``            ``// the max gcd possible and n/x``            ``// is greater then the resultant``            ``// gcd till now, then r=x``            ``if` `(n / x <= b && n / x > r)``                ``r = n / x;``        ``}` `        ``// traverses and prints d, 2d, 3d,``        ``// ..., (k-1)·d,``        ``for` `(``int` `i = 1; i < k; i++)``            ``cout << r * i << ``" "``;` `        ``// computes the last element of``        ``// the sequence n-s.``        ``int` `res = n - (r * (k * (k - 1) / 2));` `        ``// prints the last element``        ``cout << res << endl;``    ``}``}` `// driver program to test the above function``int` `main()``{``    ``int` `n = 24;``    ``int` `k = 4;``    ``print_sequence(n, k);` `    ``n = 24, k = 5;``    ``print_sequence(n, k);` `    ``n = 6, k = 4;``    ``print_sequence(n, k);``}`

## Java

 `// Java program to find the series with``// largest GCD and sum equals to n``import` `java.io.*;` `class` `GFG {` `// function to generate and print the sequence``static` `void` `print_sequence(``int` `n, ``int` `k)``{``    ``// stores the maximum gcd that can be``    ``// possible of sequence.``    ``int` `b = n / (k * (k + ``1``) / ``2``);` `    ``// if maximum gcd comes out to be``    ``// zero then not possible``    ``if` `(b == ``0``) {``        ``System.out.println(``"-1"``);` `    ``} ``else` `{` `        ``// the smallest gcd possible is 1``        ``int` `r = ``1``;` `        ``// traverse the array to find out``        ``// the max gcd possible``        ``for` `(``int` `x = ``1``; x * x <= n; x++) {` `            ``// checks if the number is``            ``// divisible or not``            ``if` `(n % x != ``0``)``                ``continue``;` `            ``// checks if x is smaller then``            ``// the max gcd possible and x``            ``// is greater then the resultant``            ``// gcd till now, then r=x``            ``if` `(x <= b && x > r)``                ``r = x;` `            ``// checks if n/x is smaller than``            ``// the max gcd possible and n/x``            ``// is greater then the resultant``            ``// gcd till now, then r=x``            ``if` `(n / x <= b && n / x > r)``                ``r = n / x;``        ``}` `        ``// traverses and prints d, 2d, 3d,..., (k-1)``        ``for` `(``int` `i = ``1``; i < k; i++)``            ``System.out.print(r * i + ``" "``);` `        ``// computes the last element of``        ``// the sequence n-s.``        ``int` `res = n - (r * (k * (k - ``1``) / ``2``));` `        ``// prints the last element``        ``System.out.println(res);``    ``}``}` `// driver program to test the above function``public` `static` `void` `main(String[] args)``{``    ``int` `n = ``24``;``    ``int` `k = ``4``;``    ``print_sequence(n, k);` `    ``n = ``24``; k = ``5``;``    ``print_sequence(n, k);` `    ``n = ``6``; k = ``4``;``    ``print_sequence(n, k);``}``}` `// This code is contributed by Prerna Saini`

## Python3

 `# Python3 code to find the series``# with largest GCD and sum equals to n` `def` `print_sequence(n, k):``    ` `    ``# stores the maximum gcd that``    ``# can be possible of sequence.``    ` `    ``b ``=` `int``(n ``/` `(k ``*` `(k ``+` `1``) ``/` `2``));``    `  `    ``# if maximum gcd comes out to be``    ``# zero then not possible``    ` `    ``if` `b ``=``=` `0``:``        ``print` `(``"-1"``)` `    ``else``:``        ``# the smallest gcd possible is 1``        ``r ``=` `1``;` `        ``# traverse the array to find out``        ``# the max gcd possible``        ``x ``=` `1``        ` `        ``while` `x ``*``*` `2` `<``=` `n:``            ` `            ``# checks if the number is``            ``# divisible or not``            ``if` `n ``%` `x !``=` `0``:``            ` `                ``# x = x + 1``                ``continue``;``                ` `            ` `            ``# checks if x is smaller then``            ``# the max gcd possible and x``            ``# is greater then the resultant``            ``# gcd till now, then r=x``            ``elif` `x <``=` `b ``and` `x > r:``                ``r ``=` `x``                ``# x = x + 1` `            ``# checks if n/x is smaller than``            ``# the max gcd possible and n/x``            ``# is greater then the resultant``            ``# gcd till now, then r=x``            ``elif` `n ``/` `x <``=` `b ``and` `n ``/` `x > r :``                ``r ``=` `n ``/` `x``                ``# x = x + 1``                ` `            ``x ``=` `x ``+` `1``        `  `    ``# traverses and prints d, 2d, 3d,``    ``# ..., (k-1)·d,``        ``i ``=` `1``        ``while` `i < k :``            ``print` `(r ``*` `i, end ``=` `" "``)``            ``i ``=` `i ``+` `1``            ` `        ``last_term ``=` `n ``-` `(r ``*` `(k ``*` `(k ``-` `1``) ``/` `2``))``        ``print` `(last_term)``        ` `        ` `            ` `        ` `# main driver``print_sequence(``24``,``4``)``print_sequence(``24``,``5``)``print_sequence(``6``,``4``)` `# This code is contributed by Saloni Gupta`

## C#

 `// C# program to find the series with``// largest GCD and sum equals to n``using` `System;` `class` `GFG {` `// function to generate and``// print the sequence``static` `void` `print_sequence(``int` `n, ``int` `k)``{``    ` `    ``// stores the maximum gcd that can be``    ``// possible of sequence.``    ``int` `b = n / (k * (k + 1) / 2);` `    ``// if maximum gcd comes out to be``    ``// zero then not possible``    ``if` `(b == 0)``    ``{``        ``Console.Write(``"-1"``);` `    ``}``    ``else``    ``{` `        ``// the smallest gcd possible is 1``        ``int` `r = 1;` `        ``// traverse the array to find out``        ``// the max gcd possible``        ``for` `(``int` `x = 1; x * x <= n; x++)``        ``{` `            ``// checks if the number is``            ``// divisible or not``            ``if` `(n % x != 0)``                ``continue``;` `            ``// checks if x is smaller then``            ``// the max gcd possible and x``            ``// is greater then the resultant``            ``// gcd till now, then r=x``            ``if` `(x <= b && x > r)``                ``r = x;` `            ``// checks if n/x is smaller than``            ``// the max gcd possible and n/x``            ``// is greater then the resultant``            ``// gcd till now, then r=x``            ``if` `(n / x <= b && n / x > r)``                ``r = n / x;``        ``}` `        ``// traverses and prints d, 2d,``        ``// 3d,..., (k-1)``        ``for` `(``int` `i = 1; i < k; i++)``        ``Console.Write(r * i + ``" "``);` `        ``// computes the last element of``        ``// the sequence n-s.``        ``int` `res = n - (r * (k *``                  ``(k - 1) / 2));` `        ``// prints the last element``        ``Console.WriteLine(res);``    ``}``}` `// Driver Code``public` `static` `void` `Main()``{``    ``int` `n = 24;``    ``int` `k = 4;``    ``print_sequence(n, k);` `    ``n = 24; k = 5;``    ``print_sequence(n, k);` `    ``n = 6; k = 4;``    ``print_sequence(n, k);``}``}` `// This code is contributed by Nitin Mittal.`

## PHP

 ` ``\$r``)``                ``\$r` `= ``\$x``;` `            ``// checks if n/x is smaller than``            ``// the max gcd possible and n/x``            ``// is greater then the resultant``            ``// gcd till now, then r=x``            ``if` `(``\$n` `/ ``\$x` `<= ``\$b` `&& ``\$n` `/ ``\$x` `> ``\$r``)``                ``\$r` `= ``\$n` `/ ``\$x``;``        ``}` `        ``// traverses and prints d, 2d, 3d,``        ``// ..., (k-1)·d,``        ``for` `(``\$i` `= 1; ``\$i` `< ``\$k``; ``\$i``++)``            ``echo``(``\$r` `* ``\$i` `. ``" "``);` `        ``// computes the last element of``        ``// the sequence n-s.``        ``\$res` `= ``\$n` `- (``\$r` `* (``\$k` `* (``\$k` `- 1) / 2));` `        ``// prints the last element``        ``echo``(``\$res` `. ``"\n"``);``    ``}``}` `// Driver Code``\$n` `= 24;``\$k` `= 4;``print_sequence(``\$n``, ``\$k``);` `\$n` `= 24; ``\$k` `= 5;``print_sequence(``\$n``, ``\$k``);` `\$n` `= 6; ``\$k` `= 4;``print_sequence(``\$n``, ``\$k``);` `// This code is contributed by Ajit.``?>`

## Javascript

 ``

Output :

```2 4 6 12
1 2 3 4 14
-1```

Time complexity: O( sqrt (n) )
Auxiliary Space: O(1)
This article is contributed by Raja Vikramaditya. 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 write comments if you find anything incorrect, or you want to share more information about the topic discussed above.

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.

My Personal Notes arrow_drop_up