Open In App
Related Articles

Permutation of first N positive integers such that prime numbers are at prime indices

Improve
Improve
Improve
Like Article
Like
Save Article
Save
Report issue
Report

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:
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++

// 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

// 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

# 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#

// 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

                    

Javascript

<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>

                    

Output: 
144
 

Time Complexity: O(n3/2)

Auxiliary Space: O(1)



Last Updated : 24 Nov, 2021
Like Article
Save Article
Previous
Next
Share your thoughts in the comments
Similar Reads