GeeksforGeeks App
Open App
Browser
Continue

# Construct Array of given size with elements at even positions divisible by their adjacent left

Given an integer N, the task is to construct and print an Array, such that:

• The size of array is N
• The elements in array are in range [1, 2*N]
• Each element in the array are distinct
• The elements at even positions are divisible by their adjacent left, but this must not be true for odd position elements, i.e.
• arr[i] % arr[i-1] == 0 is true for i % 2 == 0
• arr[i] % arr[i-1] != 0 is true for i % 2 != 0
• Array is considered to be 1-indexed.

Examples:

Input: N = 4
Output: {1, 3, 2, 4}
Explanation:
For i = 1, A[2] % A[1] = 3 % 1 = 0
For i = 2 . A[3] % A[2] = 2 % 3 ≠ 0
For i = 3, A[4] % A[3] = 4 % 2 = 0

Input: N = 7
Output: {1, 2, 3, 6, 5, 10, 7}

Approach: There can be multiple Arrays of size N based on given conditions. Here’s a simple greedy approach to construct one among them, based on below observation:

The sequence {X, 2*X, X+2, 2*(X+2)….} will always follow all the conditions of the problem for X = 1, 3, 4, … and so on, as:

According to the above sequence,
1st element pair   = X      and 2(X)
2nd element pair = X+2 and 2(X+2)
3rd element pair = X+4 and 2(X+4)
.
.
Cth element pair = X+2C and 2(X+2C)

Therefore for any Cth element pair,

• Each Array element will always be distinct.
• Element at even position 2(X+2C) will always be divisible by its adjacent left (X+2C)
• Element at odd position (X+2C) will never be divisible by its adjacent left 2(X+2C-2)

Hence this sequence will always be valid for the required Array.

Note: We cannot consider {X, 2*X, X+1, 2*(X+1)….} as the elements can be duplicate for this case when X = 1. Another such valid sequence will be {X, 2*X, X+1, 2*(X+1)….} for X > 1.

Based on the above observation, following approach can be used to solve the problem:

For this approach, we can simply consider the array constructed with X = 1 as per above sequence, as one of the possible solution.

• Declare an array of size N+1 to store the answer and initialize a variable X by 1.
• Iterate from 1 to N.
• At each odd index, store consecutive odd integers.
• At each even index, store the twice of the integer at previous index.

Below is the implementation of the above approach:

## C++

 `// C++ Code for above approach``#include ``using` `namespace` `std;` `// Function to find an array such``// that elements at even positions``// are divisible by their previous``// element and elements at odd positions``// are not``void` `constructArray(``int` `N)``{``    ``// Declaring array A to store the answer``    ``int` `ans[N + 1];` `    ``// Initializing a variable X by 1``    ``int` `X = 1;` `    ``// Iterating from 1 to N and storing``    ``// consecutive odd integers at odd``    ``// indices and twice of element at``    ``// previous index at even indices``    ``for` `(``int` `i = 1; i <= N; i++) {``        ``if` `(i % 2 == 1) {``            ``ans[i] = X;``        ``}``        ``else` `{``            ``ans[i] = 2 * ans[i - 1];``            ``X += 2;``        ``}``    ``}` `    ``// Printing the array``    ``for` `(``int` `i = 1; i <= N; i++) {``        ``cout << ans[i] << ``" "``;``    ``}``}` `// Driver Code``int` `main()``{``    ``int` `N = 7;``    ``constructArray(N);` `    ``return` `0;``}`

## Java

 `import` `java.io.*;` `class` `GFG {` `// Function to find an array such``// that elements at even positions``// are divisible by their previous``// element and elements at odd positions``// are not``static` `void` `constructArray(``int` `N)``{``    ``// Declaring array A to store the answer``    ``int` `ans[] = ``new` `int``[N + ``1``];` `    ``// Initializing a variable X by 2``    ``int` `X = ``2``;` `    ``// Iterating from 1 to N and storing``    ``// consecutive odd integers at odd``    ``// indices and twice of element at``    ``// previous index at even indices``    ``for` `(``int` `i = ``1``; i <= N; i++) {``        ``if` `(i % ``2` `== ``1``) {``            ``ans[i] = X - ``1``;``        ``}``        ``else` `{``            ``ans[i] = ``2` `* ans[i - ``1``];``            ``X += ``2``;``        ``}``    ``}` `    ``// Printing the array``    ``for` `(``int` `i = ``1``; i <= N; i++) {``        ``System.out.print(ans[i] + ``" "``);``    ``}``}` `// Driver Code``    ``public` `static` `void` `main (String[] args) {``        ``int` `N = ``7``;``            ``constructArray(N);``    ``}``}`

## Python3

 `# Python Code for above approach` `# Function to find an array such``# that elements at even positions``# are divisible by their previous``# element and elements at odd positions``# are not``def` `constructArray(N):` `    ``# Declaring array A to store the answer``    ``ans ``=` `[``0` `for` `i ``in` `range``(N ``+` `1``)]` `    ``# Initializing a variable X by 1``    ``X ``=` `1` `    ``# Iterating from 1 to N and storing``    ``# consecutive odd integers at odd``    ``# indices and twice of element at``    ``# previous index at even indices``    ``for` `i ``in` `range``(``1``, N ``+` `1``):``        ``if` `(i ``%` `2` `=``=` `1``):``            ``ans[i] ``=` `X``        ``else``:``            ``ans[i] ``=` `2` `*` `ans[i ``-` `1``]``            ``X ``+``=` `2` `    ``# Printing the array``    ``for` `i ``in` `range``(``1``, N ``+` `1``):``        ``print``(ans[i],end ``=` `" "``)` `# Driver Code``N ``=` `7``constructArray(N)` `# This code is contributed by shinjanpatra`

## C#

 `using` `System;``using` `System.Collections.Generic;``public` `class` `GFG {` `  ``// Function to find an array such``  ``// that elements at even positions``  ``// are divisible by their previous``  ``// element and elements at odd positions``  ``// are not``  ``static` `void` `constructArray(``int` `N)``  ``{``    ``// Declaring array A to store the answer``    ``int``[] ans = ``new` `int``[N + 1];` `    ``// Initializing a variable X by 1``    ``int` `X = 1;` `    ``// Iterating from 1 to N and storing``    ``// consecutive odd integers at odd``    ``// indices and twice of element at``    ``// previous index at even indices``    ``for` `(``int` `i = 1; i <= N; i++) {``      ``if` `(i % 2 == 1) {``        ``ans[i] = X;``      ``}``      ``else` `{``        ``ans[i] = 2 * ans[i - 1];``        ``X += 2;``      ``}``    ``}` `    ``// Printing the array``    ``for` `(``int` `i = 1; i <= N; i++) {``      ``Console.Write(ans[i] + ``" "``);``    ``}``  ``}``  ``static` `public` `void` `Main()``  ``{``    ``int` `N = 7;``    ``constructArray(N);` `  ``}``}` `// This code is contributed by phasing17`

## Javascript

 ``

Output

`1 2 3 6 5 10 7 `

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

Approach 2:

Without Using Extra Variable X to store values:

In this code we have removed the use of an extra variable “X” and directly computed the value of the odd indexed elements in the array “ans”. Instead of incrementing the value of “X” by 2 after each iteration, I have directly used the expression “2 * i – 1” to compute the value of the odd indexed elements. This eliminates the need for an extra variable and makes the code more compact and efficient.

The step-by-step approach to implement the new idea is given by:

• The code defines a function constructArray() that takes an integer N as input.
• The next line declares an integer array ans with N+1 elements. The array will be used to store the answer.
• The for loop iterates from 1 to N, and fills the array ans. If the index i is odd, it sets ans[i] to 2*i – 1, which is the ith odd integer. If the index i is even, it sets ans[i] to 2 * ans[i – 1], which is twice the previous element.
• Finally, the last for loop prints all the elements of the array ans.

## C++

 `#include ``using` `namespace` `std;` `// Function to find an array such``// that elements at even positions``// are divisible by their previous``// element and elements at odd positions``// are not``void` `constructArray(``int` `N)``{``    ``// Declaring array A to store the answer``    ``int` `ans[N + 1];` `    ``// Iterating from 1 to N and storing``    ``// consecutive odd integers at odd``    ``// indices and twice of element at``    ``// previous index at even indices``    ``for` `(``int` `i = 1; i <= N; i++) {``        ``if` `(i % 2 == 1) {``            ``ans[i] = 2 * i - 1;``        ``}``        ``else` `{``            ``ans[i] = 2 * ans[i - 1];``        ``}``    ``}` `    ``// Printing the array``    ``for` `(``int` `i = 1; i <= N; i++) {``        ``cout << ans[i] << ``" "``;``    ``}``}` `// Driver Code``int` `main()``{``    ``int` `N = 7;``    ``constructArray(N);` `    ``return` `0;``}`

## Java

 `import` `java.io.*;` `class` `GFG {` `// Function to find an array such``// that elements at even positions``// are divisible by their previous``// element and elements at odd positions``// are not``static` `void` `constructArray(``int` `N)``{``    ``// Declaring array A to store the answer``    ``int` `ans[] = ``new` `int``[N + ``1``];` `    ``// Iterating from 1 to N and storing``    ``// consecutive odd integers at odd``    ``// indices and twice of element at``    ``// previous index at even indices``    ``for` `(``int` `i = ``1``; i <= N; i++) {``        ``if` `(i % ``2` `== ``1``) {``            ``ans[i] = ``2` `* i - ``1``;``        ``}``        ``else` `{``            ``ans[i] = ``2` `* ans[i - ``1``];``        ``}``    ``}` `    ``// Printing the array``    ``for` `(``int` `i = ``1``; i <= N; i++) {``        ``System.out.print(ans[i] + ``" "``);``    ``}``}` `// Driver Code``    ``public` `static` `void` `main (String[] args) {``        ``int` `N = ``7``;``        ``constructArray(N);``    ``}``}`

## Python3

 `# Function to find an array such``# that elements at even positions``# are divisible by their previous``# element and elements at odd positions``# are not``def` `constructArray(N):``    ``# Declaring list A to store the answer``    ``ans ``=` `[``0``] ``*` `(N ``+` `1``)` `    ``# Iterating from 1 to N and storing``    ``# consecutive odd integers at odd``    ``# indices and twice of element at``    ``# previous index at even indices``    ``for` `i ``in` `range``(``1``, N ``+` `1``):``        ``if` `i ``%` `2` `=``=` `1``:``            ``ans[i] ``=` `2` `*` `i ``-` `1``        ``else``:``            ``ans[i] ``=` `2` `*` `ans[i ``-` `1``]` `    ``# Printing the array``    ``for` `i ``in` `range``(``1``, N ``+` `1``):``        ``print``(ans[i], end``=``" "``)``    ``print``()` `# Driver code``if` `__name__ ``=``=` `'__main__'``:``    ``N ``=` `7``    ``constructArray(N)`

## C#

 `// C# code for the approach` `using` `System;` `class` `GFG {``    ``// Driver code``    ``static` `void` `Main(``string``[] args) {``        ``int` `N = 7;``        ``ConstructArray(N);``    ``}` `      ``// Function to find an array such``    ``// that elements at even positions``    ``// are divisible by their previous``    ``// element and elements at odd positions``    ``// are not``    ``static` `void` `ConstructArray(``int` `N) {``        ``// Declaring array A to store the answer``        ``int``[] ans = ``new` `int``[N + 1];` `        ``// Iterating from 1 to N and storing``        ``// consecutive odd integers at odd``        ``// indices and twice of element at``        ``// previous index at even indices``        ``for` `(``int` `i = 1; i <= N; i++) {``            ``if` `(i % 2 == 1) {``                ``ans[i] = 2 * i - 1;``            ``}``            ``else` `{``                ``ans[i] = 2 * ans[i - 1];``            ``}``        ``}` `        ``// Printing the array``        ``for` `(``int` `i = 1; i <= N; i++) {``            ``Console.Write(ans[i] + ``" "``);``        ``}``    ``}``}`

## Javascript

 `// JavaScript code for the approach` `// Function to construct an array``// where elements at even positions are``// divisible by their previous element``// and elements at odd positions are not``function` `constructArray(N) {``    ``// Declaring an array to store the answer``    ``let ans = ``new` `Array(N + 1);` `    ``// Iterating from 1 to N and storing``    ``// consecutive odd integers at odd``    ``// indices and twice of element at``    ``// previous index at even indices``    ``for` `(let i = 1; i <= N; i++) {``        ``if` `(i % 2 == 1) {``            ``ans[i] = 2 * i - 1;``        ``}``        ``else` `{``            ``ans[i] = 2 * ans[i - 1];``        ``}``    ``}` `    ``// Printing the array``    ``console.log(ans.join(``' '``));``}` `// Driver Code``let N = 7;``constructArray(N);`

OUTPUT:

`1 2 3 6 5 10 7 `

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

My Personal Notes arrow_drop_up