# Construct Array with elements in given range and distinct GCD of each element with its index

• Last Updated : 18 Aug, 2022

Given 3 integers N, L and R. The task is to construct an array A[] of N integers, such that :

• Each element of the array is in the range [L, R].
• GCD(i, A[i]) are distinct for all elements.

Examples :

Input : N = 5, L = 1, R = 5
Output : {1, 2, 3, 4, 5}
Explanation : It can be seen that each element is in the range [1, 5].
Also, for i = 1, GCD(1, 1)=1, for i = 2, GCD(2, 2) = 2, for i = 3,
GCD(3, 3) = 3, for i = 4, GCD(4, 4) = 4 and for i = 5, GCD(5, 5) = 5.
Hence, all of these are distinct.

Input : N = 10, L = 30, R = 35
Output : -1
Explanation : It is not possible to construct an array
satisfying the given conditions.

Approach: The approach of the problem is based on the following observation

To satisfy the given conditions, we will have to assure GCD(i, A[i]) = i, for each index of the array from 1 to N.

The idea is to find the  smallest possible element with gcd(i, A[i]) = i, larger than or equal to L for each i, and if that element is smaller than equal to R, then we append it, otherwise we return -1(means not possible).

The problem can be solved by the following approach:

• Iterate from i = 1 to N.
• For each i, find the minimum multiple of i that is strictly greater than L âˆ’ 1.
• Check if that multiple is less than or equal to R.
• If so, that multiple would be the ith element of the array.
• Else, array construction would not be possible.

Below is the implementation of the above approach:

## C++

 `// C++ code to implement the above approach`   `#include ` `using` `namespace` `std;`   `// Function to Construct an array whose elements` `// are in given range and GCD of each element` `// with its index is distinct` `void` `constructArray(``int` `N, ``int` `L, ``int` `R)` `{` `    ``// Declaring the array` `    ``int` `A[N + 1];` `    ``bool` `flag = ``true``;`   `    ``// Constructing each element of array` `    ``for` `(``int` `i = 1; i <= N; i++) {`   `        ``// Creating ith element of the array` `        ``// as the smallest multiple of i` `        ``// which is greater than L-1` `        ``A[i] = ((L - 1) / i + 1) * i;`   `        ``// Checking if the ith created element` `        ``// is less than or equal to R` `        ``if` `(A[i] > R) {` `            ``flag = ``false``;` `            ``break``;` `        ``}` `    ``}`   `    ``// If flag is false, that implies` `    ``// it is not possible to construct the array` `    ``if` `(flag == ``false``) {` `        ``cout << -1;` `    ``}`   `    ``// Else print the constructed array` `    ``else` `{` `        ``for` `(``int` `i = 1; i <= N; i++) {` `            ``cout << A[i] << ``" "``;` `        ``}` `    ``}` `}`   `// Driver Code` `int` `main()` `{` `    ``int` `N = 5, L = 1, R = 5;`   `    ``// Function call` `    ``constructArray(N, L, R);` `    ``return` `0;` `}`

## Java

 `// Java code to implement the above approach` `import` `java.io.*;`   `class` `GFG {` `  ``// Function to Construct an array whose elements` `  ``// are in given range and GCD of each element` `  ``// with its index is distinct` `  ``public` `static` `void` `constructArray(``int` `N, ``int` `L, ``int` `R)` `  ``{` `    ``// Declaring the array` `    ``int` `A[] = ``new` `int``[N + ``1``];` `    ``boolean` `flag = ``true``;`   `    ``// Constructing each element of array` `    ``for` `(``int` `i = ``1``; i <= N; i++) {`   `      ``// Creating ith element of the array` `      ``// as the smallest multiple of i` `      ``// which is greater than L-1` `      ``A[i] = ((L - ``1``) / i + ``1``) * i;`   `      ``// Checking if the ith created element` `      ``// is less than or equal to R` `      ``if` `(A[i] > R) {` `        ``flag = ``false``;` `        ``break``;` `      ``}` `    ``}`   `    ``// If flag is false, that implies` `    ``// it is not possible to construct the array` `    ``if` `(flag == ``false``) {` `      ``System.out.print(-``1``);` `    ``}`   `    ``// Else print the constructed array` `    ``else` `{` `      ``for` `(``int` `i = ``1``; i <= N; i++) {` `        ``System.out.print(A[i] + ``" "``);` `      ``}` `    ``}` `  ``}`   `  ``// Driver Code` `  ``public` `static` `void` `main(String[] args)` `  ``{` `    ``int` `N = ``5``, L = ``1``, R = ``5``;`   `    ``// Function call` `    ``constructArray(N, L, R);` `  ``}` `}`   `// This code is contributed by Rohit Pradhan`

## Python3

 `# Python3 code to implement the above approach`   `# Function to Construct an array whose elements` `# are in given range and GCD of each element` `# with its index is distinct` `def` `constructArray(N, L, R) :`   `    ``# Declaring the array` `    ``A ``=` `[``0``] ``*` `(N ``+` `1``);` `    ``flag ``=` `True``;`   `    ``# Constructing each element of array` `    ``for` `i ``in` `range``(``1``, N ``+` `1``) :`   `        ``# Creating ith element of the array` `        ``# as the smallest multiple of i` `        ``# which is greater than L-1` `        ``A[i] ``=` `((L ``-` `1``) ``/``/` `i ``+` `1``) ``*` `i;`   `        ``# Checking if the ith created element` `        ``# is less than or equal to R` `        ``if` `(A[i] > R) :` `            ``flag ``=` `False``;` `            ``break``;`   `    ``# If flag is false, that implies` `    ``# it is not possible to construct the array` `    ``if` `(flag ``=``=` `False``) :` `        ``print``(``-``1``);`   `    ``# Else print the constructed array` `    ``else` `:` `        ``for` `i ``in` `range``(``1``, N ``+` `1``) :` `            ``print``(A[i], end``=``" "``);`   `# Driver Code` `if` `__name__ ``=``=` `"__main__"` `:`   `    ``N ``=` `5``; L ``=` `1``; R ``=` `5``;`   `    ``# Function call` `    ``constructArray(N, L, R);` `   `  `   ``# This code is contributed by AnkThon`

## C#

 `// C# code to implement the above approach` `using` `System;`   `class` `GFG` `{` `  `  `  ``// Function to Construct an array whose elements` `  ``// are in given range and GCD of each element` `  ``// with its index is distinct` `  ``public` `static` `void` `constructArray(``int` `N, ``int` `L, ``int` `R)` `  ``{` `    `  `    ``// Declaring the array` `    ``int` `[]A = ``new` `int``[N + 1];` `    ``bool` `flag = ``true``;`   `    ``// Constructing each element of array` `    ``for` `(``int` `i = 1; i <= N; i++) {`   `      ``// Creating ith element of the array` `      ``// as the smallest multiple of i` `      ``// which is greater than L-1` `      ``A[i] = ((L - 1) / i + 1) * i;`   `      ``// Checking if the ith created element` `      ``// is less than or equal to R` `      ``if` `(A[i] > R) {` `        ``flag = ``false``;` `        ``break``;` `      ``}` `    ``}`   `    ``// If flag is false, that implies` `    ``// it is not possible to construct the array` `    ``if` `(flag == ``false``) {` `      ``Console.Write(-1);` `    ``}`   `    ``// Else print the constructed array` `    ``else` `{` `      ``for` `(``int` `i = 1; i <= N; i++) {` `        ``Console.Write(A[i] + ``" "``);` `      ``}` `    ``}` `  ``}`   `  ``// Driver Code` `  ``public` `static` `void` `Main(``string``[] args)` `  ``{` `    ``int` `N = 5, L = 1, R = 5;`   `    ``// Function call` `    ``constructArray(N, L, R);` `  ``}` `}`   `// This code is contributed by AnkThon`

## Javascript

 ``

Output

`1 2 3 4 5 `

Time Complexity: O(N)
Auxiliary Space: O(N)

My Personal Notes arrow_drop_up
Related Articles