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

Count the number of primes in the prefix sum array of the given array

Given an array arr[] of N integers, the task is to count the number of primes in the prefix sum array of the given array. 
Examples: 
 

Input: arr[] = {1, 4, 8, 4} 
Output: 3 
The prefix sum array is {1, 5, 13, 17} 
and the three primes are 5, 13 and 17. 
Input: arr[] = {1, 5, 2, 3, 7, 9} 
Output: 1 
 

 

Approach: Create the prefix sum array and then use Sieve of Eratosthenes to count the number of primes in the prefix sum array. 
Below is the implementation of the above approach: 
 




// C++ implementation of the approach
#include <bits/stdc++.h>
using namespace std;
 
// Function to return the count of primes
// in the given array
int primeCount(int arr[], int n)
{
    // Find maximum value in the array
    int max_val = *max_element(arr, arr + n);
 
    // USE SIEVE TO FIND ALL PRIME NUMBERS LESS
    // THAN OR EQUAL TO max_val
    // Create a boolean array "prime[0..n]". A
    // value in prime[i] will finally be false
    // if i is Not a prime, else true.
    vector<bool> prime(max_val + 1, true);
 
    // Remaining part of SIEVE
    prime[0] = false;
    prime[1] = false;
    for (int p = 2; p * p <= max_val; 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 * 2; i <= max_val; i += p)
                prime[i] = false;
        }
    }
 
    // Find all primes in arr[]
    int count = 0;
    for (int i = 0; i < n; i++)
        if (prime[arr[i]])
            count++;
 
    return count;
}
 
// Function to generate the prefix array
void getPrefixArray(int arr[], int n, int pre[])
{
 
    // Fill the prefix array
    pre[0] = arr[0];
    for (int i = 1; i < n; i++) {
        pre[i] = pre[i - 1] + arr[i];
    }
}
 
// Driver code
int main()
{
 
    int arr[] = { 1, 4, 8, 4 };
    int n = sizeof(arr) / sizeof(arr[0]);
 
    // Prefix array of arr[]
    int pre[n];
    getPrefixArray(arr, n, pre);
 
    // Count of primes in the prefix array
    cout << primeCount(pre, n);
 
    return 0;
}
 





                        























                                    



                                    




                                    




                                    


                                



















// Java implementation of the approach



import java.util.*;



 



class GFG



{ 



     


//returns the max element



static int max_element(int a[])



{



    int m = a[0];




    for(int i = 0; i < a.length; i++)




        m = Math.max(a[i], m);




     



    return m;



}


 


// Function to return the count of primes


// in the given array



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



{



    // Find maximum value in the array




    int max_val = max_element(arr);



 



    // USE SIEVE TO FIND ALL PRIME NUMBERS LESS




    // THAN OR EQUAL TO max_val




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




    // value in prime[i] will finally be false




    // if i is Not a prime, else true.




    boolean prime[] = new boolean[max_val + 1];




    for (int p = 0; p <= max_val; p++)




        prime[p] = true; 



 



    // Remaining part of SIEVE




    prime[0] = false;




    prime[1] = false;




    for (int p = 2; p * p <= max_val; 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 * 2; i <= max_val; i += p)




                prime[i] = false;




        }




    }



 



    // Find all primes in arr[]




    int count = 0;




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




        if (prime[arr[i]])




            count++;



 



    return count;



}


 


// Function to generate the prefix array



static int[] getPrefixArray(int arr[], int n, int pre[])



{


 



    // Fill the prefix array




    pre[0] = arr[0];




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




    {




        pre[i] = pre[i - 1] + arr[i];




    }




    return pre;



}


 


// Driver code



public static void main(String args[])



{


 



    int arr[] = { 1, 4, 8, 4 };




    int n = arr.length;



 



    // Prefix array of arr[]




    int pre[]=new int[n];




    pre=getPrefixArray(arr, n, pre);



 



    // Count of primes in the prefix array




    System.out.println(primeCount(pre, n));



 


}


}


 


// This code is contributed by Arnab Kundu


















                        






                        























                                    



                                    




                                    




                                    


                                



















# Python3 implementation of the approach 


 


# Function to return the count 


# of primes in the given array 



def primeCount(arr, n): 




  



    # Find maximum value in the array 




    max_val = max(arr) 



 



    # USE SIEVE TO FIND ALL PRIME NUMBERS LESS 




    # THAN OR EQUAL TO max_val 




    # Create a boolean array "prime[0..n]". A 




    # value in prime[i] will finally be False 




    # if i is Not a prime, else True. 




    prime = [True] * (max_val+1) 



 



    # Remaining part of SIEVE 




    prime[0] = prime[1] = False




    p = 2




    while p * p <= max_val:  



 



        # If prime[p] is not changed, 




        # then it is a prime 




        if prime[p] == True:  



 



            # Update all multiples of p 




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




                prime[i] = False




                 



        p += 1




          



    # Find all primes in arr[] 




    count = 0




    for i in range(0, n): 




        if prime[arr[i]]: 




            count += 1



 



    return count 




  


# Function to generate the prefix array 



def getPrefixArray(arr, n, pre): 




  



    # Fill the prefix array 




    pre[0] = arr[0] 




    for i in range(1, n):  




        pre[i] = pre[i - 1] + arr[i] 



 


# Driver code 



if __name__ == "__main__":




  



    arr = [1, 4, 8, 4]  




    n = len(arr) 



 



    # Prefix array of arr[] 




    pre = [None] * n 




    getPrefixArray(arr, n, pre) 



 



    # Count of primes in the prefix array 




    print(primeCount(pre, n)) 



 


# This code is contributed by Rituraj Jain


















                        






                        























                                    



                                    




                                    




                                    


                                



















// C# implementation of the approach



using System;



 



class GFG



{ 



     


// returns the max element



static int max_element(int[] a)



{



    int m = a[0];




    for(int i = 0; i < a.Length; i++)




        m = Math.Max(a[i], m);




     



    return m;



}


 


// Function to return the count of primes


// in the given array



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



{



    // Find maximum value in the array




    int max_val = max_element(arr);



 



    // USE SIEVE TO FIND ALL PRIME NUMBERS LESS




    // THAN OR EQUAL TO max_val




    // Create a bool array "prime[0..n]". A




    // value in prime[i] will finally be false




    // if i is Not a prime, else true.




    bool[] prime = new bool[max_val + 1];




    for (int p = 0; p <= max_val; p++)




        prime[p] = true; 



 



    // Remaining part of SIEVE




    prime[0] = false;




    prime[1] = false;




    for (int p = 2; p * p <= max_val; 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 * 2; i <= max_val; i += p)




                prime[i] = false;




        }




    }



 



    // Find all primes in arr[]




    int count = 0;




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




        if (prime[arr[i]])




            count++;



 



    return count;



}


 


// Function to generate the prefix array



static int[] getPrefixArray(int[] arr, int n, int[] pre)



{


 



    // Fill the prefix array




    pre[0] = arr[0];




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




    {




        pre[i] = pre[i - 1] + arr[i];




    }




    return pre;



}


 


// Driver code



public static void Main()



{


 



    int[] arr = { 1, 4, 8, 4 };




    int n = arr.Length;



 



    // Prefix array of arr[]




    int[] pre = new int[n];




    pre = getPrefixArray(arr, n, pre);



 



    // Count of primes in the prefix array




    Console.Write(primeCount(pre, n));



 


}


}


 


// This code is contributed by ChitraNayal


















                        






                        























                                    



                                    




                                    




                                    


                                



















<?php


// PHP implementation of the approach 


 


// Function to return the count of primes 


// in the given array 



function primeCount($arr, $n) 



{ 



    // Find maximum value in the array 




    $max_val = max($arr); 



 



    // USE SIEVE TO FIND ALL PRIME NUMBERS LESS 




    // THAN OR EQUAL TO max_val 




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




    // value in prime[i] will finally be false 




    // if i is Not a prime, else true. 




    $prime = array_fill(0, $max_val + 1, true); 



 



    // Remaining part of SIEVE 




    $prime[0] = false; 




    $prime[1] = false; 




    for ($p = 2; $p * $p <= $max_val; $p++)




    { 



 



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




        // it is a prime 




        if ($prime[$p] == true) 




        { 



 



            // Update all multiples of p 




            for ($i = $p * 2; $i <= $max_val; $i += $p) 




                $prime[$i] = false; 




        } 




    } 



 



    // Find all primes in arr[] 




    $count = 0; 




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




        if ($prime[$arr[$i]]) 




            $count++; 



 



    return $count; 



} 


 


// Function to generate the prefix array 



function getPrefixArray($arr, $n, $pre) 



{ 


 



    // Fill the prefix array 




    $pre[0] = $arr[0]; 




    for ($i = 1; $i < $n; $i++) 




    { 




        $pre[$i] = $pre[$i - 1] + $arr[$i]; 




    } 




    return $pre ;



} 


 


// Driver code 



$arr = array( 1, 4, 8, 4 ); 




$n = count($arr) ;



 


// Prefix array of arr[] 



$pre = array(); 




$pre = getPrefixArray($arr, $n, $pre); 



 


// Count of primes in the prefix array 



echo primeCount($pre, $n); 



 


// This code is contributed by AnkitRai01


?>


















                        






                        























                                    



                                    




                                    




                                    


                                



















<script>


 


// Javascript implementation of the approach


 


// Function to return the count of primes


// in the given array



function primeCount(arr, n)



{



    // Find maximum value in the array




    let max_val = Math.max(...arr);



 



    // USE SIEVE TO FIND ALL PRIME NUMBERS LESS




    // THAN OR EQUAL TO max_val




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




    // value in prime[i] will finally be false




    // if i is Not a prime, else true.




    let prime = new Array(max_val + 1).fill(true);



 



    // Remaining part of SIEVE




    prime[0] = false;




    prime[1] = false;




    for (let p = 2; p * p <= max_val; p++) {



 



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




        // it is a prime




        if (prime[p] == true) {



 



            // Update all multiples of p




            for (let i = p * 2; i <= max_val; i += p)




                prime[i] = false;




        }




    }



 



    // Find all primes in arr[]




    let count = 0;




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




        if (prime[arr[i]])




            count++;



 



    return count;



}


 


// Function to generate the prefix array



function getPrefixArray(arr, n, pre)



{


 



    // Fill the prefix array




    pre[0] = arr[0];




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




        pre[i] = pre[i - 1] + arr[i];




    }



}


 


// Driver code


 



    let arr = [ 1, 4, 8, 4 ];




    let n = arr.length;



 



    // Prefix array of arr[]




    let pre = new Array(n);




    getPrefixArray(arr, n, pre);



 



    // Count of primes in the prefix array




    document.write(primeCount(pre, n));



 


</script>


















                        






                        








Output: 

3


 


Time Complexity: O(n + sqrt(max(arr))), where max(arr) is the largest element of the array arr.
Auxiliary Space: O(n + max(arr))

	

        Article Tags : 
        

            Arrays
DSA
Mathematical        


		
	

	


      

      

          
Recommended Articles

      

      

          
          
1. Count primes that can be expressed as sum of two consecutive primes and 1

          
2. Count of primes below N which can be expressed as the sum of two primes

          
3. Rearrange the array to maximize the number of primes in prefix sum of the array

          
4. Nth Term of a Fibonacci Series of Primes formed by concatenating pairs of Primes in a given range

          
5. Length of largest sub-array having primes strictly greater than non-primes

          
6. Count primes less than number formed by replacing digits of Array sum with prime count till the digit

          
7. Maximum prefix sum which is equal to suffix sum such that prefix and suffix do not overlap

          
8. Maximum sum increasing subsequence from a prefix and a given element after prefix is must

          
9. Prefix Factorials of a Prefix Sum Array

          
10. Check if count of substrings in S with string S1 as prefix and S2 as suffix is equal to that with S2 as prefix and S1 as suffix

          
11. Count of binary strings of length N having equal count of 0's and 1's and count of 1's ≥ count of 0's in each prefix substring

          
12. Count of primes in a given range that can be expressed as sum of perfect squares

          
13. Count of primes after converting given binary number in base between L to R

          
14. Count the number of rows and columns in given Matrix having all primes

          
15. Number of distinct ways to represent a number as sum of K unique primes

          
16. Count number of primes in an array

          
17. Count numbers  < = N whose difference with the count of primes upto them is  > = K

          
18. Count of all values of N in [L, R] such that count of primes upto N is also prime

          
19. Find original Array from given Array where each element is sum of prefix and postfix sum

          
20. Count numbers which can be represented as sum of same parity primes

          
21. Count distinct prime triplets up to N such that sum of two primes is equal to the third prime

          
22. Count Pairs with XOR Representable as Sum of Same Parity Primes

          
23. Count of indices up to which prefix and suffix sum is equal for given Array

          
24. Maximum Primes whose sum is equal to given N

          
25. Sum of all Primes in a given range using Sieve of Eratosthenes