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

Maximize the size of array by deleting exactly k sub-arrays to make array prime

Given an array arr[] of N positive integers and a non-negative integer K. The task is to delete exactly K sub-arrays from the array such that all the remaining elements of the array are prime and the size of the remaining array is maximum possible.

Examples: 



Input: arr[] = {2, 4, 2, 2, 4, 2, 4, 2}, k = 2 
Output: 4 
Delete the subarrays arr[1] and arr[4…6] and 
the remaining prime array will be {2, 2, 2, 2}

Input: arr[] = {2, 4, 2, 2, 4, 2, 4, 2}, k = 3 
Output: 5 



A simple approach would be to search for all the sub-arrays that would cost us O(N2) time complexity and then keep track of the number of primes or composites in a particular length of sub-array.

An efficient approach is to keep track of the number of primes between two consecutive composites.

  1. Preprocessing step: Store all the primes in the prime array using Sieve of Eratosthenes
  2. Compute the indices of all composite numbers in a vector v.
  3. Compute the distance between two consecutive indices of the above-described vector in a vector diff as this will store the number of primes between any two consecutive composites.
  4. Sort this vector. After sorting, we get the subarray that contains the least no of primes to the highest no of primes.
  5. Compute the prefix sum of this vector. Now each index of diff denotes the k value and the value in diff denotes no of primes to be deleted when deleting k subarrays. 0th index denotes the largest k less than the size of v, 1st index denotes the second-largest k, and so on. So, from the prefix sum vector, we directly get the no of primes to be deleted.

After performing the above steps, our solution depends on three cases: 

  1. This is an impossible case if k is 0 and there are composite integers in the array.
  2. If k is greater than or equal to no of composites, then we can delete all-composite integers and extra primes to equate the value k. These all subarrays are of size 1 which gives us the optimal answers.
  3. If k is less than no of composite integers, then we have to delete those subarrays which contain all the composite and no of primes falling into those subarrays.

Below is the implementation of the above approach:




// C++ implementation of the approach
#include <bits/stdc++.h>
using namespace std;
const int N = 1e7 + 5;
bool prime[N];
 
// Sieve of Eratosthenes
void sieve()
{
    for (int i = 2; i < N; i++) {
        if (!prime[i]) {
            for (int j = i + i; j < N; j += i) {
                prime[j] = 1;
            }
        }
    }
    prime[1] = 1;
}
 
// Function to return the size
// of the maximized array
int maxSizeArr(int* arr, int n, int k)
{
    vector<int> v, diff;
 
    // Insert the indices of composite numbers
    for (int i = 0; i < n; i++) {
        if (prime[arr[i]])
            v.push_back(i);
    }
 
    // Compute the number of prime between
    // two consecutive composite
    for (int i = 1; i < v.size(); i++) {
        diff.push_back(v[i] - v[i - 1] - 1);
    }
 
    // Sort the diff vector
    sort(diff.begin(), diff.end());
 
    // Compute the prefix sum of diff vector
    for (int i = 1; i < diff.size(); i++) {
        diff[i] += diff[i - 1];
    }
 
    // Impossible case
    if (k > n || (k == 0 && v.size())) {
        return -1;
    }
 
    // Delete sub-arrays of length 1
    else if (v.size() <= k) {
        return (n - k);
    }
 
    // Find the number of primes to be deleted
    // when deleting the sub-arrays
    else if (v.size() > k) {
        int tt = v.size() - k;
        int sum = 0;
        sum += diff[tt - 1];
        int res = n - (v.size() + sum);
        return res;
    }
}
 
// Driver code
int main()
{
    sieve();
    int arr[] = { 2, 4, 2, 2, 4, 2, 4, 2 };
    int n = sizeof(arr) / sizeof(arr[0]);
    int k = 2;
    cout << maxSizeArr(arr, n, k);
 
    return 0;
}
 





                        























                                    



                                    




                                    




                                    


                                



















// Java implementation of the approach



import java.util.*;



 



class GFG



{


 



static int N = 10000005;




static int []prime = new int[N];



 


// Sieve of Eratosthenes



static void sieve()



{



    for (int i = 2; i < N; i++) 




    {




        if (prime[i] == 0) 




        {




            for (int j = i + i; j < N; j += i)




            {




                prime[j] = 1;




            }




        }




    }




    prime[1] = 1;



}


 


// Function to return the size


// of the maximized array



static int maxSizeArr(int arr[], int n, int k)



{



    ArrayList<Integer> v = new ArrayList<Integer>(); 




    ArrayList<Integer> diff = new ArrayList<Integer>(); 



 



    // Insert the indices of composite numbers




    int num = 0;




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




    {




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




        {




            v.add(i);




        }




    }



 



    // Compute the number of prime between




    // two consecutive composite




    num = 0;




    for (int i = 1; i < v.size(); i++)




    {




        diff.add(v.get(i) - v.get(i - 1) - 1);




    }



 



    // Sort the diff vector




    Collections.sort(diff);



 



    // Compute the prefix sum of diff vector




    for (int i = 1; i < diff.size(); i++)




    {




        diff.set(i, diff.get(i) + diff.get(i - 1));




    }



 



    // Impossible case




    if (k > n || (k == 0 && v.size() > 0))




    {




        return -1;




    }



 



    // Delete sub-arrays of length 1




    else if (v.size() <= k) 




    {




        return (n - k);




    }



 



    // Find the number of primes to be deleted




    // when deleting the sub-arrays




    else if (v.size() > k)




    {




        int tt = v.size() - k;




        int sum = 0;




        sum += diff.get(tt - 1);




        int res = n - (v.size() + sum);




        return res;




    }




    return 1;



}



     


// Driver code



public static void main(String []args)



{



    sieve();




    int []arr = { 2, 4, 2, 2, 4, 2, 4, 2 };




    int n = arr.length;




    int k = 2;




    System.out.println(maxSizeArr(arr, n, k));



}


}


 


// This code is contributed by Surendra_Gangwar


















                        






                        























                                    



                                    




                                    




                                    


                                



















# Python implementation of above approach


 



N = 10000005




prime = [False]*N



 


# Sieve of Eratosthenes



def sieve():




    for i in range(2,N):




        if not prime[i]:




            for j in range(i+1,N):




                prime[j] = True




     



    prime[1] = True



 


# Function to return the size


# of the maximized array



def maxSizeArr(arr, n, k):




    v, diff = [], []



 



    # Insert the indices of composite numbers




    for i in range(n):




        if prime[arr[i]]:




            v.append(i)




     



    # Compute the number of prime between




    # two consecutive composite




    for i in range(1, len(v)):




        diff.append(v[i] - v[i-1] -1)




     



    # Sort the diff vector




    diff.sort()



 



    # Compute the prefix sum of diff vector




    for i in range(1, len(diff)):




        diff[i] += diff[i-1]




     



    # Impossible case




    if k > n or (k == 0 and len(v)):




        return -1




     



    # Delete sub-arrays of length 1




    elif len(v) <= k:




        return (n-k)




     



    # Find the number of primes to be deleted




    # when deleting the sub-arrays




    elif len(v) > k:




        tt = len(v) - k




        s = 0




        s += diff[tt-1]




        res = n - (len(v) + s)




        return res



 


 


# Driver code



if __name__ == "__main__":




     



    sieve()



 



    arr = [2, 4, 2, 2, 4, 2, 4, 2]




    n = len(arr)




    k = 2



 



    print(maxSizeArr(arr, n, k)) 



 


# This code is contributed by


# sanjeev2552 


















                        






                        























                                    



                                    




                                    




                                    


                                



















// C# implementation of the approach



using System;




using System.Collections.Generic;



 



class GFG{



 



static int N = 1000005;




static int []prime = new int[N];



 


// Sieve of Eratosthenes



static void sieve()



{



    for(int i = 2; i < N; i++) 




    {




        if (prime[i] == 0) 




        {




            for(int j = i + i; 




                    j < N; j += i)




            {




                prime[j] = 1;




            }




        }




    }




    prime[1] = 1;



}


 


// Function to return the size


// of the maximized array



static int maxSizeArr(int []arr, int n,




                                 int k)



{



    List<int> v = new List<int>(); 




    List<int> diff = new List<int>(); 



 



    // Insert the indices of composite numbers




    //int num = 0;




     



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




    {




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




        {




            v.Add(i);




        }




    }



 



    // Compute the number of prime between




    // two consecutive composite




    //num = 0;




    for(int i = 1; i < v.Count; i++)




    {




        diff.Add(v[i] - v[i - 1] - 1);




    }



 



    // Sort the diff vector




    diff.Sort();



 



    // Compute the prefix sum of diff vector




    for(int i = 1; i < diff.Count; i++)




    {




        diff[i] = diff[i] + diff[i - 1]; 




    }



 



    // Impossible case




    if (k > n || (k == 0 && v.Count > 0))




    {




        return -1;




    }



 



    // Delete sub-arrays of length 1




    else if (v.Count <= k) 




    {




        return (n - k);




    }



 



    // Find the number of primes to be deleted




    // when deleting the sub-arrays




    else if (v.Count > k)




    {




        int tt = v.Count - k;




        int sum = 0;




        sum += diff[tt - 1];




        int res = n - (v.Count + sum);




        return res;




    }




    return 1;



}



     


// Driver code



public static void Main(String []args)



{



    sieve();




    int []arr = { 2, 4, 2, 2, 4, 2, 4, 2 };




    int n = arr.Length;




    int k = 2;




     



    Console.WriteLine(maxSizeArr(arr, n, k));



}


}


 


// This code is contributed by Amit Katiyar


















                        






                        























                                    



                                    




                                    




                                    


                                



















<script>


// Javascript implementation of the approach


 


 


const N = 1e7 + 5;



let prime = new Array(N);



 


// Sieve of Eratosthenes



function sieve() {




    for (let i = 2; i < N; i++) {




        if (!prime[i]) {




            for (let j = i + i; j < N; j += i) {




                prime[j] = 1;




            }




        }




    }




    prime[1] = 1;



}


 


// Function to return the size


// of the maximized array



function maxSizeArr(arr, n, k) {




    let v = new Array();




    let diff = new Array();



 



    // Insert the indices of composite numbers




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




        if (prime[arr[i]])




            v.push(i);




    }



 



    // Compute the number of prime between




    // two consecutive composite




    for (let i = 1; i < v.length; i++) {




        diff.push(v[i] - v[i - 1] - 1);




    }



 



    // Sort the diff vector




    diff.sort((a, b) => a - b);



 



    // Compute the prefix sum of diff vector




    for (let i = 1; i < diff.length; i++) {




        diff[i] += diff[i - 1];




    }



 



    // Impossible case




    if (k > n || (k == 0 && v.length)) {




        return -1;




    }



 



    // Delete sub-arrays of length 1




    else if (v.length <= k) {




        return (n - k);




    }



 



    // Find the number of primes to be deleted




    // when deleting the sub-arrays




    else if (v.length > k) {




        let tt = v.length - k;




        let sum = 0;




        sum += diff[tt - 1];




        let res = n - (v.length + sum);




        return res;




    }



}


 


// Driver code


 


sieve();


let arr = [2, 4, 2, 2, 4, 2, 4, 2];


let n = arr.length;


let k = 2;


document.write(maxSizeArr(arr, n, k));


 


// This code is contributed by _saurabh_jaiswal


 


</script>


















                        






                        








Output: 

4


 


Time Complexity: O(N*logN), as we are using a inbuilt sort function to sort an array of size N. Where N is the number of elements in the array.
Auxiliary Space: O(10000005), as we using extra space for the prime array.

	

        Article Tags : 
        

            Arrays
DSA
Greedy
Sorting        


		
	

	


      

      

          
Recommended Articles

      

      

          
          
1. Ways to divide a binary array into sub-arrays such that each sub-array contains exactly one 1

          
2. Count the number of sub-arrays such that the average of elements present in the sub-array is greater than that not present in the sub-array

          
3. Count of index pairs (i, j) such that string after deleting ith character is equal to string after deleting jth character

          
4. Count numbers in a given range having prime and non-prime digits at prime and non-prime positions respectively

          
5. Minimum flips to make mean of all k size sub-arrays less than 1

          
6. Maximum sub-array sum after dividing array into sub-arrays based on the given queries

          
7. Maximum possible middle element of the array after deleting exactly k elements

          
8. Maximum length of longest increasing contiguous subarray after deleting exactly one element from array

          
9. Check if a string can become empty by recursively deleting a given sub-string

          
10. Maximize the maximum among minimum of K consecutive sub-arrays

          
11. Generate a string of size N whose each substring of size M has exactly K distinct characters

          
12. Maximize subarrays count containing the maximum and minimum Array element after deleting at most one element

          
13. Reduce Array and Maximize sum by deleting one occurrence of A[i] and all occurrences of A[i]+1 and A[i]-1

          
14. Maximize first element of Array by deleting first or adding a previously deleted element

          
15. Minimize deletions in Array by deleting all occurrences of any number such that array size is reduced to at least half

          
16. Maximize difference between sum of prime and non-prime array elements by left shifting of digits minimum number of times

          
17. Cpp14 Program to Maximize difference between sum of prime and non-prime array elements by left shifting of digits minimum number of times

          
18. Java Program to Maximize difference between sum of prime and non-prime array elements by left shifting of digits minimum number of times

          
19. Maximum OR sum of sub-arrays of two different arrays

          
20. Find sub-arrays from given two arrays such that they have equal sum

          
21. Check if number can be made prime by deleting a single digit

          
22. Count of unique prime numbers formed by deleting digits of given number

          
23. Find the longest sub-array having exactly k odd numbers

          
24. Minimum size binary string required such that probability of deleting two 1's at random is 1/X

          
25. Minimize steps to make Array elements equal by deleting adjacent pair and inserting bitwise OR