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)
Similar Reads
Construct an Array of length N containing exactly K elements divisible by their positions
Given two integers N and K, the task is to construct an array of length N containing exactly K elements divisible by their positions. Examples: Input: N = 6, K = 2Output: {5, 1, 2, 3, 4, 6}Explanation: Considering the above array:At Position 1, element 5 is divisible by 1At Position 2, element 1 is
10 min read
Count of elements on the left which are divisible by current element | Set 2
Given an array A[] of N integers, the task is to generate an array B[] such that B[i] contains the count of indices j in A[] such that j < i and A[j] % A[i] = 0Examples: Input: arr[] = {3, 5, 1} Output: 0 0 2 Explanation: 3 and 5 do not divide any element on their left but 1 divides 3 and 5.Input
7 min read
Count of elements in given Array divisible by all elements in their prefix
Given an array arr[] containing N positive integers, the task is to find the total number of elements in the array that are divisible by all the elements present before them. Examples: Input: arr[] = {10, 6, 60, 120, 30, 360}Output: 3Explanation: 60, 120 and 360 are the required elements. Input: arr
12 min read
Maximize the count of adjacent element pairs with even sum by rearranging the Array
Given an array, arr[] of N integers, the task is to find the maximum possible count of adjacent pairs with an even sum, rearranging the array arr[]. Examples: Input: arr[] = {5, 5, 1}Output: 2Explanation:The given array is already arranged to give the maximum count of adjacent pairs with an even sum
6 min read
Make all array elements even by replacing adjacent pair of array elements with their sum
Given an array arr[] of size N, the task is to make all array elements even by replacing a pair of adjacent elements with their sum. Examples: Input: arr[] = { 2, 4, 5, 11, 6 }Output: 1Explanation:Replacing a pair (arr[2], arr[3]) with their sum ( = 5 + 11 = 16) modifies arr[] to { 2, 4, 16, 16, 6 }
8 min read
Count number of pairs not divisible by any element in the array
Given an array arr[] of size N, the task is to count the number of pairs of integers (i, j) for which there does not exist an integer k such that arr[i] is divisible by arr[k] and arr[j] is divisible by arr[k], such that k can be any index between [0, N - 1]. Examples: Input: N = 4, arr[] = {2, 4, 5
5 min read
Print array elements that are divisible by at-least one other
Given an array of length N that contains only integers, the task is to print the special numbers of array. A number in this array is called Special number if it is divisible by at least one other number in the array. Examples : Input : 1 2 3 Output : 2 3 Explanation : both 2 and 3 are divisible by 1
9 min read
Maximum partitions possible of given Array with cost at most K and equal count of odd and even elements
Given two integers N, K, and an array, arr[] of size N, containing an equal number of even and odd elements, and also given that the cost of partitioning the array by making a cut between index i and i+1 is equal to the abs(arr[i]-arr[i+1]), the task is to find the maximum partitions of the array, s
9 min read
Construct Array with elements in given range and distinct GCD of each element with its index
Given 3 integers N, L and R. The task is to construct an array A[] of N integers, such that : Each element of the array is in the range [L, R].GCD(i, A[i]) are distinct for all elements. Examples : Input : N = 5, L = 1, R = 5Output : {1, 2, 3, 4, 5}Explanation : It can be seen that each element is i
7 min read
Count of adjacent pairs in given Array with even sum
Given an array arr[] of N integers, the task is to find the count of pairs of adjacent elements whose sum is even where each element can belong to at most one pair. Example: Input: arr[] = {1, 12, 1, 3, 5}Output: 1Explanation: 1 pair can be formed with arr[3] and arr[4]. Input: arr[] = {1, 2, 3, 4,
4 min read