Construct an array from GCDs of consecutive elements in given array

Last Updated : 18 Aug, 2022

Given an array a[] of n elements. The task is to find the array (say b[]) of n + 1 such that Greatest Common Divisor of b[i] and b[i + 1] is equals to a[i]. If multiple solutions exist, print the one whose array sum is minimum.

Examples:

```Input : a[] = { 1, 2, 3 }
Output : 1 2 6 3
GCD(1, 2) = 1
GCD(2, 6) = 2
GCD(6, 3) = 3
Also, 1 + 2 + 6 + 3 = 12 which is smallest among all
possible value of array that can be constructed.

Input : a[] = { 5, 10, 5 }
Output : 5 10 10 5```

Suppose there is only one number in the given array a[]. Let it be K, and then both numbers in the constructed array (say b[]) will be K and K.
So, the value of the b[0] will be a[0] only. Now consider that, we are done up to index i i.e we have already processed upto index i and calculated b[i + 1].
Now the gcd(b[i + 1], b[i + 2]) = a[i + 1] and gcd(b[i + 2], b[i + 3]) = a[i + 2]. So, b[i + 2] >= lcm(a[i + 1], a[i + 2]). Or, b[i + 2] will be multiple of lcm(a[i + 1], a[i + 2]). As we want the minimum sum, so we want the minimum value of b[i + 2]. So, b[i + 2] = lcm(a[i + 2], a[i + 3]).

Below is the implementation of this approach:

C++

 `// CPP Program to construct an array whose GCD of` `// every consecutive element is the given array` `#include ` `using` `namespace` `std;`   `// Return the LCM of two numbers.` `int` `lcm(``int` `a, ``int` `b)` `{` `    ``return` `(a * b) / __gcd(a, b);` `}`   `// Print the required constructed array` `void` `printArray(``int` `a[], ``int` `n)` `{` `    ``// printing the first element.` `    ``cout << a[0] << ``" "``;`   `    ``// finding and printing the LCM of consecutive` `    ``// element of given array.` `    ``for` `(``int` `i = 0; i < n - 1; i++)` `        ``cout << lcm(a[i], a[i + 1]) << ``" "``;`   `    ``// printing the last element of the given array.` `    ``cout << a[n - 1] << endl;` `}`   `// Driven Program` `int` `main()` `{` `    ``int` `a[] = { 1, 2, 3 };` `    ``int` `n = ``sizeof``(a) / ``sizeof``(a[0]);` `    ``printArray(a, n);` `    ``return` `0;` `}`

Java

 `// Java Program to construct an array whose` `// GCD of every consecutive element is the` `// given array`   `import` `java.io.*;`   `class` `GFG {` `    `  `    ``// Recursive function to return gcd of` `    ``// a and b` `    ``static` `int` `__gcd(``int` `a, ``int` `b)` `    ``{` `        `  `        ``// Everything divides 0 ` `        ``if` `(a == ``0` `|| b == ``0``)` `        ``return` `0``;` `    `  `        ``// base case` `        ``if` `(a == b)` `            ``return` `a;` `    `  `        ``// a is greater` `        ``if` `(a > b)` `            ``return` `__gcd(a - b, b);` `            `  `        ``return` `__gcd(a, b - a);` `    ``}`   `    ``// Return the LCM of two numbers.` `    ``static` `int` `lcm(``int` `a, ``int` `b)` `    ``{` `        ``return` `(a * b) / __gcd(a, b);` `    ``}` `    `  `    ``// Print the required constructed array` `    ``static` `void` `printArray(``int` `a[], ``int` `n)` `    ``{` `        `  `        ``// printing the first element.` `        ``System.out.print( a[``0``] + ``" "``);` `    `  `        ``// finding and printing the LCM of ` `        ``// consecutive element of given array.` `        ``for` `(``int` `i = ``0``; i < n - ``1``; i++)` `            ``System.out.print(lcm(a[i],` `                            ``a[i + ``1``]) + ``" "``);` `    `  `        ``// printing the last element of the` `        ``// given array.` `        ``System.out.print(a[n - ``1``]);` `    ``}` `    `  `    ``// Driven Program` `    ``public` `static` `void` `main (String[] args)` `    ``{` `        ``int` `a[] = { ``1``, ``2``, ``3` `};` `        ``int` `n = a.length;` `        ``printArray(a, n);` `    ``}` `}`   `// This code is contributed by anuj_67.`

Python3

 `# Python Program to construct an array whose` `# GCD of every consecutive element is the` `# given array`   `# Recursive function to return gcd of` `# a and b` `def` `__gcd( a, b):` `        `  `    ``# Everything divides 0 ` `    ``if` `(a ``=``=` `0` `or` `b ``=``=` `0``):` `        ``return` `0` `        `  `    ``# base case` `    ``if` `(a ``=``=` `b):` `        ``return` `a ` `        `  `    ``# a is greater` `    ``if` `(a > b):` `        ``return` `__gcd(a ``-` `b, b)         ` `    ``return` `__gcd(a, b ``-` `a)` `    `  `# Return the LCM of two numbers.` `def` `lcm(a, b):` `    ``return` `(a ``*` `b) ``/` `__gcd(a, b)`   `# Print the required constructed array` `def` `printArray(a, n):` `        `  `    ``# printing the first element.` `    ``print` `( ``str``(a[``0``]) ``+` `" "``)` `        `  `    ``# finding and printing the LCM of ` `    ``# consecutive element of given array.` `    ``for` `i ``in` `range``(``0``,n``-``1``):` `        ``print` `(``str``(lcm(a[i],a[i ``+` `1``])) ``+` `" "``)` `        `  `    ``# printing the last element of the` `    ``# given array.` `    ``print` `(a[n ``-` `1``])`   `# Driver code` `a ``=` `[``1``, ``2``, ``3` `]` `n ``=` `len``(a)` `printArray(a, n)`   `# This code is contributed by Prateek Bajaj`

C#

 `// C# Program to construct an array whose` `// GCD of every consecutive element is the` `// given array` `using` `System;` `class` `GFG {` `    `  `    ``// Recursive function to return` `    ``// gcd of a and b` `    ``static` `int` `__gcd(``int` `a, ``int` `b)` `    ``{` `        ``// Everything divides 0 ` `        ``if` `(a == 0 || b == 0)` `        ``return` `0;` `    `  `        ``// base case` `        ``if` `(a == b)` `            ``return` `a;` `    `  `        ``// a is greater` `        ``if` `(a > b)` `            ``return` `__gcd(a - b, b);` `            `  `        ``return` `__gcd(a, b - a);` `    ``}`   `    ``// Return the LCM of two numbers.` `    ``static` `int` `lcm(``int` `a, ``int` `b)` `    ``{` `        ``return` `(a * b) / __gcd(a, b);` `    ``}` `    `  `    ``// Print the required constructed array` `    ``static` `void` `printArray(``int` `[]a, ``int` `n)` `    ``{` `        `  `        ``// printing the first element.` `        ``Console.Write( a[0] + ``" "``);` `    `  `        ``// finding and printing the LCM of ` `        ``// consecutive element of given array.` `        ``for` `(``int` `i = 0; i < n - 1; i++)` `            ``Console.Write(lcm(a[i],` `                  ``a[i + 1]) + ``" "``);` `    `  `        ``// printing the last element ` `        ``// of the given array.` `        ``Console.Write(a[n - 1]);` `    ``}` `    `  `    ``// Driver Code` `    ``public` `static` `void` `Main ()` `    ``{` `        ``int` `[]a = {1, 2, 3};` `        ``int` `n = a.Length;` `        ``printArray(a, n);` `    ``}` `}`   `// This code is contributed by anuj_67.`

PHP

 ` ``\$b``)` `        ``return` `__gcd( ``\$a` `- ``\$b` `, ``\$b` `) ;`   `    ``return` `__gcd( ``\$a` `, ``\$b` `- ``\$a` `) ;` `}`   `// Return the LCM of two numbers.` `function` `lcm(``\$a``, ``\$b``)` `{` `    ``return` `(``\$a` `* ``\$b``) / __gcd(``\$a``, ``\$b``);` `}`   `// Print the required constructed array` `function` `printArray( ``\$a``, ``\$n``)` `{` `    `  `    ``// printing the first element.` `    ``echo` `\$a``[0] , ``" "``;`   `    ``// finding and printing ` `    ``// the LCM of consecutive` `    ``// element of given array.` `    ``for` `( ``\$i` `= 0; ``\$i` `< ``\$n` `- 1; ``\$i``++)` `        ``echo` `lcm(``\$a``[``\$i``], ``\$a``[``\$i` `+ 1]) , ``" "``;`   `    ``// printing the last element` `    ``// of the given array.` `    ``echo` `\$a``[``\$n` `- 1] ,``"\n"``;` `}`   `    ``// Driver Code` `    ``\$a` `= ``array``(1, 2, 3);` `    ``\$n` `= ``count``(``\$a``);` `    ``printArray(``\$a``, ``\$n``);`   `// This code is contributed by anuj_67.` `?>`

Javascript

 ``

Output

`1 2 6 3`

Complexity Analysis:

• Time complexity: O(n * log(max(a, b)), where n represents the size of the given array.
• Auxiliary Space: O(1)

Previous
Next