# Construct an Array of length N containing exactly K elements divisible by their positions

• Last Updated : 04 Apr, 2022

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 = 2
Output: {5, 1, 2, 3, 4, 6}
Explanation: Considering the above array:
At Position 1, element 5 is divisible by 1
At Position 2, element 1 is not divisible by 2
At Position 3, element 2 is not divisible by 3
At Position 4, element 3 is not divisible by 4
At Position 5, element 4 is not divisible by 5
At Position 6, element 6 is divisible by 6
Therefore, there are exactly K elements in array divisible by their positions, meeting the required criteria.
Hence the resultant array will be {5 1 2 3 4 6}.

Input: N = 5, K = 5
Output: {1, 2, 3, 4, 5}

Approach: The problem can be solved easily using Greedy approach based on below observations:

For any integer X, we know that:

• X will be divisible by 1 and X always.
• No integer greater than X will ever be able to divide X.

So using these observations, we can construct the array containing exactly K elements divisible by their positions, as follows:

• For position 1, place any element greater than 1, because 1 will divide all integers
• For positions greater than 1, choose K-1 positions, and place them in the array at corresponding indices.
• The remaining N-K positions can be placed at any other position to match the required criteria.

Illustrations:

Consider an example: N = 6, K = 5

The empty array of size 6 will be:
arr[]:         _  _ _  _ _  _
positions: 1 2 3 4 5 6

Step 1: Fill position 1 with any integer greater than 1

• For 1st value equal to its position, we have 2 options – to insert 1 at 1, and to insert some integer greater than 1 at 1. If we insert 1 at 1, there will be a case when we cannot have K=5 values same as their positions. So we will insert some other value greater than 1 at position 1 (say 5):
• arr[]:         5 _ _  _ _  _
positions: 1 2 3 4 5 6

Step 2: Fill K-1 (=4) positions at corresponding indices

• For 2nd value equal to its position:
• arr[]:         5 2 _  _ _ _
positions: 1 2 3 4 5 6
• For 3rd value equal to its position:
• arr[]:         5 2 3  _ _ _
positions: 1 2 3 4 5 6
• For 4th value equal to its position:
• arr[]:         5 2 3 4 _ _
positions: 1 2 3 4 5 6
• For 5th value equal to its position, we cannot insert 5 at position 5, as it is already used at position 1. So we will insert 1 at position 5, and 6 at position 6:
• arr[]:         5 2 3 4 1 6
positions: 1 2 3 4 5 6

Therefore the final array will be: 5 2 3 4 1 6

Follow the steps below to implement the above approach:

• Create an array of N consecutive positive integers from 1 to N.
• After the index N-K, there will be K-1 elements left, we will not interfere with these elements. So, we have K-1 elements, which are divisible by their position.
• We will make First element of the array equal to the element at index N-K. This would also be divisible by its position.
• We will make the remaining elements (i.e. from index 1 to N-K) equal to the elements immediate left to them. These all N-K elements will not be divisible by their position then and remaining K elements would be divisible by their position.

Below is the implementation of the above approach:

## C++

 `// C++ program for above approach` `#include ` `using` `namespace` `std;`   `// Function to construct an array of size` `// N such that it contains all numbers from` `// 1 to N and only K elements are divisible by` `// their position (i.e. index+1)` `vector<``int``> constructArray(``int` `N, ``int` `K)` `{` `    ``// Declaring array of size N` `    ``vector<``int``> A(N, 0);`   `    ``// Initializing array as {1, 2, 3....N}` `    ``for` `(``int` `i = 0; i < N; i++) {` `        ``A[i] = i + 1;` `    ``}`   `    ``// N-K index stored in a variable "target"` `    ``// After target there will be k-1 elements` `    ``// which are divisible by their position` `    ``int` `target = N - K;`   `    ``// Initializing "prev" variable that helps in` `    ``// shifting elements to their right` `    ``int` `prev = A[0];`   `    ``// Assigning first element the value at target` `    ``// index` `    ``A[0] = A[target];`   `    ``// Making all elements from index 1 to target` `    ``// equal to their immediate left element` `    ``// as any number would not be divisible` `    ``// by its next number` `    ``for` `(``int` `i = 1; i <= target; i++) {` `        ``int` `temp = A[i];` `        ``A[i] = prev;` `        ``prev = temp;` `    ``}`   `    ``return` `A;` `}`   `// Driver Code` `int` `main()` `{` `    ``int` `N = 6, K = 2;`   `    ``// Calling function` `    ``// to construct the array` `    ``vector<``int``> A = constructArray(N, K);`   `    ``// Printing resultant array` `    ``for` `(``int` `i = 0; i < N; i++)` `        ``cout << A[i] << ``" "``;` `    ``cout << endl;` `}`

## Java

 `// JAVA program for above approach` `import` `java.util.*;` `class` `GFG ` `{` `  `  `    ``// Function to construct an array of size` `    ``// N such that it contains all numbers from` `    ``// 1 to N and only K elements are divisible by` `    ``// their position (i.e. index+1)` `    ``public` `static` `int``[] constructArray(``int` `N, ``int` `K)` `    ``{` `      `  `        ``// Declaring array of size N` `        ``int` `A[] = ``new` `int``[N];` `        ``for` `(``int` `i = ``0``; i < A.length; ++i) {` `            ``A[i] = ``0``;` `        ``}`   `        ``// Initializing array as {1, 2, 3....N}` `        ``for` `(``int` `i = ``0``; i < N; i++) {` `            ``A[i] = i + ``1``;` `        ``}`   `        ``// N-K index stored in a variable "target"` `        ``// After target there will be k-1 elements` `        ``// which are divisible by their position` `        ``int` `target = N - K;`   `        ``// Initializing "prev" variable that helps in` `        ``// shifting elements to their right` `        ``int` `prev = A[``0``];`   `        ``// Assigning first element the value at target` `        ``// index` `        ``A[``0``] = A[target];`   `        ``// Making all elements from index 1 to target` `        ``// equal to their immediate left element` `        ``// as any number would not be divisible` `        ``// by its next number` `        ``for` `(``int` `i = ``1``; i <= target; i++) {` `            ``int` `temp = A[i];` `            ``A[i] = prev;` `            ``prev = temp;` `        ``}`   `        ``return` `A;` `    ``}`   `    ``// Driver Code` `    ``public` `static` `void` `main(String[] args)` `    ``{` `        ``int` `N = ``6``, K = ``2``;`   `        ``// Calling function` `        ``// to construct the array` `        ``int` `A[] = constructArray(N, K);`   `        ``// Printing resultant array` `        ``for` `(``int` `i = ``0``; i < N; i++)` `            ``System.out.print(A[i] + ``" "``);` `        ``System.out.println();` `    ``}` `}`   `// This code is contributed by Taranpreet`

## Python3

 `# Python program for above approach`   `# Function to construct an array of size` `# N such that it contains all numbers from` `# 1 to N and only K elements are divisible by` `# their position (i.e. index+1)` `def` `constructArray(N, K):` `  `  `    ``# Declaring array of size N` `    ``A ``=` `[``0``]``*``N`   `    ``# Initializing array as {1, 2, 3....N}` `    ``for` `i ``in` `range``(N): ` `      ``A[i] ``=` `i ``+` `1`   `    ``# N-K index stored in a variable "target"` `    ``# After target there will be k-1 elements` `    ``# which are divisible by their position` `    ``target ``=` `N ``-` `K`   `    ``# Initializing "prev" variable that helps in` `    ``# shifting elements to their right` `    ``prev ``=` `A[``0``]`   `    ``# Assigning first element the value at target` `    ``# index` `    ``A[``0``] ``=` `A[target]`   `    ``# Making all elements from index 1 to target` `    ``# equal to their immediate left element` `    ``# as any number would not be divisible` `    ``# by its next number` `    ``for` `i ``in` `range``(``1``,target``+``1``):` `        ``temp ``=` `A[i]` `        ``A[i] ``=` `prev` `        ``prev ``=` `temp`   `    ``return` `A`   `# Driver Code` `N ``=` `6` `K ``=` `2`   `# Calling function` `# to construct the array` `A ``=` `constructArray(N, K)`   `# Printing resultant array` `for` `i ``in` `range``(N):` `   ``print``(A[i],end``=``" "``)`   `# This code is contributed by shinjanpatra`

## C#

 `// C# program for above approach` `using` `System;` `class` `GFG {`   `  ``// Function to construct an array of size` `  ``// N such that it contains all numbers from` `  ``// 1 to N and only K elements are divisible by` `  ``// their position (i.e. index+1)` `  ``static` `int``[] constructArray(``int` `N, ``int` `K)` `  ``{`   `    ``// Declaring array of size N` `    ``int``[] A = ``new` `int``[N];` `    ``for` `(``int` `i = 0; i < A.Length; ++i) {` `      ``A[i] = 0;` `    ``}`   `    ``// Initializing array as {1, 2, 3....N}` `    ``for` `(``int` `i = 0; i < N; i++) {` `      ``A[i] = i + 1;` `    ``}`   `    ``// N-K index stored in a variable "target"` `    ``// After target there will be k-1 elements` `    ``// which are divisible by their position` `    ``int` `target = N - K;`   `    ``// Initializing "prev" variable that helps in` `    ``// shifting elements to their right` `    ``int` `prev = A[0];`   `    ``// Assigning first element the value at target` `    ``// index` `    ``A[0] = A[target];`   `    ``// Making all elements from index 1 to target` `    ``// equal to their immediate left element` `    ``// as any number would not be divisible` `    ``// by its next number` `    ``for` `(``int` `i = 1; i <= target; i++) {` `      ``int` `temp = A[i];` `      ``A[i] = prev;` `      ``prev = temp;` `    ``}`   `    ``return` `A;` `  ``}`   `  ``// Driver Code` `  ``public` `static` `void` `Main()` `  ``{` `    ``int` `N = 6, K = 2;`   `    ``// Calling function` `    ``// to construct the array` `    ``int``[] A = constructArray(N, K);`   `    ``// Printing resultant array` `    ``for` `(``int` `i = 0; i < N; i++)` `      ``Console.Write(A[i] + ``" "``);` `    ``Console.WriteLine();` `  ``}` `}`   `// This code is contributed by Samim Hossain Mondal.`

## Javascript

 ``

Output

`5 1 2 3 4 6 `

Time Complexity:  O(N)
Auxiliary Space:  O(N)

My Personal Notes arrow_drop_up
Related Articles