Skip to content
Related Articles

Related Articles

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]
  • Last Updated : 10 May, 2021

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 the array A[].

Below is the implementation of the above approach:

C++




// C++ program for the above approach
#include <bits/stdc++.h>
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 Erastosthenes
    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<Integer> v
            = new ArrayList<Integer>();
 
    // Sieve of Erastosthenes
    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 Erastosthenes
    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 Erastosthenes
    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.
Output: 
2 3 5 7 2

 

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

Attention reader! Don’t stop learning now. Get hold of all the important mathematical concepts for competitive programming with the Essential Maths for CP Course at a student-friendly price. To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

My Personal Notes arrow_drop_up
Recommended Articles
Page :