Skip to content
Related Articles

Related Articles

Improve Article

Maximum no. of contiguous Prime Numbers in an array

  • Difficulty Level : Medium
  • Last Updated : 11 May, 2021

Given an array arr[] of N elements. The task is to find the maximum number of the contiguous prime numbers in the given array.
Examples: 

Input: arr[] = {3, 5, 2, 66, 7, 11, 8}
Output: 3
Maximum contiguous prime number sequence is {2, 3, 5}

Input: arr[] = {1, 0, 2, 11, 32, 8, 9}
Output: 2
Maximum contiguous prime number sequence is {2, 11}

Approach: 

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.

  • Create a sieve to check whether an element is prime or not in O(1).
  • Traverse the array with two variables named current_max and max_so_far.
  • If a prime number is found then increment current_max and compare it with max_so_far.
  • If current_max is greater than max_so_far, then assign max_so_far with current_max
  • Every time a non-prime element is found reset current_max to 0.

Below is the implementation of the above approach:

C++




// C++ implementation of the approach
#include <bits/stdc++.h>
using namespace std;
 
void SieveOfEratosthenes(bool prime[], int p_size)
{
    // false here indicates
    // that it is not prime
    prime[0] = false;
    prime[1] = false;
 
    for (int p = 2; p * p <= p_size; p++) {
 
        // If prime[p] is not changed,
        // then it is a prime
        if (prime[p]) {
 
            // Update all multiples of p,
            // set them to non-prime
            for (int i = p * p; i <= p_size; i += p)
                prime[i] = false;
        }
    }
}
 
// Function that finds
// maximum contiguous subarray of prime numbers
int maxPrimeSubarray(int arr[], int n)
{
    int max_ele = *max_element(arr, arr+n);
    bool prime[max_ele + 1];
    memset(prime, true, sizeof(prime));
 
    SieveOfEratosthenes(prime, max_ele);
 
    int current_max = 0, max_so_far = 0;
 
    for (int i = 0; i < n; i++) {
 
        // check if element is non-prime
        if (prime[arr[i]] == false)
            current_max = 0;
 
        // If element is prime, than update
        // current_max and max_so_far accordingly.
        else {
            current_max++;
            max_so_far = max(current_max, max_so_far);
        }
    }
 
    return max_so_far;
}
 
// Driver code
int main()
{
 
    int arr[] = { 1, 0, 2, 4, 3, 29, 11, 7, 8, 9 };
    int n = sizeof(arr) / sizeof(arr[0]);
    cout << maxPrimeSubarray(arr, n);
 
    return 0;
}
Java



// Java implementation of the approach
import java.util.*;
 
class GFG
{
 
static void SieveOfEratosthenes(boolean prime[],
                                int p_size)
{
    // false here indicates
    // that it is not prime
    prime[0] = false;
    prime[1] = false;
 
    for (int p = 2; p * p <= p_size; p++)
    {
 
        // If prime[p] is not changed,
        // then it is a prime
        if (prime[p])
        {
 
            // Update all multiples of p,
            // set them to non-prime
            for (int i = p * p; i <= p_size; i += p)
                prime[i] = false;
        }
    }
}
 
// Function that finds
// maximum contiguous subarray of prime numbers
static int maxPrimeSubarray(int arr[], int n)
{
    int max_ele = Arrays.stream(arr).max().getAsInt();
    boolean prime[] = new boolean[max_ele + 1];
    Arrays.fill(prime, true);
 
    SieveOfEratosthenes(prime, max_ele);
 
    int current_max = 0, max_so_far = 0;
 
    for (int i = 0; i < n; i++)
    {
        // check if element is non-prime
        if (prime[arr[i]] == false)
            current_max = 0;
 
        // If element is prime, than update
        // current_max and max_so_far accordingly.
        else
        {
            current_max++;
            max_so_far = Math.max(current_max, max_so_far);
        }
    }
    return max_so_far;
}
 
// Driver code
public static void main(String[] args)
{
    int arr[] = { 1, 0, 2, 4, 3, 29, 11, 7, 8, 9 };
    int n = arr.length;
    System.out.print(maxPrimeSubarray(arr, n));
}
}
 
/* This code contributed by PrinciRaj1992 */
Python 3



# Python3 implementation of
# the approach
 
def SieveOfEratosthenes( prime, p_size):
 
    # false here indicates
    # that it is not prime
    prime[0] = False
    prime[1] = False
    for p in range(2,p_size+1):
        if(p*p>p_size):
            break
 
        # If prime[p] is not changed,
        # then it is a prime
        if (prime[p]):
 
            # Update all multiples of p,
            # set them to non-prime
            i=p*p
            while(i<=p_size):
                prime[i] = False
                i = i + p
         
# Function that finds
# maximum contiguous subarray of prime numbers
def maxPrimeSubarray( arr, n):
 
    max_ele = max(arr)
    prime=[True]*(max_ele + 1)
 
    SieveOfEratosthenes(prime, max_ele)
 
    current_max = 0
    max_so_far = 0
    for i in range(n):
 
        # check if element is non-prime
        if (prime[arr[i]] == False):
            current_max = 0
 
        # If element is prime, than update
        # current_max and max_so_far accordingly.
        else:
            current_max=current_max + 1
            max_so_far = max(current_max, max_so_far)
         
    return max_so_far
 
# Driver code
if __name__=='__main__':
    arr = [ 1, 0, 2, 4, 3, 29, 11, 7, 8, 9 ]
    n = len(arr)
    print(maxPrimeSubarray(arr, n))
 
# this code is contributed by
# ash264
C#



// C# implementation of the approach
using System;
using System.Linq;
 
class GFG
{
 
static void SieveOfEratosthenes(bool []prime,
                                int p_size)
{
    // false here indicates
    // that it is not prime
    prime[0] = false;
    prime[1] = false;
 
    for (int p = 2; p * p <= p_size; p++)
    {
 
        // If prime[p] is not changed,
        // then it is a prime
        if (prime[p])
        {
 
            // Update all multiples of p,
            // set them to non-prime
            for (int i = p * p; i <= p_size; i += p)
                prime[i] = false;
        }
    }
}
 
// Function that finds maximum
// contiguous subarray of prime numbers
static int maxPrimeSubarray(int []arr, int n)
{
    int max_ele = arr.Max();
    bool []prime = new bool[max_ele + 1];
    for(int i = 0; i < max_ele + 1; i++)
        prime[i]=true;
 
    SieveOfEratosthenes(prime, max_ele);
 
    int current_max = 0, max_so_far = 0;
 
    for (int i = 0; i < n; i++)
    {
        // check if element is non-prime
        if (prime[arr[i]] == false)
            current_max = 0;
 
        // If element is prime, than update
        // current_max and max_so_far accordingly.
        else
        {
            current_max++;
            max_so_far = Math.Max(current_max, max_so_far);
        }
    }
    return max_so_far;
}
 
// Driver code
public static void Main(String[] args)
{
    int []arr = { 1, 0, 2, 4, 3, 29, 11, 7, 8, 9 };
    int n = arr.Length;
    Console.Write(maxPrimeSubarray(arr, n));
}
}
 
// This code contributed by Rajput-Ji
Javascript



<script>
 
// Javascript implementation of the approach
 
function SieveOfEratosthenes(prime, p_size)
{
    // false here indicates
    // that it is not prime
    prime[0] = false;
    prime[1] = false;
 
    for (var p = 2; p * p <= p_size; p++) {
 
        // If prime[p] is not changed,
        // then it is a prime
        if (prime[p]) {
 
            // Update all multiples of p,
            // set them to non-prime
            for (var i = p * p; i <= p_size; i += p)
                prime[i] = false;
        }
    }
}
 
// Function that finds
// maximum contiguous subarray of prime numbers
function maxPrimeSubarray(arr, n)
{
    var max_ele = arr.reduce((a,b) => Math.max(a,b));
    var prime = Array(max_ele+1).fill(true);
 
    SieveOfEratosthenes(prime, max_ele);
 
    var current_max = 0, max_so_far = 0;
 
    for (var i = 0; i < n; i++) {
 
        // check if element is non-prime
        if (prime[arr[i]] == false)
            current_max = 0;
 
        // If element is prime, than update
        // current_max and max_so_far accordingly.
        else {
            current_max++;
            max_so_far = Math.max(current_max, max_so_far);
        }
    }
 
    return max_so_far;
}
 
// Driver code
var arr = [ 1, 0, 2, 4, 3, 29, 11, 7, 8, 9 ];
var n = arr.length;
document.write( maxPrimeSubarray(arr, n));
 
</script>
Output
4



My Personal Notes
arrow_drop_up
Next

Longest sub-array of Prime Numbers using Segmented Sieve
Recommended Articles
Page :
Count numbers in a given range having prime and non-prime digits at prime and non-prime positions respectively
15, Jan 21
Print numbers such that no two consecutive numbers are co-prime and every three consecutive numbers are co-prime
22, Jan 19
Absolute difference between the Product of Non-Prime numbers and Prime numbers of an Array
03, Nov 18
Absolute difference between the XOR of Non-Prime numbers and Prime numbers of an Array
23, Sep 19
Find the count of maximum contiguous Even numbers
12, Oct 18
Count prime numbers that can be expressed as sum of consecutive prime numbers
10, Sep 20
Count prime numbers up to N that can be represented as a sum of two prime numbers
14, Apr 21
Find prime factors of Z such that Z is product of all even numbers till N that are product of two distinct prime numbers
28, Jun 21
Maximum number of contiguous array elements with same number of set bits
13, Nov 18
Maximum product of sum of two contiguous subarrays of an array
20, Jan 20
Queries to find maximum sum contiguous subarrays of given length in a rotating array
15, Sep 20
Print prime numbers with prime sum of digits in an array
15, Jan 19
Segregate Prime and Non-Prime Numbers in an array
30, Apr 21
Print all maximal increasing contiguous sub-array in an array
06, Feb 20
Maximum absolute difference between sum of two contiguous sub-arrays
14, Jun 16
K maximum sums of non-overlapping contiguous sub-arrays
04, Jan 18
K maximum sums of overlapping contiguous sub-arrays
14, Jan 18
Maximum contiguous decreasing sequence obtained by removing any one element
18, Mar 20
Difference between maximum and minimum average of all K-length contiguous subarrays
12, Jul 21
Count of numbers of length N having prime numbers at odd indices and odd numbers at even indices
25, Aug 21
Prime numbers after prime P with sum S
27, Feb 18
Check if a prime number can be expressed as sum of two Prime Numbers
22, Nov 18
Print all numbers whose set of prime factors is a subset of the set of the prime factors of X
22, Apr 19
Sum of prime numbers without odd prime digits
29, Jul 19
Article Contributed By :
https://media.geeksforgeeks.org/auth/avatar.png
Shashank_Sharma
@Shashank_Sharma
Vote for difficulty
Current difficulty :
Medium





Improved By :
Article Tags :
Practice Tags :
Report Issue

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

Lightbox