Open In App

We use cookies to ensure you have the best browsing experience on our website. By using our site, you acknowledge that you have read and understood our Cookie Policy & Privacy Policy

Minimize swaps required to make all prime-indexed elements as prime

Given an array arr[] of size N. The task is to find the minimum number of swaps required to re-arrange the array such that all prime-indexed elements are prime, If the task can’t be achieved, print “-1“

Examples:



Input:  N = 5, arr[] = {1, 2, 3, 4, 5}
Output: 0
Explanation: All the prime indices {2, 3, 5} (one-based indexing) have prime elements present on them. Therefore, minimum swaps required is 0.

Input:  N = 5, arr[] = {2, 7, 8, 5, 13}
Output: 1
Explanation: swap 8 and 5 once, to get all the prime numbers at prime indices.



 

Approach: The task can be solved using the Sieve of Eratosthenes. 

Below is the implementation of the above approach:




#include <bits/stdc++.h>
using namespace std;
 
const int mxn = 1e4 + 1;
bool prime[mxn + 1];
 
// Function to pre-calculate the prime[]
// prime[i] denotes whether
// i is prime or not
void SieveOfEratosthenes()
{
    memset(prime, true, sizeof(prime));
 
    for (int p = 2; p * p <= mxn; p++) {
        // If prime[p] is not changed,
        // then it is a prime
        if (prime[p] == true) {
            // Update all multiples
            // of p greater than or
            // equal to the square of it
            // numbers which are multiple
            // of p and are less than p^2
            // are already been marked.
            for (int i = p * p; i <= mxn; i += p)
                prime[i] = false;
        }
    }
}
 
// Function to count minimum number
// of swaps required
int countMin(int arr[], int n)
{
    // To count the minimum number of swaps
    // required to convert the array into
    // perfectly prime
    int cMinSwaps = 0;
 
    // To count total number of prime
    // indexes in the array
    int cPrimeIndices = 0;
 
    // To count the total number of
    // prime numbers in the array
 
    int cPrimeNos = 0;
 
    for (int i = 0; i < n; i++) {
        // Check whether index
        // is prime or not
 
        if (prime[i + 1]) {
            cPrimeIndices++;
 
            // Element is not prime
            if (!prime[arr[i]])
                cMinSwaps++;
            else
                cPrimeNos++;
        }
        else if (prime[arr[i]]) {
            cPrimeNos++;
        }
    }
 
    // If the total number of prime numbers
    // is greater than or equal to the total
    // number of prime indices, then it is
    // possible to convert the array into
    // perfectly prime
    if (cPrimeNos >= cPrimeIndices)
        return cMinSwaps;
    else
        return -1;
}
// Driver Code
int main()
{
    // Pre-calculate prime[]
    SieveOfEratosthenes();
 
    int n = 5;
    int arr[5] = { 2, 7, 8, 5, 13 };
 
    cout << countMin(arr, n);
    return 0;
}
 





                        























                                    



                                    




                                    




                                    


                                



















// Java program for the above approach



import java.io.*;



 



class GFG {




    static boolean prime[] = new boolean[(int)1e4 + 2];




    static void SieveOfEratosthenes()




    {




        // Create a boolean array "prime[0..n]" and




        // initialize all entries it as true. A value in




        // prime[i] will finally be false if i is Not a




        // prime, else true.



 



        for (int i = 0; i < (int)1e4 + 2; i++)




            prime[i] = true;



 



        for (int p = 2; p * p < (int)1e4 + 2; p++) 




        {




           



            // If prime[p] is not changed, then it is a




            // prime




            if (prime[p] == true)




            {




               



                // Update all multiples of p




                for (int i = p * p; i < (int)1e4 + 2;




                     i += p)




                    prime[i] = false;




            }




        }




    }




   



    // Function to count minimum number




    // of swaps required




    static int countMin(int[] arr, int n)




    {




       



        // To count the minimum number of swaps




        // required to convert the array into




        // perfectly prime




        int cMinSwaps = 0;



 



        // To count total number of prime




        // indexes in the array




        int cPrimeIndices = 0;



 



        // To count the total number of




        // prime numbers in the array



 



        int cPrimeNos = 0;



 



        for (int i = 0; i < n; i++) {




            // Check whether index




            // is prime or not



 



            if (prime[i + 1]) {




                cPrimeIndices++;



 



                // Element is not prime




                if (prime[arr[i]] == false)




                    cMinSwaps++;




                else




                    cPrimeNos++;




            }




            else if (prime[arr[i]]) {




                cPrimeNos++;




            }




        }



 



        // If the total number of prime numbers




        // is greater than or equal to the total




        // number of prime indices, then it is




        // possible to convert the array into




        // perfectly prime




        if (cPrimeNos >= cPrimeIndices)




            return cMinSwaps;




        else




            return -1;




    }




   



    // Driver Code




    public static void main(String[] args)




    {




       



        // Pre-calculate prime[]




        SieveOfEratosthenes();



 



        int n = 5;




        int arr[] = { 2, 7, 8, 5, 13 };



 



        System.out.println(countMin(arr, n));




    }



}


 


// This code is contributed by Potta Lokesh


















                        






                        























                                    



                                    




                                    




                                    


                                



















# Python program for the above approach



import math



 



mxn = 10000 + 1




prime = [True for _ in range(mxn + 1)]



 


# Function to pre-calculate the prime[]


# prime[i] denotes whether


# i is prime or not



def SieveOfEratosthenes():




    global prime




    for p in range(2, int(math.sqrt(mxn)) + 1):




       



                # If prime[p] is not changed,




                # then it is a prime




        if (prime[p] == True):




                        # Update all multiples




                        # of p greater than or




                        # equal to the square of it




                        # numbers which are multiple




                        # of p and are less than p^2




                        # are already been marked.



 



            for i in range(p*p, mxn+1, p):




                prime[i] = False



 


 


# Function to count minimum number


# of swaps required



def countMin(arr, n):



 



        # To count the minimum number of swaps




        # required to convert the array into




        # perfectly prime




    cMinSwaps = 0



 



    # To count total number of prime




    # indexes in the array




    cPrimeIndices = 0



 



    # To count the total number of




    # prime numbers in the array



 



    cPrimeNos = 0



 



    for i in range(0, n):




                # Check whether index




                # is prime or not



 



        if (prime[i + 1]):




            cPrimeIndices += 1



 



            # Element is not prime




            if (not prime[arr[i]]):




                cMinSwaps += 1




            else:




                cPrimeNos += 1



 



        elif (prime[arr[i]]):




            cPrimeNos += 1



 



    # If the total number of prime numbers




    # is greater than or equal to the total




    # number of prime indices, then it is




    # possible to convert the array into




    # perfectly prime




    if (cPrimeNos >= cPrimeIndices):




        return cMinSwaps




    else:




        return -1



 


# Driver Code



if __name__ == "__main__":



 



    # Pre-calculate prime[]




    SieveOfEratosthenes()



 



    n = 5




    arr = [2, 7, 8, 5, 13]



 



    print(countMin(arr, n))



 



    # This code is contributed by rakeshsahni



















                        






                        























                                    



                                    




                                    




                                    


                                



















// C# program for the above approach



using System;



 



class GFG 



{



    static bool[] prime = new bool[(int)1e4 + 2];




    static void SieveOfEratosthenes()




    {




       



        // Create a boolean array "prime[0..n]" and




        // initialize all entries it as true. A value in




        // prime[i] will finally be false if i is Not a




        // prime, else true.




        for (int i = 0; i < (int)1e4 + 2; i++)




            prime[i] = true;



 



        for (int p = 2; p * p < (int)1e4 + 2; p++) {



 



            // If prime[p] is not changed, then it is a




            // prime




            if (prime[p] == true) {



 



                // Update all multiples of p




                for (int i = p * p; i < (int)1e4 + 2;




                     i += p)




                    prime[i] = false;




            }




        }




    }



 



    // Function to count minimum number




    // of swaps required




    static int countMin(int[] arr, int n)




    {



 



        // To count the minimum number of swaps




        // required to convert the array into




        // perfectly prime




        int cMinSwaps = 0;



 



        // To count total number of prime




        // indexes in the array




        int cPrimeIndices = 0;



 



        // To count the total number of




        // prime numbers in the array



 



        int cPrimeNos = 0;



 



        for (int i = 0; i < n; i++) {




            // Check whether index




            // is prime or not



 



            if (prime[i + 1]) {




                cPrimeIndices++;



 



                // Element is not prime




                if (prime[arr[i]] == false)




                    cMinSwaps++;




                else




                    cPrimeNos++;




            }




            else if (prime[arr[i]]) {




                cPrimeNos++;




            }




        }



 



        // If the total number of prime numbers




        // is greater than or equal to the total




        // number of prime indices, then it is




        // possible to convert the array into




        // perfectly prime




        if (cPrimeNos >= cPrimeIndices)




            return cMinSwaps;




        else




            return -1;




    }



 



    // Driver Code




    public static void Main()




    {



 



        // Pre-calculate prime[]




        SieveOfEratosthenes();



 



        int n = 5;




        int[] arr = { 2, 7, 8, 5, 13 };



 



        Console.Write(countMin(arr, n));




    }



}


 


// This code is contributed by subhammahato348.


















                        






                        























                                    



                                    




                                    




                                    


                                



















<script>


const mxn = 1e4 + 1;



let prime = new Array(mxn + 1);



 


// Function to pre-calculate the prime[]


// prime[i] denotes whether


// i is prime or not



function SieveOfEratosthenes() {




  prime.fill(true);



 



  for (let p = 2; p * p <= mxn; p++)




  {




   



    // If prime[p] is not changed,




    // then it is a prime




    if (prime[p] == true)




    {




     



      // Update all multiples




      // of p greater than or




      // equal to the square of it




      // numbers which are multiple




      // of p and are less than p^2




      // are already been marked.




      for (let i = p * p; i <= mxn; i += p) prime[i] = false;




    }




  }



}


 


// Function to count minimum number


// of swaps required



function countMin(arr, n)



{


 



  // To count the minimum number of swaps




  // required to convert the array into




  // perfectly prime




  let cMinSwaps = 0;



 



  // To count total number of prime




  // indexes in the array




  let cPrimeIndices = 0;



 



  // To count the total number of




  // prime numbers in the array



 



  let cPrimeNos = 0;



 



  for (let i = 0; i < n; i++) {




    // Check whether index




    // is prime or not



 



    if (prime[i + 1]) {




      cPrimeIndices++;



 



      // Element is not prime




      if (!prime[arr[i]]) cMinSwaps++;




      else cPrimeNos++;




    } else if (prime[arr[i]]) {




      cPrimeNos++;




    }




  }



 



  // If the total number of prime numbers




  // is greater than or equal to the total




  // number of prime indices, then it is




  // possible to convert the array into




  // perfectly prime




  if (cPrimeNos >= cPrimeIndices) return cMinSwaps;




  else return -1;



}


 


// Driver Code


 


// Pre-calculate prime[]


SieveOfEratosthenes();


 


let n = 5;


let arr = [2, 7, 8, 5, 13];


 


document.write(countMin(arr, n));


 


// This code is contributed by gfgking.


</script>


















                        






                        








Output

1


Time Complexity: O(mxn(log(log(mxn)))
Auxiliary Space: O(mxn)

	

        Article Tags : 
        

            Arrays
DSA
Mathematical        


		
	

	


      

      

          
Recommended Articles

      

      

          
          
1. Minimum swaps of similar indexed elements required to make all elements of one of the two given arrays equal

          
2. Minimum swaps of same-indexed elements required to make sum of two given arrays even

          
3. Bitwise XOR of same indexed array elements after rearranging an array to make XOR of same indexed elements of two arrays equal

          
4. Minimize swaps of same-indexed characters to make sum of ASCII value of characters of both the strings odd

          
5. Minimize swaps required to make the first and last elements the largest and smallest elements in the array respectively

          
6. Minimum swaps of same indexed elements required to obtain a Majority Element in one of the arrays

          
7. Minimize count of swaps of adjacent elements required to make an array increasing

          
8. Minimize replacements or swapping of same indexed characters required to make two given strings palindromic

          
9. Minimize swaps required to maximize the count of elements replacing a greater element in an Array

          
10. Minimize swaps required to place largest and smallest array elements at first and last array indices

          
11. Minimum number of swaps required to minimize sum of absolute differences between adjacent array elements

          
12. Minimize swap between same indexed elements to make given Arrays strictly increasing

          
13. Minimize subtraction followed by increments of adjacent elements required to make all array elements equal

          
14. Make all the elements of array odd by incrementing odd-indexed elements of odd-length subarrays

          
15. Minimize the Sum of all the subarrays made up of the products of same-indexed elements

          
16. Minimum number of swaps required to make parity of array elements  same as their indices

          
17. Minimize swaps of pairs of characters required such that no two adjacent characters in the string are same

          
18. Minimize steps required to make all array elements same by adding 1, 2 or 5

          
19. Minimize count of given operations required to be performed to make all array elements equal to 1

          
20. Minimize count of divisions by 2 required to make all array elements equal

          
21. Minimize cost of insertions and deletions required to make all array elements equal

          
22. Minimize increments required to make differences between all pairs of array elements even

          
23. Minimize cost required to make all array elements greater than or equal to zero

          
24. Minimize insertions required to make ratio of maximum and minimum of all pairs of adjacent array elements at most K

          
25. Minimize replacements of leftmost largest array element required to make all array elements equal