# Generate a sequence X from given sequence Y such that Yi = gcd(X1, X2 , … , Xi)

• Last Updated : 22 Dec, 2021

Given a sequence Y of size N where:

Yi = gcd(X1, X2, X3, . . ., Xi ) of some sequence X.

The task is to find such a sequence X if any such X is possible.

Note: If X exists there can be multiple value possible for X. Generating any one is sufficient.

Examples:

Input: N = 2, Y = [4, 2]
Output: [4, 2]
Explanation: Y0 = gcd(X0) = X0 = 4. And gcd(4, 2) = 2 = Y1.

Input: [1, 3]
Output: -1
Explanation: No such sequence can be formed.

Approach: The problem can be solved based on the following observation:

• ith element of Y = gcd(X1, X2, X3, . . ., Xi ) and (i+1)th element of Y = gcd(X1, X2, X3, . . ., Xi, Xi+1).
• So (i+1)th element of Y can be written as gcd(gcd(X1, X2, X3, . . ., Xi ), Xi+1) ——-(1) i.e, gcd(a, b, c) = gcd( gcd(a, b), c ).
• So (i+1)th element of Y is gcd( ith element of Y, X(i+1)) from equation 1.
• Therefore (i+1)th element of Y must be factor of ith element of Y, as gcd of two elements is divisor of both the elements.
• Since (i+1)th element of Y divides ith element of Y, gcd( ith element, (i+1)th element) is always equals to (i+1)th element.

Illustration:

For example: N = 2, Y = {4, 2}

• X = Y = 4 because any number is GCD of itself.
• Y = GCD(X, X). Now GCD(X) = Y. So Y = GCD(Y, X). Therefore Y should be a factor of Y.
• In the given example 2 is a factor of 4. So forming a sequence X is possible and X can be same as Y.
Assigning X = 2 satisfies GCD (X[0, X) = Y = 2.
• So the final sequence X is {4, 2}.

So follow the steps mentioned below to solve the problem based on the above observation:

1. Start traversing Y from the starting of the sequence.
2. If in the given Sequence Y has any (i+1)th element which does not divide ith element then sequence X can’t be generated.
3. If the (i+1)th element divides ith element then there exists a sequence X and it can be found by above conclusion of(i+1)th element of Y
is gcd( ith element of Y, Xi+1) and Xi+1 = Yi+1 is a possible value for Xi+1.

Below is the implementation of the approach:

## C++

 `// C++ Program to implement above approach``#include ``using` `namespace` `std;` `// Euclidean theorem to find gcd``int` `gcd(``int` `a, ``int` `b)``{``    ``if` `(b == 0)``        ``return` `a;``    ``return` `gcd(b, a % b);``}` `// Function to check if it is possible``// to generate lost sequence X``void` `checkforX(``int` `Y[], ``int` `N)``{``    ``int` `cur_gcd = Y;``    ``bool` `Xexist = ``true``;` `    ``// Loop to check existence of X``    ``for` `(``int` `i = 1; i < N; i++) {``        ``cur_gcd = gcd(cur_gcd, Y[i]);``        ``if` `(cur_gcd != Y[i]) {``            ``Xexist = ``false``;``            ``break``;``        ``}``    ``}` `    ``// Sequence X is found``    ``if` `(Xexist) {` `        ``// Loop to generate X``        ``for` `(``int` `i = 0; i < N; i++)``            ``cout << Y[i] << ``' '``;``    ``}` `    ``// Sequence X can't be generated``    ``else` `{``        ``cout << -1 << endl;``    ``}``}` `// Driver code``int` `main()``{``    ``int` `N = 2;` `    ``// Sequence Y of size 2``    ``int` `Y[] = { 4, 2 };``    ``checkforX(Y, N);``    ``return` `0;``}`

## C

 `// C program to implement above approach``#include ` `// Euclidean theorem to calculate gcd``int` `gcd(``int` `a, ``int` `b)``{``    ``if` `(b == 0)``        ``return` `a;``    ``return` `gcd(b, a % b);``}` `// Function to check if it is possible``// to generate lost sequence X``void` `checkforX(``int` `Y[], ``int` `N)``{``    ``int` `cur_gcd = Y;``    ``int` `Xexist = 1;` `    ``// Loop to check existence of X``    ``for` `(``int` `i = 1; i < N; i++) {``        ``cur_gcd = gcd(cur_gcd, Y[i]);``        ``if` `(cur_gcd != Y[i]) {``            ``Xexist = 0;``            ``break``;``        ``}``    ``}` `    ``// Sequence X is found``    ``if` `(Xexist) {` `        ``// Loop to generate X``        ``for` `(``int` `i = 0; i < N; i++)``            ``printf``(``"%d "``, Y[i]);``    ``}` `    ``// Sequence X can't be generated``    ``else` `{``        ``printf``(``"-1"``);``    ``}``}` `// Driver code``int` `main()``{``    ``int` `N = 2;` `    ``// Sequence Y of size 2``    ``int` `Y[] = { 4, 2 };``    ``checkforX(Y, N);``    ``return` `0;``}`

## Java

 `// Java Program to implement above approach``import` `java.util.*;` `class` `GFG{` `// Euclidean theorem to find gcd``static` `int` `gcd(``int` `a, ``int` `b)``{``    ``if` `(b == ``0``)``        ``return` `a;``    ``return` `gcd(b, a % b);``}` `// Function to check if it is possible``// to generate lost sequence X``static` `void` `checkforX(``int` `Y[], ``int` `N)``{``    ``int` `cur_gcd = Y[``0``];``    ``boolean` `Xexist = ``true``;` `    ``// Loop to check existence of X``    ``for` `(``int` `i = ``1``; i < N; i++) {``        ``cur_gcd = gcd(cur_gcd, Y[i]);``        ``if` `(cur_gcd != Y[i]) {``            ``Xexist = ``false``;``            ``break``;``        ``}``    ``}` `    ``// Sequence X is found``    ``if` `(Xexist) {` `        ``// Loop to generate X``        ``for` `(``int` `i = ``0``; i < N; i++)``            ``System.out.print(Y[i] +``" "``);``    ``}` `    ``// Sequence X can't be generated``    ``else` `{``        ``System.out.print(-``1` `+``"\n"``);``    ``}``}` `// Driver code``public` `static` `void` `main(String[] args)``{``    ``int` `N = ``2``;` `    ``// Sequence Y of size 2``    ``int` `Y[] = { ``4``, ``2` `};``    ``checkforX(Y, N);``}``}` `// This code is contributed by 29AjayKumar`

## Python3

 `# Python code for the above approach` `# Euclidean theorem to find gcd``def` `gcd(a, b):``    ``if` `(b ``=``=` `0``):``        ``return` `a``    ``return` `gcd(b, a ``%` `b)` `# Function to check if it is possible``# to generate lost sequence X``def` `checkforX(Y, N):``    ``cur_gcd ``=` `Y[``0``]``    ``Xexist ``=` `True` `    ``# Loop to check existence of X``    ``for` `i ``in` `range``(``1``, N):``        ``cur_gcd ``=` `gcd(cur_gcd, Y[i])``        ``if` `(cur_gcd !``=` `Y[i]):``            ``Xexist ``=` `False``            ``break` `    ``# Sequence X is found``    ``if` `(Xexist):` `        ``# Loop to generate X``        ``for` `i ``in` `range``(N):``            ``print``(Y[i], end``=``' '``)` `    ``# Sequence X can't be generated``    ``else``:``        ``print``(``-``1``)` `# Driver code``N ``=` `2` `# Sequence Y of size 2``Y ``=` `[``4``, ``2``]``checkforX(Y, N)` `# This code is contributed by gfgking`

## C#

 `// C# Program to implement above approach``using` `System;``class` `GFG``{``  ` `// Euclidean theorem to find gcd``static` `int` `gcd(``int` `a, ``int` `b)``{``    ``if` `(b == 0)``        ``return` `a;``    ``return` `gcd(b, a % b);``}` `// Function to check if it is possible``// to generate lost sequence X``static` `void` `checkforX(``int` `[]Y, ``int` `N)``{``    ``int` `cur_gcd = Y;``    ``bool` `Xexist = ``true``;` `    ``// Loop to check existence of X``    ``for` `(``int` `i = 1; i < N; i++) {``        ``cur_gcd = gcd(cur_gcd, Y[i]);``        ``if` `(cur_gcd != Y[i]) {``            ``Xexist = ``false``;``            ``break``;``        ``}``    ``}` `    ``// Sequence X is found``    ``if` `(Xexist) {` `        ``// Loop to generate X``        ``for` `(``int` `i = 0; i < N; i++)``            ``Console.Write(Y[i] + ``" "``);``    ``}` `    ``// Sequence X can't be generated``    ``else` `{``        ``Console.Write(-1);``    ``}``}` `// Driver code``public` `static` `void` `Main()``{``    ``int` `N = 2;` `    ``// Sequence Y of size 2``    ``int` `[]Y = { 4, 2 };``    ``checkforX(Y, N);``}``}` `// This code is contributed by Samim Hossain Mondal.`

## Javascript

 ``
Output
`4 2 `

Time Complexity: O(N)
Auxiliary space: O(1)

My Personal Notes arrow_drop_up