Skip to content
Related Articles

Related Articles

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

Improve Article
Save Article
  • Last Updated : 04 Apr, 2022
Improve Article
Save Article

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




// 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




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


My Personal Notes arrow_drop_up
Related Articles

Start Your Coding Journey Now!