Segregate Prime and Non-Prime Numbers in an array
Last Updated :
06 Jul, 2023
Given an array arr[] of size N, the task is to rearrange the array elements such that all the Prime numbers are placed before the Non-prime numbers.
Examples:
Input: arr[] = {1, 8, 2, 3, 4, 5, 7, 20}
Output: 7 5 2 3 4 8 1 20
Explanation:
The output consists of all the prime numbers 7 5 2 3, followed by Non-Prime numbers 4 8 1 20.
Input: arr[] = {2, 3, 4, 5, 6, 7, 8, 9, 10}
Output: 2 3 7 5 6 4 8 9 10
Naive Approach:
The simplest approach to solve this problem is to make two arrays/vectors to store the prime and non-prime array elements respectively and print the prime numbers followed by the non-primes numbers.
Steps to implement this approach:
- Make two vector prime and nonPrime to store prime and non-prime numbers
- After that traverse the whole input array and if any number is prime then push that into the prime vector else into the nonPrime vector
- To check if any number is prime or not, we will take care of many edge cases like 0,1 is not prime, 2,3 is prime, etc..
- In the last first print elements of the prime vector then print elements of the nonPrime vector
Code to implement the above steps:
C++
#include <bits/stdc++.h>
using namespace std;
bool isPrime( int n)
{
if (n <= 1)
return false ;
if (n <= 3)
return true ;
if (n % 2 == 0 || n % 3 == 0)
return false ;
for ( int i = 5;
i * i <= n; i = i + 6) {
if (n % i == 0
|| n % (i + 2) == 0)
return false ;
}
return true ;
}
void segregatePrimeNonPrime(
int arr[], int N)
{
vector< int > prime;
vector< int > nonPrime;
for ( int i=0;i<N;i++){
if (isPrime(arr[i])){prime.push_back(arr[i]);}
else {nonPrime.push_back(arr[i]);}
}
for ( int i=0;i<prime.size();i++){
cout<<prime[i]<< " " ;
}
for ( int i=0;i<nonPrime.size();i++){
cout<<nonPrime[i]<< " " ;
}
}
int main()
{
int arr[] = { 2, 3, 4, 6, 7, 8, 9, 10 };
int N = sizeof (arr) / sizeof (arr[0]);
segregatePrimeNonPrime(arr, N);
return 0;
}
|
Java
import java.util.*;
public class Main
{
public static boolean isPrime( int n)
{
if (n <= 1 )
return false ;
if (n <= 3 )
return true ;
if (n % 2 == 0 || n % 3 == 0 )
return false ;
for ( int i = 5 ; i * i <= n; i = i + 6 ) {
if (n % i == 0 || n % (i + 2 ) == 0 )
return false ;
}
return true ;
}
public static void segregatePrimeNonPrime( int [] arr,
int N)
{
ArrayList<Integer> prime = new ArrayList<Integer>();
ArrayList<Integer> nonPrime
= new ArrayList<Integer>();
for ( int i = 0 ; i < N; i++) {
if (isPrime(arr[i])) {
prime.add(arr[i]);
}
else {
nonPrime.add(arr[i]);
}
}
for ( int i = 0 ; i < prime.size(); i++) {
System.out.print(prime.get(i) + " " );
}
for ( int i = 0 ; i < nonPrime.size(); i++) {
System.out.print(nonPrime.get(i) + " " );
}
}
public static void main(String[] args)
{
int [] arr = { 2 , 3 , 4 , 6 , 7 , 8 , 9 , 10 };
int N = arr.length;
segregatePrimeNonPrime(arr, N);
}
}
|
Python3
import math
def isPrime(n):
if n < = 1 :
return False
if n < = 3 :
return True
if n % 2 = = 0 or n % 3 = = 0 :
return False
for i in range ( 5 , int (math.sqrt(n)) + 1 , 6 ):
if n % i = = 0 or n % (i + 2 ) = = 0 :
return False
return True
def segregatePrimeNonPrime(arr, N):
prime = []
nonPrime = []
for i in range (N):
if isPrime(arr[i]):
prime.append(arr[i])
else :
nonPrime.append(arr[i])
for i in range ( len (prime)):
print (prime[i], end = " " )
for i in range ( len (nonPrime)):
print (nonPrime[i], end = " " )
if __name__ = = '__main__' :
arr = [ 2 , 3 , 4 , 6 , 7 , 8 , 9 , 10 ]
N = len (arr)
segregatePrimeNonPrime(arr, N)
|
C#
using System;
using System.Collections.Generic;
public class MainClass
{
public static bool IsPrime( int n)
{
if (n <= 1)
return false ;
if (n <= 3)
return true ;
if (n % 2 == 0 || n % 3 == 0)
return false ;
for ( int i = 5; i * i <= n; i = i + 6)
{
if (n % i == 0 || n % (i + 2) == 0)
return false ;
}
return true ;
}
public static void SegregatePrimeNonPrime( int [] arr, int N)
{
List< int > prime = new List< int >();
List< int > nonPrime = new List< int >();
for ( int i = 0; i < N; i++)
{
if (IsPrime(arr[i]))
{
prime.Add(arr[i]);
}
else
{
nonPrime.Add(arr[i]);
}
}
for ( int i = 0; i < prime.Count; i++)
{
Console.Write(prime[i] + " " );
}
for ( int i = 0; i < nonPrime.Count; i++)
{
Console.Write(nonPrime[i] + " " );
}
}
public static void Main( string [] args)
{
int [] arr = { 2, 3, 4, 6, 7, 8, 9, 10 };
int N = arr.Length;
SegregatePrimeNonPrime(arr, N);
}
}
|
Javascript
<script>
function isPrime(n) {
if (n <= 1) {
return false ;
}
if (n <= 3) {
return true ;
}
if (n % 2 === 0 || n % 3 === 0) {
return false ;
}
for (let i = 5; i * i <= n; i += 6) {
if (n % i === 0 || n % (i + 2) === 0) {
return false ;
}
}
return true ;
}
function segregatePrimeNonPrime(arr) {
let prime = [];
let nonPrime = [];
for (let i = 0; i < arr.length; i++) {
if (isPrime(arr[i])) {
prime.push(arr[i]);
} else {
nonPrime.push(arr[i]);
}
}
for (let i = 0; i < prime.length; i++) {
document.write(prime[i] + " " );
}
for (let i = 0; i < nonPrime.length; i++) {
document.write(nonPrime[i] + " " );
}
}
let arr = [2, 3, 4, 6, 7, 8, 9, 10];
segregatePrimeNonPrime(arr);
</script>
|
Output-
2 3 7 4 6 8 9 10
Time Complexity: O(N*sqrt(N)), O(N) for traversing the array, and sqrt(N) for finding whether any number is prime or not.
Auxiliary Space: O(N),because of prime and nonPrime vector
Alternate Approach: To optimize the auxiliary space of the above approach, the idea to solve this problem is using the Two-Pointer Approach. Follow the steps below to solve the problem:
- Initialize two pointers left as 0 and right to the end of the array as (N – 1).
- Traverse the array until left is less than right and do the following:
- Keep incrementing the left pointer until the element pointing to the left index is Prime Number.
- Keep decrementing the right pointer until the element pointing to the left index is a non-Prime Number.
- If left is less than right then swap arr[left] and arr[right] and increment left and decrement right by 1.
- After the above steps, print the update array arr[].
Below is the implementation of the above approach:
C++
#include <iostream>
using namespace std;
void swap( int * a, int * b)
{
int temp = *a;
*a = *b;
*b = temp;
}
bool isPrime( int n)
{
if (n <= 1)
return false ;
if (n <= 3)
return true ;
if (n % 2 == 0 || n % 3 == 0)
return false ;
for ( int i = 5;
i * i <= n; i = i + 6) {
if (n % i == 0
|| n % (i + 2) == 0)
return false ;
}
return true ;
}
void segregatePrimeNonPrime(
int arr[], int N)
{
int left = 0, right = N - 1;
while (left < right) {
while (isPrime(arr[left]))
left++;
while (!isPrime(arr[right]))
right--;
if (left < right) {
swap(&arr[left], &arr[right]);
left++;
right--;
}
}
for ( int i = 0; i < N; i++)
cout << arr[i] << " " ;
}
int main()
{
int arr[] = { 2, 3, 4, 6, 7, 8, 9, 10 };
int N = sizeof (arr) / sizeof (arr[0]);
segregatePrimeNonPrime(arr, N);
return 0;
}
|
Java
import java.io.*;
import java.lang.*;
import java.util.*;
public class GFG {
static boolean isPrime( int n)
{
if (n <= 1 )
return false ;
if (n <= 3 )
return true ;
if (n % 2 == 0 || n % 3 == 0 )
return false ;
for ( int i = 5 ; i * i <= n; i = i + 6 ) {
if (n % i == 0 || n % (i + 2 ) == 0 )
return false ;
}
return true ;
}
static void segregatePrimeNonPrime( int arr[], int N)
{
int left = 0 , right = N - 1 ;
while (left < right) {
while (isPrime(arr[left]))
left++;
while (!isPrime(arr[right]))
right--;
if (left < right) {
int temp = arr[right];
arr[right] = arr[left];
arr[left] = temp;
left++;
right--;
}
}
for ( int i = 0 ; i < N; i++)
System.out.print(arr[i] + " " );
}
public static void main(String[] args)
{
int arr[] = { 2 , 3 , 4 , 6 , 7 , 8 , 9 , 10 };
int N = arr.length;
segregatePrimeNonPrime(arr, N);
}
}
|
Python3
def isPrime(n):
if (n < = 1 ):
return False
if (n < = 3 ):
return True
if (n % 2 = = 0 or n % 3 = = 0 ):
return False
i = 5
while (i * i < = n):
if (n % i = = 0 or n % (i + 2 ) = = 0 ):
return False
i + = 6
return True
def segregatePrimeNonPrime(arr, N):
left, right = 0 , N - 1
while (left < right):
while (isPrime(arr[left])):
left + = 1
while ( not isPrime(arr[right])):
right - = 1
if (left < right):
arr[left], arr[right] = arr[right], arr[left]
left + = 1
right - = 1
for num in arr:
print (num, end = " " )
arr = [ 2 , 3 , 4 , 6 , 7 , 8 , 9 , 10 ]
N = len (arr)
segregatePrimeNonPrime(arr, N)
|
C#
using System;
class GFG{
static bool isPrime( int n)
{
if (n <= 1)
return false ;
if (n <= 3)
return true ;
if (n % 2 == 0 || n % 3 == 0)
return false ;
for ( int i = 5; i * i <= n; i = i + 6)
{
if (n % i == 0 || n % (i + 2) == 0)
return false ;
}
return true ;
}
static void segregatePrimeNonPrime( int [] arr, int N)
{
int left = 0, right = N - 1;
while (left < right)
{
while (isPrime(arr[left]))
left++;
while (!isPrime(arr[right]))
right--;
if (left < right)
{
int temp = arr[right];
arr[right] = arr[left];
arr[left] = temp;
left++;
right--;
}
}
for ( int i = 0; i < N; i++)
Console.Write(arr[i] + " " );
}
public static void Main( string [] args)
{
int [] arr = { 2, 3, 4, 6, 7, 8, 9, 10 };
int N = arr.Length;
segregatePrimeNonPrime(arr, N);
}
}
|
Javascript
<script>
function SieveOfEratosthenes(prime, n)
{
for (let p = 2; p * p <= n; p++)
{
if (prime[p] == true )
{
for (let i = p * p; i <= n; i += p)
prime[i] = false ;
}
}
}
function segregatePrimeNonPrime(prime, arr, N)
{
SieveOfEratosthenes(prime, 10000000);
let left = 0, right = N - 1;
while (left < right)
{
while (prime[arr[left]])
left++;
while (!prime[arr[right]])
right--;
if (left < right)
{
let temp = arr[left];
arr[left] = arr[right];
arr[right] = temp;
left++;
right--;
}
}
for (let i = 0; i < N; i++)
document.write(arr[i] + " " );
}
let prime = Array.from({length: 10000001}, (_, i) => true );
let arr = [ 2, 3, 4, 6, 7, 8, 9, 10 ];
let N = arr.length;
segregatePrimeNonPrime(prime, arr, N);
</script>
|
Time Complexity: O(N*sqrt(N))
Auxiliary Space: O(1), since no extra space has been taken.
Efficient Approach: The above approach can be optimized by using the Sieve of Eratosthenes to find whether the number is prime or non-prime in constant time.
Below is the implementation of the above approach:
C++
#include <bits/stdc++.h>
#include <iostream>
using namespace std;
bool prime[10000001];
void swap( int * a, int * b)
{
int temp = *a;
*a = *b;
*b = temp;
}
void SieveOfEratosthenes( int n)
{
memset (prime, true , sizeof (prime));
for ( int p = 2; p * p <= n; p++) {
if (prime[p] == true ) {
for ( int i = p * p;
i <= n; i += p)
prime[i] = false ;
}
}
}
void segregatePrimeNonPrime(
int arr[], int N)
{
SieveOfEratosthenes(10000000);
int left = 0, right = N - 1;
while (left < right) {
while (prime[arr[left]])
left++;
while (!prime[arr[right]])
right--;
if (left < right) {
swap(&arr[left], &arr[right]);
left++;
right--;
}
}
for ( int i = 0; i < N; i++)
cout << arr[i] << " " ;
}
int main()
{
int arr[] = { 2, 3, 4, 6, 7, 8, 9, 10 };
int N = sizeof (arr) / sizeof (arr[0]);
segregatePrimeNonPrime(arr, N);
return 0;
}
|
Java
import java.util.*;
class GFG{
public static void SieveOfEratosthenes( boolean [] prime,
int n)
{
for ( int p = 2 ; p * p <= n; p++)
{
if (prime[p] == true )
{
for ( int i = p * p; i <= n; i += p)
prime[i] = false ;
}
}
}
public static void segregatePrimeNonPrime( boolean [] prime,
int arr[], int N)
{
SieveOfEratosthenes(prime, 10000000 );
int left = 0 , right = N - 1 ;
while (left < right)
{
while (prime[arr[left]])
left++;
while (!prime[arr[right]])
right--;
if (left < right)
{
int temp = arr[left];
arr[left] = arr[right];
arr[right] = temp;
left++;
right--;
}
}
for ( int i = 0 ; i < N; i++)
System.out.printf(arr[i] + " " );
}
public static void main(String[] args)
{
boolean [] prime = new boolean [ 10000001 ];
Arrays.fill(prime, true );
int arr[] = { 2 , 3 , 4 , 6 , 7 , 8 , 9 , 10 };
int N = arr.length;
segregatePrimeNonPrime(prime, arr, N);
}
}
|
Python3
def SieveOfEratosthenes(prime, n):
p = 2
while (p * p < = n):
if (prime[p] = = True ):
i = p * p
while (i < = n):
prime[i] = False
i + = p
p + = 1
def segregatePrimeNonPrime(prime, arr, N):
SieveOfEratosthenes(prime, 10000000 )
left, right = 0 , N - 1
while (left < right):
while (prime[arr[left]]):
left + = 1
while ( not prime[arr[right]]):
right - = 1
if (left < right):
arr[left], arr[right] = arr[right], arr[left]
left + = 1
right - = 1
for num in arr:
print (num, end = " " )
arr = [ 2 , 3 , 4 , 6 , 7 , 8 , 9 , 10 ]
N = len (arr)
prime = [ True ] * 10000001
segregatePrimeNonPrime(prime, arr, N)
|
C#
using System;
class GFG{
public static void SieveOfEratosthenes( bool [] prime,
int n)
{
for ( int p = 2; p * p <= n; p++)
{
if (prime[p] == true )
{
for ( int i = p * p; i <= n; i += p)
prime[i] = false ;
}
}
}
public static void segregatePrimeNonPrime( bool [] prime,
int []arr, int N)
{
SieveOfEratosthenes(prime, 10000000);
int left = 0, right = N - 1;
while (left < right)
{
while (prime[arr[left]])
left++;
while (!prime[arr[right]])
right--;
if (left < right)
{
int temp = arr[left];
arr[left] = arr[right];
arr[right] = temp;
left++;
right--;
}
}
for ( int i = 0; i < N; i++)
Console.Write(arr[i] + " " );
}
public static void Main(String[] args)
{
bool [] prime = new bool [10000001];
for ( int i = 0; i < prime.Length; i++)
prime[i] = true ;
int []arr = { 2, 3, 4, 6, 7, 8, 9, 10 };
int N = arr.Length;
segregatePrimeNonPrime(prime, arr, N);
}
}
|
Javascript
function SieveOfEratosthenes(prime, n)
{
for (let p = 2; p * p <= n; p++)
{
if (prime[p] == true )
{
for (let i = p * p; i <= n; i += p)
prime[i] = false ;
}
}
}
function segregatePrimeNonPrime(prime, arr, N)
{
SieveOfEratosthenes(prime, 10000000);
let left = 0, right = N - 1;
while (left < right)
{
while (prime[arr[left]])
left++;
while (!prime[arr[right]])
right--;
if (left < right)
{
let temp = arr[left];
arr[left] = arr[right];
arr[right] = temp;
left++;
right--;
}
}
for (let i = 0; i < N; i++)
console.log(arr[i] + " " );
}
let prime = Array.from({length: 10000001},
(_, i) => true );
let arr = [ 2, 3, 4, 6, 7, 8, 9, 10 ];
let N = arr.length;
segregatePrimeNonPrime(prime, arr, N);
|
Time Complexity: O(N*log(log(N)))
Auxiliary Space: O(N)
Share your thoughts in the comments
Please Login to comment...