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)