Series with largest GCD and sum equals to n

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 than 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 than 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 <bits/stdc++.h>
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 than
            // the max gcd possible and x
            // is greater than 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 than 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 than
            // the max gcd possible and x
            // is greater than 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 than 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 than
            # the max gcd possible and x
            # is greater than 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 than 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 than
            // the max gcd possible and x
            // is greater than 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 than 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

<?php
// PHP program to find the
// series with largest GCD
// and sum equals to n

// function to generate and
// print the sequence
function 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)
    {
        echo(-1);
    }
    else
    {

        // the smallest gcd possible is 1
        $r = 1;

        // traverse the array to find out
        // the max gcd possible
        for ($x = 1; $x * $x <= $n; $x++)
        {

            // checks if the number is
            // divisible or not
            if ($n % $x != 0)
                continue;

            // checks if x is smaller than
            // the max gcd possible and x
            // is greater than 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 than 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

<script>

// Javascript program to find the
// series with largest GCD
// and sum equals to n

// function to generate and
// print the sequence
function print_sequence(n, k)
{
    // stores the maximum gcd that
    // can be possible of sequence.
    let b = parseInt(n / (k * (k + 1) / 2));

    // if maximum gcd comes out to be
    // zero then not possible
    if (b == 0)
    {
        document.write(-1);
    }
    else
    {

        // the smallest gcd possible is 1
        let r = 1;

        // traverse the array to find out
        // the max gcd possible
        for (let x = 1; x * x <= n; x++)
        {

            // checks if the number is
            // divisible or not
            if (n % x != 0)
                continue;

            // checks if x is smaller than
            // the max gcd possible and x
            // is greater than 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 than 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 (let i = 1; i < k; i++)
            document.write(r * i + " ");

        // computes the last element of
        // the sequence n-s.
        let res = n - (r * (k * (k - 1) / 2));

        // prints the last element
        document.write(res + "<br>");
    }
}

// Driver Code
let n = 24;
let 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 _saurabh_jaiswal.

</script>

Output :

2 4 6 12
1 2 3 4 14
-1

Time complexity: O( sqrt (n) ) 
Auxiliary Space: O(1)
If you like GeeksforGeeks and would like to contribute, you can also write an article using write.geeksforgeeks.org or mail your article to review-team@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.