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 <bits/stdc++.h>
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

<script>
    // JavaScript 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
    const constructArray = (N) => {

        // Declaring array A to store the answer
        let ans = new Array(N + 1).fill(0);

        // Initializing a variable X by 1
        let 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 (let 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 (let i = 1; i <= N; i++) {
            document.write(`${ans[i]} `);
        }
    }

    // Driver Code
    let N = 7;
    constructArray(N);

// This code is contributed by rakeshsahni
</script>

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 <bits/stdc++.h>
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)