Given an integer N, the task is to find the number of permutations of first N positive integers such that prime numbers are at prime indices (for 1-based indexing).
Note: Since, the number of ways may be very large, return the answer modulo 109 + 7.
Examples:
Input: N = 3
Output: 2
Explanation:
Possible permutation of first 3 positive integers, such that prime numbers are at prime indices are: {1, 2, 3}, {1, 3, 2}
Input: N = 5
Output: 12
Explanation:
Some of the possible permutation of first 5 positive integers, such that prime numbers are at prime indices are: {1, 2, 3, 4}, {1, 3, 2, 4}, {4, 2, 3, 1}, {4, 3, 2, 1}
Approach: There are K number of primes from 1 to N and there is exactly K number of prime indexes from index 1 to N. So the number of permutations for prime numbers is K!. Similarly, the number of permutations for non-prime numbers is (N-K)!. So the total number of permutations is K!*(N-K)!
For example:
Given test case: [1,2,3,4,5]. 2, 3 and 5 are fixed on prime index slots, we can only swap them around. There are 3 x 2 x 1 = 3! ways [[2,3,5], [2,5,3], [3,2,5], [3,5,2], [5,2,3], [5,3,2]], For Non-prime numbers - {1,4} [[1,4], [4,1]] So the total is 3!*2!
Below is the implementation of the above approach:
// C++ implementation to find the // permutation of first N positive // integers such that prime numbers // are at the prime indices #define mod 1000000007 #include<bits/stdc++.h> using namespace std;
int fact( int n)
{ int ans = 1;
while (n > 0)
{
ans = ans * n;
n--;
}
return ans;
} // Function to check that // a number is prime or not bool isPrime( int n)
{ if (n <= 1)
return false ;
// Loop to check that
// number is divisible by any
// other number or not except 1
for ( int i = 2; i< sqrt (n) + 1; i++)
{
if (n % i == 0)
return false ;
else
return true ;
}
} // Function to find the permutations void findPermutations( int n)
{ int prime = 0;
// Loop to find the
// number of prime numbers
for ( int j = 1; j < n + 1; j++)
{
if (isPrime(j))
prime += 1;
}
// Permutation of N
// positive integers
int W = fact(prime) * fact(n - prime);
cout << (W % mod);
} // Driver Code int main()
{ int n = 7;
findPermutations(n);
} // This code is contributed by Bhupendra_Singh |
// Java implementation to find the // permutation of first N positive // integers such that prime numbers // are at the prime indices import java.io.*;
class GFG{
static int mod = 1000000007 ;
static int fact( int n)
{ int ans = 1 ;
while (n > 0 )
{
ans = ans * n;
n--;
}
return ans;
} // Function to check that // a number is prime or not static boolean isPrime( int n)
{ if (n <= 1 )
return false ;
// Loop to check that
// number is divisible by any
// other number or not except 1
for ( int i = 2 ; i< Math.sqrt(n) + 1 ; i++)
{
if (n % i == 0 )
return false ;
else
return true ;
}
return true ;
} // Function to find the permutations static void findPermutations( int n)
{ int prime = 0 ;
// Loop to find the
// number of prime numbers
for ( int j = 1 ; j < n + 1 ; j++)
{
if (isPrime(j))
prime += 1 ;
}
// Permutation of N
// positive integers
int W = fact(prime) * fact(n - prime);
System.out.println(W % mod);
} // Driver Code public static void main (String[] args)
{ int n = 7 ;
findPermutations(n);
} } // This code is contributed by shubhamsingh10 |
# Python3 implementation to find the # permutation of first N positive # integers such that prime numbers # are at the prime indices import math
# Function to check that # a number is prime or not def isPrime(n):
if n < = 1 :
return False
# Loop to check that
# number is divisible by any
# other number or not except 1
for i in range ( 2 , int (n * * 0.5 ) + 1 ):
if n % i = = 0 :
return False
else :
return True
# Constant value for modulo CONST = int (math. pow ( 10 , 9 )) + 7
# Function to find the permutations def findPermutations(n):
prime = 0
# Loop to find the
# number of prime numbers
for j in range ( 1 , n + 1 ):
if isPrime(j):
prime + = 1
# Permutation of N
# positive integers
W = math.factorial(prime) * \
math.factorial(n - prime)
print (W % CONST)
# Driver Code if __name__ = = "__main__" :
n = 7
# Function Call
findPermutations(n)
|
// C# implementation to find the // permutation of first N positive // integers such that prime numbers // are at the prime indices using System;
class GFG{
static int mod = 1000000007;
static int fact( int n)
{ int ans = 1;
while (n > 0)
{
ans = ans * n;
n--;
}
return ans;
} // Function to check that // a number is prime or not static bool isPrime( int n)
{ if (n <= 1)
return false ;
// Loop to check that
// number is divisible by any
// other number or not except 1
for ( int i = 2; i < Math.Sqrt(n) + 1; i++)
{
if (n % i == 0)
return false ;
else
return true ;
}
return true ;
} // Function to find the permutations static void findPermutations( int n)
{ int prime = 0;
// Loop to find the
// number of prime numbers
for ( int j = 1; j < n + 1; j++)
{
if (isPrime(j))
prime += 1;
}
// Permutation of N
// positive integers
int W = fact(prime) * fact(n - prime);
Console.Write(W % mod);
} // Driver Code public static void Main()
{ int n = 7;
findPermutations(n);
} } // This code is contributed by Code_Mech |
<script> // JavaScript implementation to find the // permutation of first N positive // integers such that prime numbers // are at the prime indices let mod = 1000000007; function fact(n)
{ let ans = 1;
while (n > 0)
{
ans = ans * n;
n--;
}
return ans;
} // Function to check that // a number is prime or not function isPrime(n)
{ if (n <= 1)
return false ;
// Loop to check that
// number is divisible by any
// other number or not except 1
for (let i = 2; i< Math.sqrt(n) + 1; i++)
{
if (n % i == 0)
return false ;
else
return true ;
}
} // Function to find the permutations function findPermutations(n)
{ let prime = 0;
// Loop to find the
// number of prime numbers
for (let j = 1; j < n + 1; j++)
{
if (isPrime(j))
prime += 1;
}
// Permutation of N
// positive integers
let W = fact(prime) * fact(n - prime);
document.write(W % mod);
} // Driver Code let n = 7;
findPermutations(n);
// This code is contributed by Manoj. </script> |
144
Time Complexity: O(n3/2)
Auxiliary Space: O(1)