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

• Last Updated : 04 Apr, 2022

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

 `// Java Code for above approach` `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 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++) {` `        ``System.out.print(ans[i] + ``" "``);` `    ``}` `}`   `// Driver Code` `    ``public` `static` `void` `main (String[] args) {` `         ``int` `N = ``7``;` `            ``constructArray(N);` `    ``}` `}`   `// This code is contributed by hrithikgarg03188.`

## 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)

My Personal Notes arrow_drop_up
Related Articles