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

filter_none

edit
close

play_arrow

link
brightness_4
code

// 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 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);
}

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

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

chevron_right


[

Python3

filter_none

edit
close

play_arrow

link
brightness_4
code

# 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

chevron_right


C#

filter_none

edit
close

play_arrow

link
brightness_4
code

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

chevron_right


PHP

filter_none

edit
close

play_arrow

link
brightness_4
code

<?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 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 ($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.
?>

chevron_right



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.



My Personal Notes arrow_drop_up

Improved By : nitin mittal, jit_t