# Generate an N-length array A[] from an array arr[] such that arr[i] is the last index consisting of a multiple of A[i]

Given an array arr[] of length N, with values less than N, the task is to construct another array A[] of same length such that for every ith element in the array A[], arr[i] is the last index (1-based indexing) consisting of a multiple of A[i].

Examples:

Input: arr[] = {4, 1, 2, 3, 4}
Output: 2 3 5 7 2
Explanation:
A[0]: Last index which can contain a multiple of A[0] has to be A[arr[0]] = A[4].
A[1]: Last index which can contain a multiple of A[1] has to be A[arr[1]] = A[1].
A[2]: Last index which can contain a multiple of A[2] has to be A[arr[2]] = A[2].
A[3]: Last index which can contain a multiple of A[3] has to be A[arr[3]] = A[3].
A[4]: Last index which can contain a multiple of A[4] has to be A[arr[4]] = A[4].
Hence, in the final array, A[4] must be divisible by A[0] and A[1], A[2] and A[3] must not be divisible by any other array elements.
Hence, the array A[] = {2, 3, 5, 7, 2} satisfies the condition.

Input: arr[] = {0, 1, 2, 3, 4}
Output: 2 3 5 7 11

Approach: The idea is to place prime numbers as array elements in required indices satisfying the conditions. Follow the steps below to solve the problem:

• Generate all Prime Numbers using Sieve Of Eratosthenes and store it in another array.
• Initialize array A[] with {0}, to store the required array.
• Traverse the array arr[] and perform the following steps:
• Check if A[arr[i]] is non-zero but A[i] is 0. If found to be true, then assign A[i] = A[arr[i]].
• Check if A[arr[i]] and A[i] are both 0 or not. If found to be true, then assign a prime number different to already assigned array elements, to both indices arr[i] and i.
• After completing the above steps, print the elements of array A[].

Below is the implementation of the above approach:

## C++

 `// C++ program for the above approach` `#include ` `using` `namespace` `std;`   `int` `sieve[1000000];`   `// Function to generate all` `// prime numbers upto 10^6` `void` `sieveOfPrimes()` `{` `    ``// Initialize sieve[] as 1` `    ``memset``(sieve, 1, ``sizeof``(sieve));`   `    ``int` `N = 1000000;`   `    ``// Iterate over the range [2, N]` `    ``for` `(``int` `i = 2; i * i <= N; i++) {`   `        ``// If current element is non-prime` `        ``if` `(sieve[i] == 0)` `            ``continue``;`   `        ``// Make all multiples of i as 0` `        ``for` `(``int` `j = i * i; j <= N; j += i)` `            ``sieve[j] = 0;` `    ``}` `}`   `// Function to construct an array A[]` `// satisfying the given conditions` `void` `getArray(``int``* arr, ``int` `N)` `{` `    ``// Stores the resultant array` `    ``int` `A[N] = { 0 };`   `    ``// Stores all prime numbers` `    ``vector<``int``> v;`   `    ``// Sieve of Eratosthenes` `    ``sieveOfPrimes();`   `    ``for` `(``int` `i = 2; i <= 1e5; i++)`   `        ``// Append the integer i` `        ``// if it is a prime` `        ``if` `(sieve[i])` `            ``v.push_back(i);`   `    ``// Indicates current position` `    ``// in list of prime numbers` `    ``int` `j = 0;`   `    ``// Traverse the array arr[]` `    ``for` `(``int` `i = 0; i < N; i++) {`   `        ``int` `ind = arr[i];`   `        ``// If already filled with` `        ``// another prime number` `        ``if` `(A[i] != 0)` `            ``continue``;`   `        ``// If A[i] is not filled` `        ``// but A[ind] is filled` `        ``else` `if` `(A[ind] != 0)`   `            ``// Store A[i] = A[ind]` `            ``A[i] = A[ind];`   `        ``// If none of them were filled` `        ``else` `{`   `            ``// To make sure A[i] does` `            ``// not affect other values,` `            ``// store next prime number` `            ``int` `prime = v[j++];`   `            ``A[i] = prime;` `            ``A[ind] = A[i];` `        ``}` `    ``}`   `    ``// Print the resultant array` `    ``for` `(``int` `i = 0; i < N; i++) {` `        ``cout << A[i] << ``" "``;` `    ``}` `}`   `// Driver Code` `int` `main()` `{` `    ``int` `arr[] = { 4, 1, 2, 3, 4 };` `    ``int` `N = ``sizeof``(arr) / ``sizeof``(arr[0]);`   `    ``// Function Call` `    ``getArray(arr, N);`   `    ``return` `0;` `}`

## Java

 `// Java program for the above approach` `import` `java.util.*;` `class` `GFG` `{`   `static` `int``[] sieve = ``new` `int``[``10000000``];`   `// Function to generate all` `// prime numbers upto 10^6` `static` `void` `sieveOfPrimes()` `{` `  `  `    ``// Initialize sieve[] as 1` `    ``Arrays.fill(sieve, ``1``);` `    ``int` `N = ``1000000``;`   `    ``// Iterate over the range [2, N]` `    ``for` `(``int` `i = ``2``; i * i <= N; i++)` `    ``{`   `        ``// If current element is non-prime` `        ``if` `(sieve[i] == ``0``)` `            ``continue``;`   `        ``// Make all multiples of i as 0` `        ``for` `(``int` `j = i * i; j <= N; j += i)` `            ``sieve[j] = ``0``;` `    ``}` `}`   `// Function to construct an array A[]` `// satisfying the given conditions` `static` `void` `getArray(``int``[] arr, ``int` `N)` `{` `  `  `    ``// Stores the resultant array` `    ``int` `A[] = ``new` `int``[N];` `    ``Arrays.fill(A, ``0``);`   `    ``// Stores all prime numbers` `    ``ArrayList v ` `            ``= ``new` `ArrayList(); `   `    ``// Sieve of Eratosthenes` `    ``sieveOfPrimes();`   `    ``for` `(``int` `i = ``2``; i <= ``1000000``; i++)`   `        ``// Append the integer i` `        ``// if it is a prime` `        ``if` `(sieve[i] != ``0``)` `            ``v.add(i);`   `    ``// Indicates current position` `    ``// in list of prime numbers` `    ``int` `j = ``0``;`   `    ``// Traverse the array arr[]` `    ``for` `(``int` `i = ``0``; i < N; i++) ` `    ``{` `        ``int` `ind = arr[i];`   `        ``// If already filled with` `        ``// another prime number` `        ``if` `(A[i] != ``0``)` `            ``continue``;`   `        ``// If A[i] is not filled` `        ``// but A[ind] is filled` `        ``else` `if` `(A[ind] != ``0``)`   `            ``// Store A[i] = A[ind]` `            ``A[i] = A[ind];`   `        ``// If none of them were filled` `        ``else` `{`   `            ``// To make sure A[i] does` `            ``// not affect other values,` `            ``// store next prime number` `            ``int` `prime = v.get(j++);`   `            ``A[i] = prime;` `            ``A[ind] = A[i];` `        ``}` `    ``}`   `    ``// Print the resultant array` `    ``for` `(``int` `i = ``0``; i < N; i++) {` `        ``System.out.print( A[i] + ``" "``);` `    ``}` `}`   `// Driver Code` `public` `static` `void` `main(String[] args)` `{` `    ``int` `arr[] = { ``4``, ``1``, ``2``, ``3``, ``4` `};` `    ``int` `N = arr.length;`   `    ``// Function Call` `    ``getArray(arr, N);`   `}` `}`   `// This code is contributed by code_hunt.`

## Python3

 `# Python3 program for the above approach` `sieve ``=` `[``1``]``*``(``1000000``+``1``)`   `# Function to generate all` `# prime numbers upto 10^6` `def` `sieveOfPrimes():` `    ``global` `sieve` `    ``N ``=` `1000000`   `    ``# Iterate over the range [2, N]` `    ``for` `i ``in` `range``(``2``, N ``+` `1``):` `        ``if` `i ``*` `i > N:` `            ``break` `            `  `        ``# If current element is non-prime` `        ``if` `(sieve[i] ``=``=` `0``):` `            ``continue`   `        ``# Make all multiples of i as 0` `        ``for` `j ``in` `range``(i ``*` `i, N ``+` `1``, i):` `            ``sieve[j] ``=` `0`   `# Function to construct an array A[]` `# satisfying the given conditions` `def` `getArray(arr, N):` `    ``global` `sieve` `    `  `    ``# Stores the resultant array` `    ``A ``=` `[``0``]``*``N`   `    ``# Stores all prime numbers` `    ``v ``=` `[]`   `    ``# Sieve of Eratosthenes` `    ``sieveOfPrimes()` `    ``for` `i ``in` `range``(``2``,``int``(``1e5``)``+``1``):`   `        ``# Append the integer i` `        ``# if it is a prime` `        ``if` `(sieve[i]):` `            ``v.append(i)`   `    ``# Indicates current position` `    ``# in list of prime numbers` `    ``j ``=` `0`   `    ``# Traverse the array arr[]` `    ``for` `i ``in` `range``(N):` `        ``ind ``=` `arr[i]`   `        ``# If already filled with` `        ``# another prime number` `        ``if` `(A[i] !``=` `0``):` `            ``continue`   `        ``# If A[i] is not filled` `        ``# but A[ind] is filled` `        ``elif` `(A[ind] !``=` `0``):`   `            ``# Store A[i] = A[ind]` `            ``A[i] ``=` `A[ind]` `            `  `        ``# If none of them were filled` `        ``else``:`   `            ``# To make sure A[i] does` `            ``# not affect other values,` `            ``# store next prime number` `            ``prime ``=` `v[j]` `            ``A[i] ``=` `prime` `            ``A[ind] ``=` `A[i]` `            ``j ``+``=` `1`   `    ``# Print the resultant array` `    ``for` `i ``in` `range``(N):` `        ``print``(A[i], end ``=` `" "``)`   `        ``# Driver Code` `if` `__name__ ``=``=` `'__main__'``:` `    ``arr ``=` `[``4``, ``1``, ``2``, ``3``, ``4``]` `    ``N ``=` `len``(arr)`   `    ``# Function Call` `    ``getArray(arr, N)`   `    ``# This code is contributed by mohit kumar 29.`

## C#

 `// C# Program to implement` `// the above approach` `using` `System;` `using` `System.Collections.Generic; `   `class` `GFG ` `{` `  ``static` `int``[] sieve = ``new` `int``[10000000];`   `  ``// Function to generate all` `  ``// prime numbers upto 10^6` `  ``static` `void` `sieveOfPrimes()` `  ``{`   `    ``// Initialize sieve[] as 1` `    ``for``(``int` `i = 0; i < 10000000; i++)` `    ``{` `      ``sieve[i] = 1;` `    ``}` `    ``int` `N = 1000000;`   `    ``// Iterate over the range [2, N]` `    ``for` `(``int` `i = 2; i * i <= N; i++)` `    ``{`   `      ``// If current element is non-prime` `      ``if` `(sieve[i] == 0)` `        ``continue``;`   `      ``// Make all multiples of i as 0` `      ``for` `(``int` `j = i * i; j <= N; j += i)` `        ``sieve[j] = 0;` `    ``}` `  ``}`   `  ``// Function to construct an array A[]` `  ``// satisfying the given conditions` `  ``static` `void` `getArray(``int``[] arr, ``int` `N)` `  ``{`   `    ``// Stores the resultant array` `    ``int``[] A = ``new` `int``[N];` `    ``for``(``int` `i = 0; i < N; i++)` `    ``{` `      ``A[i] = 0;` `    ``}`   `    ``// Stores all prime numbers` `    ``List<``int``> v ` `      ``= ``new` `List<``int``>(); `   `    ``// Sieve of Eratosthenes` `    ``sieveOfPrimes();`   `    ``for` `(``int` `i = 2; i <= 1000000; i++)`   `      ``// Append the integer i` `      ``// if it is a prime` `      ``if` `(sieve[i] != 0)` `        ``v.Add(i);`   `    ``// Indicates current position` `    ``// in list of prime numbers` `    ``int` `j = 0;`   `    ``// Traverse the array arr[]` `    ``for` `(``int` `i = 0; i < N; i++) ` `    ``{` `      ``int` `ind = arr[i];`   `      ``// If already filled with` `      ``// another prime number` `      ``if` `(A[i] != 0)` `        ``continue``;`   `      ``// If A[i] is not filled` `      ``// but A[ind] is filled` `      ``else` `if` `(A[ind] != 0)`   `        ``// Store A[i] = A[ind]` `        ``A[i] = A[ind];`   `      ``// If none of them were filled` `      ``else` `{`   `        ``// To make sure A[i] does` `        ``// not affect other values,` `        ``// store next prime number` `        ``int` `prime = v[j++];`   `        ``A[i] = prime;` `        ``A[ind] = A[i];` `      ``}` `    ``}`   `    ``// Print the resultant array` `    ``for` `(``int` `i = 0; i < N; i++) ` `    ``{` `      ``Console.Write( A[i] + ``" "``);` `    ``}` `  ``}`     `  ``// Driver Code` `  ``public` `static` `void` `Main(String[] args) ` `  ``{` `    ``int``[] arr = { 4, 1, 2, 3, 4 };` `    ``int` `N = arr.Length;`   `    ``// Function Call` `    ``getArray(arr, N);` `  ``}` `}`   `// This code is contributed by splevel62.`

## Javascript

 ``

Output:

`2 3 5 7 2`

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

Feeling lost in the world of random DSA topics, wasting time without progress? It's time for a change! Join our DSA course, where we'll guide you on an exciting journey to master DSA efficiently and on schedule.
Ready to dive in? Explore our Free Demo Content and join our DSA course, trusted by over 100,000 geeks!

Previous
Next