Construct Array of given size with elements at even positions divisible by their adjacent left
Last Updated :
27 Mar, 2023
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++
#include <bits/stdc++.h>
using namespace std;
void constructArray( int N)
{
int ans[N + 1];
int X = 1;
for ( int i = 1; i <= N; i++) {
if (i % 2 == 1) {
ans[i] = X;
}
else {
ans[i] = 2 * ans[i - 1];
X += 2;
}
}
for ( int i = 1; i <= N; i++) {
cout << ans[i] << " " ;
}
}
int main()
{
int N = 7;
constructArray(N);
return 0;
}
|
Java
import java.io.*;
class GFG {
static void constructArray( int N)
{
int ans[] = new int [N + 1 ];
int X = 2 ;
for ( int i = 1 ; i <= N; i++) {
if (i % 2 == 1 ) {
ans[i] = X - 1 ;
}
else {
ans[i] = 2 * ans[i - 1 ];
X += 2 ;
}
}
for ( int i = 1 ; i <= N; i++) {
System.out.print(ans[i] + " " );
}
}
public static void main (String[] args) {
int N = 7 ;
constructArray(N);
}
}
|
Python3
def constructArray(N):
ans = [ 0 for i in range (N + 1 )]
X = 1
for i in range ( 1 , N + 1 ):
if (i % 2 = = 1 ):
ans[i] = X
else :
ans[i] = 2 * ans[i - 1 ]
X + = 2
for i in range ( 1 , N + 1 ):
print (ans[i],end = " " )
N = 7
constructArray(N)
|
C#
using System;
using System.Collections.Generic;
public class GFG {
static void constructArray( int N)
{
int [] ans = new int [N + 1];
int X = 1;
for ( int i = 1; i <= N; i++) {
if (i % 2 == 1) {
ans[i] = X;
}
else {
ans[i] = 2 * ans[i - 1];
X += 2;
}
}
for ( int i = 1; i <= N; i++) {
Console.Write(ans[i] + " " );
}
}
static public void Main()
{
int N = 7;
constructArray(N);
}
}
|
Javascript
<script>
const constructArray = (N) => {
let ans = new Array(N + 1).fill(0);
let X = 1;
for (let i = 1; i <= N; i++) {
if (i % 2 == 1) {
ans[i] = X;
}
else {
ans[i] = 2 * ans[i - 1];
X += 2;
}
}
for (let i = 1; i <= N; i++) {
document.write(`${ans[i]} `);
}
}
let N = 7;
constructArray(N);
</script>
|
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;
void constructArray( int N)
{
int ans[N + 1];
for ( int i = 1; i <= N; i++) {
if (i % 2 == 1) {
ans[i] = 2 * i - 1;
}
else {
ans[i] = 2 * ans[i - 1];
}
}
for ( int i = 1; i <= N; i++) {
cout << ans[i] << " " ;
}
}
int main()
{
int N = 7;
constructArray(N);
return 0;
}
|
Java
import java.io.*;
class GFG {
static void constructArray( int N)
{
int ans[] = new int [N + 1 ];
for ( int i = 1 ; i <= N; i++) {
if (i % 2 == 1 ) {
ans[i] = 2 * i - 1 ;
}
else {
ans[i] = 2 * ans[i - 1 ];
}
}
for ( int i = 1 ; i <= N; i++) {
System.out.print(ans[i] + " " );
}
}
public static void main (String[] args) {
int N = 7 ;
constructArray(N);
}
}
|
Python3
def constructArray(N):
ans = [ 0 ] * (N + 1 )
for i in range ( 1 , N + 1 ):
if i % 2 = = 1 :
ans[i] = 2 * i - 1
else :
ans[i] = 2 * ans[i - 1 ]
for i in range ( 1 , N + 1 ):
print (ans[i], end = " " )
print ()
if __name__ = = '__main__' :
N = 7
constructArray(N)
|
C#
using System;
class GFG {
static void Main( string [] args) {
int N = 7;
ConstructArray(N);
}
static void ConstructArray( int N) {
int [] ans = new int [N + 1];
for ( int i = 1; i <= N; i++) {
if (i % 2 == 1) {
ans[i] = 2 * i - 1;
}
else {
ans[i] = 2 * ans[i - 1];
}
}
for ( int i = 1; i <= N; i++) {
Console.Write(ans[i] + " " );
}
}
}
|
Javascript
function constructArray(N) {
let ans = new Array(N + 1);
for (let i = 1; i <= N; i++) {
if (i % 2 == 1) {
ans[i] = 2 * i - 1;
}
else {
ans[i] = 2 * ans[i - 1];
}
}
console.log(ans.join( ' ' ));
}
let N = 7;
constructArray(N);
|
OUTPUT:
1 2 3 6 5 10 7
Time Complexity: O(N)
Auxiliary Space: O(N)
Share your thoughts in the comments
Please Login to comment...