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

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 10⁹ + 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++

// 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(n^3/2)

Auxiliary Space: O(1)