# 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 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++ implementation to find the ` `// permutation of first N positive ` `// integers such that prime numbers ` `// are at the prime indices` `#define mod 1000000007` `#include` `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`

Output:
144

Check out this Author's contributed articles.

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.

Article Tags :
Practice Tags :