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++ program for the above approach #include <bits/stdc++.h> using namespace std;
// Function to check if a number n // is a prime number of not bool isPrime( int n)
{ // Edges Cases
if (n <= 1)
return false ;
if (n <= 3)
return true ;
// To skip middle five numbers
if (n % 2 == 0 || n % 3 == 0)
return false ;
// Checks for prime or non prime
for ( int i = 5;
i * i <= n; i = i + 6) {
// If n is divisible by i
// or i + 2, return false
if (n % i == 0
|| n % (i + 2) == 0)
return false ;
}
// Otherwise, the
// number is prime
return true ;
} // Function to segregate the primes // and non-primes present in an array void segregatePrimeNonPrime(
int arr[], int N)
{ //To store Prime Numbers
vector< int > prime;
//To store non-prime numbers
vector< int > nonPrime;
//Traverse the input array
for ( int i=0;i<N;i++){
if (isPrime(arr[i])){prime.push_back(arr[i]);}
else {nonPrime.push_back(arr[i]);}
}
//First print all prime numbers
for ( int i=0;i<prime.size();i++){
cout<<prime[i]<< " " ;
}
//After printing all prime numbers print all non-prime numbers
for ( int i=0;i<nonPrime.size();i++){
cout<<nonPrime[i]<< " " ;
}
} // Driver Code int main()
{ int arr[] = { 2, 3, 4, 6, 7, 8, 9, 10 };
int N = sizeof (arr) / sizeof (arr[0]);
segregatePrimeNonPrime(arr, N);
return 0;
} |
import java.util.*;
public class Main
{ // Function to check if a number n
// is a prime number of not
public static boolean isPrime( int n)
{
// Edges Cases
if (n <= 1 )
return false ;
if (n <= 3 )
return true ;
// To skip middle five numbers
if (n % 2 == 0 || n % 3 == 0 )
return false ;
// Checks for prime or non prime
for ( int i = 5 ; i * i <= n; i = i + 6 ) {
// If n is divisible by i
// or i + 2, return false
if (n % i == 0 || n % (i + 2 ) == 0 )
return false ;
}
// Otherwise, the
// number is prime
return true ;
}
// Function to segregate the primes
// and non-primes present in an array
public static void segregatePrimeNonPrime( int [] arr,
int N)
{
// To store Prime Numbers
ArrayList<Integer> prime = new ArrayList<Integer>();
// To store non-prime numbers
ArrayList<Integer> nonPrime
= new ArrayList<Integer>();
// Traverse the input array
for ( int i = 0 ; i < N; i++) {
if (isPrime(arr[i])) {
prime.add(arr[i]);
}
else {
nonPrime.add(arr[i]);
}
}
// First print all prime numbers
for ( int i = 0 ; i < prime.size(); i++) {
System.out.print(prime.get(i) + " " );
}
// After printing all prime numbers print all
// non-prime numbers
for ( int i = 0 ; i < nonPrime.size(); i++) {
System.out.print(nonPrime.get(i) + " " );
}
}
// Driver Code
public static void main(String[] args)
{
int [] arr = { 2 , 3 , 4 , 6 , 7 , 8 , 9 , 10 };
int N = arr.length;
segregatePrimeNonPrime(arr, N);
}
} |
# Python program for the above approach import math
# Function to check if a number n is a prime number of not def isPrime(n):
# Edges Cases
if n < = 1 :
return False
if n < = 3 :
return True
# To skip middle five numbers
if n % 2 = = 0 or n % 3 = = 0 :
return False
# Checks for prime or non prime
for i in range ( 5 , int (math.sqrt(n)) + 1 , 6 ):
# If n is divisible by i or i + 2, return false
if n % i = = 0 or n % (i + 2 ) = = 0 :
return False
# Otherwise, the number is prime
return True
# Function to segregate the primes and non-primes present in an array def segregatePrimeNonPrime(arr, N):
# To store Prime Numbers
prime = []
# To store non-prime numbers
nonPrime = []
# Traverse the input array
for i in range (N):
if isPrime(arr[i]):
prime.append(arr[i])
else :
nonPrime.append(arr[i])
# First print all prime numbers
for i in range ( len (prime)):
print (prime[i], end = " " )
# After printing all prime numbers print all non-prime numbers
for i in range ( len (nonPrime)):
print (nonPrime[i], end = " " )
# Driver Code if __name__ = = '__main__' :
arr = [ 2 , 3 , 4 , 6 , 7 , 8 , 9 , 10 ]
N = len (arr)
segregatePrimeNonPrime(arr, N)
|
using System;
using System.Collections.Generic;
public class MainClass
{ // Function to check if a number n
// is a prime number of not
public static bool IsPrime( int n)
{
// Edge Cases
if (n <= 1)
return false ;
if (n <= 3)
return true ;
// To skip middle five numbers
if (n % 2 == 0 || n % 3 == 0)
return false ;
// Checks for prime or non prime
for ( int i = 5; i * i <= n; i = i + 6)
{
// If n is divisible by i
// or i + 2, return false
if (n % i == 0 || n % (i + 2) == 0)
return false ;
}
// Otherwise, the
// number is prime
return true ;
}
// Function to segregate the primes
// and non-primes present in an array
public static void SegregatePrimeNonPrime( int [] arr, int N)
{
// To store Prime Numbers
List< int > prime = new List< int >();
// To store non-prime numbers
List< int > nonPrime = new List< int >();
// Traverse the input array
for ( int i = 0; i < N; i++)
{
if (IsPrime(arr[i]))
{
prime.Add(arr[i]);
}
else
{
nonPrime.Add(arr[i]);
}
}
// First print all prime numbers
for ( int i = 0; i < prime.Count; i++)
{
Console.Write(prime[i] + " " );
}
// After printing all prime numbers print all
// non-prime numbers
for ( int i = 0; i < nonPrime.Count; i++)
{
Console.Write(nonPrime[i] + " " );
}
}
// Driver Code
public static void Main( string [] args)
{
int [] arr = { 2, 3, 4, 6, 7, 8, 9, 10 };
int N = arr.Length;
SegregatePrimeNonPrime(arr, N);
}
} |
<script> // Javascript program for the above approach
// Function to check if a number n
// is a prime number of not
function isPrime(n) {
// Edges Cases
if (n <= 1) {
return false ;
}
if (n <= 3) {
return true ;
}
// To skip middle five numbers
if (n % 2 === 0 || n % 3 === 0) {
return false ;
}
// Checks for prime or non prime
for (let i = 5; i * i <= n; i += 6) {
// If n is divisible by i
// or i + 2, return false
if (n % i === 0 || n % (i + 2) === 0) {
return false ;
}
}
// Otherwise, the
// number is prime
return true ;
}
// Function to segregate the primes
// and non-primes present in an array
function segregatePrimeNonPrime(arr) {
//To store Prime Numbers
let prime = [];
//To store non-prime numbers
let nonPrime = [];
//Traverse the input array
for (let i = 0; i < arr.length; i++) {
if (isPrime(arr[i])) {
prime.push(arr[i]);
} else {
nonPrime.push(arr[i]);
}
}
//First print all prime numbers
for (let i = 0; i < prime.length; i++) {
document.write(prime[i] + " " );
}
//After printing all prime numbers print all non-prime numbers
for (let i = 0; i < nonPrime.length; i++) {
document.write(nonPrime[i] + " " );
}
}
// Driver Code
let arr = [2, 3, 4, 6, 7, 8, 9, 10];
segregatePrimeNonPrime(arr);
// This code is contributed by Pushpesh Raj
</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++ program for the above approach #include <iostream> using namespace std;
// Function to swap two numbers a and b void swap( int * a, int * b)
{ int temp = *a;
*a = *b;
*b = temp;
} // Function to check if a number n // is a prime number of not bool isPrime( int n)
{ // Edges Cases
if (n <= 1)
return false ;
if (n <= 3)
return true ;
// To skip middle five numbers
if (n % 2 == 0 || n % 3 == 0)
return false ;
// Checks for prime or non prime
for ( int i = 5;
i * i <= n; i = i + 6) {
// If n is divisible by i
// or i + 2, return false
if (n % i == 0
|| n % (i + 2) == 0)
return false ;
}
// Otherwise, the
// number is prime
return true ;
} // Function to segregate the primes // and non-primes present in an array void segregatePrimeNonPrime(
int arr[], int N)
{ // Initialize left and right pointers
int left = 0, right = N - 1;
// Traverse the array
while (left < right) {
// Increment left while array
// element at left is prime
while (isPrime(arr[left]))
left++;
// Decrement right while array
// element at right is non-prime
while (!isPrime(arr[right]))
right--;
// If left < right, then swap
// arr[left] and arr[right]
if (left < right) {
// Swap arr[left] and arr[right]
swap(&arr[left], &arr[right]);
left++;
right--;
}
}
// Print segregated array
for ( int i = 0; i < N; i++)
cout << arr[i] << " " ;
} // Driver Code 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 program for the above approach import java.io.*;
import java.lang.*;
import java.util.*;
public class GFG {
// Function to check if a number n
// is a prime number of not
static boolean isPrime( int n)
{
// Edges Cases
if (n <= 1 )
return false ;
if (n <= 3 )
return true ;
// To skip middle five numbers
if (n % 2 == 0 || n % 3 == 0 )
return false ;
// Checks for prime or non prime
for ( int i = 5 ; i * i <= n; i = i + 6 ) {
// If n is divisible by i
// or i + 2, return false
if (n % i == 0 || n % (i + 2 ) == 0 )
return false ;
}
// Otherwise, the
// number is prime
return true ;
}
// Function to segregate the primes
// and non-primes present in an array
static void segregatePrimeNonPrime( int arr[], int N)
{
// Initialize left and right pointers
int left = 0 , right = N - 1 ;
// Traverse the array
while (left < right) {
// Increment left while array
// element at left is prime
while (isPrime(arr[left]))
left++;
// Decrement right while array
// element at right is non-prime
while (!isPrime(arr[right]))
right--;
// If left < right, then swap
// arr[left] and arr[right]
if (left < right) {
// Swap arr[left] and arr[right]
int temp = arr[right];
arr[right] = arr[left];
arr[left] = temp;
left++;
right--;
}
}
// Print segregated array
for ( int i = 0 ; i < N; i++)
System.out.print(arr[i] + " " );
}
// Driver Code
public static void main(String[] args)
{
int arr[] = { 2 , 3 , 4 , 6 , 7 , 8 , 9 , 10 };
int N = arr.length;
segregatePrimeNonPrime(arr, N);
}
} // This code is contributed by Kingash. |
# Python3 program for the above approach # Function to check if a number n # is a prime number of not def isPrime(n):
# Edges Cases
if (n < = 1 ):
return False
if (n < = 3 ):
return True
# To skip middle five numbers
if (n % 2 = = 0 or n % 3 = = 0 ):
return False
# Checks for prime or non prime
i = 5
while (i * i < = n):
# If n is divisible by i or i + 2,
# return False
if (n % i = = 0 or n % (i + 2 ) = = 0 ):
return False
i + = 6
# Otherwise, the number is prime
return True
# Function to segregate the primes and # non-primes present in an array def segregatePrimeNonPrime(arr, N):
# Initialize left and right pointers
left, right = 0 , N - 1
# Traverse the array
while (left < right):
# Increment left while array element
# at left is prime
while (isPrime(arr[left])):
left + = 1
# Decrement right while array element
# at right is non-prime
while ( not isPrime(arr[right])):
right - = 1
# If left < right, then swap
# arr[left] and arr[right]
if (left < right):
# Swap arr[left] and arr[right]
arr[left], arr[right] = arr[right], arr[left]
left + = 1
right - = 1
# Print segregated array
for num in arr:
print (num, end = " " )
# Driver code arr = [ 2 , 3 , 4 , 6 , 7 , 8 , 9 , 10 ]
N = len (arr)
segregatePrimeNonPrime(arr, N) # This code is contributed by girishthatte |
// C# program for the above approach using System;
class GFG{
// Function to check if a number n // is a prime number of not static bool isPrime( int n)
{ // Edges Cases
if (n <= 1)
return false ;
if (n <= 3)
return true ;
// To skip middle five numbers
if (n % 2 == 0 || n % 3 == 0)
return false ;
// Checks for prime or non prime
for ( int i = 5; i * i <= n; i = i + 6)
{
// If n is divisible by i
// or i + 2, return false
if (n % i == 0 || n % (i + 2) == 0)
return false ;
}
// Otherwise, the
// number is prime
return true ;
} // Function to segregate the primes // and non-primes present in an array static void segregatePrimeNonPrime( int [] arr, int N)
{ // Initialize left and right pointers
int left = 0, right = N - 1;
// Traverse the array
while (left < right)
{
// Increment left while array
// element at left is prime
while (isPrime(arr[left]))
left++;
// Decrement right while array
// element at right is non-prime
while (!isPrime(arr[right]))
right--;
// If left < right, then swap
// arr[left] and arr[right]
if (left < right)
{
// Swap arr[left] and arr[right]
int temp = arr[right];
arr[right] = arr[left];
arr[left] = temp;
left++;
right--;
}
}
// Print segregated array
for ( int i = 0; i < N; i++)
Console.Write(arr[i] + " " );
} // Driver Code public static void Main( string [] args)
{ int [] arr = { 2, 3, 4, 6, 7, 8, 9, 10 };
int N = arr.Length;
segregatePrimeNonPrime(arr, N);
} } // This code is contributed by ukasp |
<script> // Javascript program implementation // of the approach // Function to generate prime numbers // using Sieve of Eratosthenes function SieveOfEratosthenes(prime, n)
{ for (let p = 2; p * p <= n; p++)
{
// If prime[p] is unchanged,
// then it is a prime
if (prime[p] == true )
{
// Update all multiples of p
for (let i = p * p; i <= n; i += p)
prime[i] = false ;
}
}
} // Function to segregate the primes and non-primes function segregatePrimeNonPrime(prime, arr, N)
{ // Generate all primes till 10^
SieveOfEratosthenes(prime, 10000000);
// Initialize left and right
let left = 0, right = N - 1;
// Traverse the array
while (left < right)
{
// Increment left while array element
// at left is prime
while (prime[arr[left]])
left++;
// Decrement right while array element
// at right is non-prime
while (!prime[arr[right]])
right--;
// If left < right, then swap arr[left]
// and arr[right]
if (left < right)
{
// Swap arr[left] and arr[right]
let temp = arr[left];
arr[left] = arr[right];
arr[right] = temp;
left++;
right--;
}
}
// Print segregated array
for (let i = 0; i < N; i++)
document.write(arr[i] + " " );
} // Driver Code let prime = Array.from({length: 10000001}, (_, i) => true );
let arr = [ 2, 3, 4, 6, 7, 8, 9, 10 ];
let N = arr.length;
// Function Call
segregatePrimeNonPrime(prime, arr, N);
</script> |
2 3 7 6 4 8 9 10
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++ program for the above approach #include <bits/stdc++.h> #include <iostream> using namespace std;
bool prime[10000001];
// Function to swap two numbers a and b void swap( int * a, int * b)
{ int temp = *a;
*a = *b;
*b = temp;
} // Function to generate prime numbers // using Sieve of Eratosthenes void SieveOfEratosthenes( int n)
{ memset (prime, true , sizeof (prime));
for ( int p = 2; p * p <= n; p++) {
// If prime[p] is unchanged,
// then it is a prime
if (prime[p] == true ) {
// Update all multiples of p
for ( int i = p * p;
i <= n; i += p)
prime[i] = false ;
}
}
} // Function to segregate the primes // and non-primes void segregatePrimeNonPrime(
int arr[], int N)
{ // Generate all primes till 10^7
SieveOfEratosthenes(10000000);
// Initialize left and right
int left = 0, right = N - 1;
// Traverse the array
while (left < right) {
// Increment left while array
// element at left is prime
while (prime[arr[left]])
left++;
// Decrement right while array
// element at right is non-prime
while (!prime[arr[right]])
right--;
// If left < right, then swap
// arr[left] and arr[right]
if (left < right) {
// Swap arr[left] and arr[right]
swap(&arr[left], &arr[right]);
left++;
right--;
}
}
// Print segregated array
for ( int i = 0; i < N; i++)
cout << arr[i] << " " ;
} // Driver code int main()
{ int arr[] = { 2, 3, 4, 6, 7, 8, 9, 10 };
int N = sizeof (arr) / sizeof (arr[0]);
// Function Call
segregatePrimeNonPrime(arr, N);
return 0;
} |
// Java program for the above approach import java.util.*;
class GFG{
// Function to generate prime numbers // using Sieve of Eratosthenes public static void SieveOfEratosthenes( boolean [] prime,
int n)
{ for ( int p = 2 ; p * p <= n; p++)
{
// If prime[p] is unchanged,
// then it is a prime
if (prime[p] == true )
{
// Update all multiples of p
for ( int i = p * p; i <= n; i += p)
prime[i] = false ;
}
}
} // Function to segregate the primes and non-primes public static void segregatePrimeNonPrime( boolean [] prime,
int arr[], int N)
{ // Generate all primes till 10^
SieveOfEratosthenes(prime, 10000000 );
// Initialize left and right
int left = 0 , right = N - 1 ;
// Traverse the array
while (left < right)
{
// Increment left while array element
// at left is prime
while (prime[arr[left]])
left++;
// Decrement right while array element
// at right is non-prime
while (!prime[arr[right]])
right--;
// If left < right, then swap arr[left]
// and arr[right]
if (left < right)
{
// Swap arr[left] and arr[right]
int temp = arr[left];
arr[left] = arr[right];
arr[right] = temp;
left++;
right--;
}
}
// Print segregated array
for ( int i = 0 ; i < N; i++)
System.out.printf(arr[i] + " " );
} // Driver code 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;
// Function Call
segregatePrimeNonPrime(prime, arr, N);
} } // This code is contributed by girishthatte |
# Python3 program for the above approach # Function to generate prime numbers # using Sieve of Eratosthenes def SieveOfEratosthenes(prime, n):
p = 2
while (p * p < = n):
# If prime[p] is unchanged,
# then it is a prime
if (prime[p] = = True ):
# Update all multiples of p
i = p * p
while (i < = n):
prime[i] = False
i + = p
p + = 1
# Function to segregate the primes and non-primes def segregatePrimeNonPrime(prime, arr, N):
# Generate all primes till 10^7
SieveOfEratosthenes(prime, 10000000 )
# Initialize left and right
left, right = 0 , N - 1
# Traverse the array
while (left < right):
# Increment left while array element
# at left is prime
while (prime[arr[left]]):
left + = 1
# Decrement right while array element
# at right is non-prime
while ( not prime[arr[right]]):
right - = 1
# If left < right, then swap arr[left]
# and arr[right]
if (left < right):
# Swap arr[left] and arr[right]
arr[left], arr[right] = arr[right], arr[left]
left + = 1
right - = 1
# Print segregated array
for num in arr:
print (num, end = " " )
# Driver code arr = [ 2 , 3 , 4 , 6 , 7 , 8 , 9 , 10 ]
N = len (arr)
prime = [ True ] * 10000001
# Function Call segregatePrimeNonPrime(prime, arr, N) # This code is contributed by girishthatte |
// C# program for the above approach using System;
class GFG{
// Function to generate prime numbers // using Sieve of Eratosthenes public static void SieveOfEratosthenes( bool [] prime,
int n)
{ for ( int p = 2; p * p <= n; p++)
{
// If prime[p] is unchanged,
// then it is a prime
if (prime[p] == true )
{
// Update all multiples of p
for ( int i = p * p; i <= n; i += p)
prime[i] = false ;
}
}
} // Function to segregate the primes and non-primes public static void segregatePrimeNonPrime( bool [] prime,
int []arr, int N)
{ // Generate all primes till 10^
SieveOfEratosthenes(prime, 10000000);
// Initialize left and right
int left = 0, right = N - 1;
// Traverse the array
while (left < right)
{
// Increment left while array element
// at left is prime
while (prime[arr[left]])
left++;
// Decrement right while array element
// at right is non-prime
while (!prime[arr[right]])
right--;
// If left < right, then swap arr[left]
// and arr[right]
if (left < right)
{
// Swap arr[left] and arr[right]
int temp = arr[left];
arr[left] = arr[right];
arr[right] = temp;
left++;
right--;
}
}
// Print segregated array
for ( int i = 0; i < N; i++)
Console.Write(arr[i] + " " );
} // Driver code 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;
// Function Call
segregatePrimeNonPrime(prime, arr, N);
} } // This code is contributed by Princi Singh |
// Javascript program for the above approach // Function to generate prime numbers // using Sieve of Eratosthenes function SieveOfEratosthenes(prime, n)
{ for (let p = 2; p * p <= n; p++)
{
// If prime[p] is unchanged,
// then it is a prime
if (prime[p] == true )
{
// Update all multiples of p
for (let i = p * p; i <= n; i += p)
prime[i] = false ;
}
}
} // Function to segregate the primes and non-primes function segregatePrimeNonPrime(prime, arr, N)
{ // Generate all primes till 10^
SieveOfEratosthenes(prime, 10000000);
// Initialize left and right
let left = 0, right = N - 1;
// Traverse the array
while (left < right)
{
// Increment left while array element
// at left is prime
while (prime[arr[left]])
left++;
// Decrement right while array element
// at right is non-prime
while (!prime[arr[right]])
right--;
// If left < right, then swap arr[left]
// and arr[right]
if (left < right)
{
// Swap arr[left] and arr[right]
let temp = arr[left];
arr[left] = arr[right];
arr[right] = temp;
left++;
right--;
}
}
// Print segregated array
for (let i = 0; i < N; i++)
console.log(arr[i] + " " );
} // Driver Code
let prime = Array.from({length: 10000001},
(_, i) => true );
let arr = [ 2, 3, 4, 6, 7, 8, 9, 10 ];
let N = arr.length;
// Function Call
segregatePrimeNonPrime(prime, arr, N);
|
2 3 7 6 4 8 9 10
Time Complexity: O(N*log(log(N)))
Auxiliary Space: O(N)