构造给定大小的数组，其中元素在偶数位置可被相邻的左边整除

给定一个整数N ，任务是构造和打印一个数组，这样：

• 数组的大小为 N
• 数组中的元素在 [1, 2*N] 范围内
• 数组中的每个元素都是不同的
• 偶数位置的元素可以被它们相邻的左边整除，但是对于奇数位置的元素一定不能这样，即
  • arr[i] % arr[i-1] == 0 对于 i % 2 == 0 为真
  • arr[i] % arr[i-1] != 0 对于 i % 2 != 0 为真
• 数组被认为是 1-indexed。

例子：

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}

方法：根据给定的条件，可以有多个大小为 N 的数组。根据以下观察，这是一种简单的贪婪方法来构建其中一个：

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.

基于以上观察，可以采用以下方法解决问题：

For this approach, we can simply consider the array constructed with X = 1 as per above sequence, as one of the possible solution.

• 声明一个大小为 N+1 的数组来存储答案并将变量 X 初始化为 1。
• 从 1 迭代到 N。
• 在每个奇数索引处，存储连续的奇数。
• 在每个偶数索引处，将整数的两倍存储在前一个索引处。

下面是上述方法的实现：

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

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

输出

1 2 3 6 5 10 7 

时间复杂度： O(N)
辅助空间： O(N)