Description#
Return the number of permutations of 1 to n so that prime numbers are at prime indices (1-indexed.)
(Recall that an integer is prime if and only if it is greater than 1, and cannot be written as a product of two positive integers both smaller than it.)
Since the answer may be large, return the answer modulo 10^9 + 7.
Example 1:
Input: n = 5
Output: 12
Explanation: For example [1,2,5,4,3] is a valid permutation, but [5,2,3,4,1] is not because the prime number 5 is at index 1.
Example 2:
Input: n = 100
Output: 682289015
Constraints:
Solutions#
Solution 1: Mathematics#
First, count the number of prime numbers within the range $[1,n]$, which we denote as $cnt$. Then, calculate the product of the factorial of $cnt$ and $n-cnt$ to get the answer, remember to perform the modulo operation.
Here, we use the “Sieve of Eratosthenes” to count prime numbers.
If $x$ is a prime number, then multiples of $x$ greater than $x$, such as $2x$, $3x$, … are definitely not prime numbers, so we can start from here.
Let $primes[i]$ indicate whether the number $i$ is a prime number. If it is a prime number, it is $true$, otherwise it is $false$.
We sequentially traverse each number $i$ in the range $[2,n]$. If this number is a prime number, the number of prime numbers increases by $1$, and then all its multiples $j$ are marked as composite numbers (except for the prime number itself), that is, $primes[j]=false$. In this way, at the end of the run, we can know the number of prime numbers.
The time complexity is $O(n \times \log \log n)$.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
| class Solution:
def numPrimeArrangements(self, n: int) -> int:
def count(n):
cnt = 0
primes = [True] * (n + 1)
for i in range(2, n + 1):
if primes[i]:
cnt += 1
for j in range(i + i, n + 1, i):
primes[j] = False
return cnt
cnt = count(n)
ans = factorial(cnt) * factorial(n - cnt)
return ans % (10**9 + 7)
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
| class Solution {
private static final int MOD = (int) 1e9 + 7;
public int numPrimeArrangements(int n) {
int cnt = count(n);
long ans = f(cnt) * f(n - cnt);
return (int) (ans % MOD);
}
private long f(int n) {
long ans = 1;
for (int i = 2; i <= n; ++i) {
ans = (ans * i) % MOD;
}
return ans;
}
private int count(int n) {
int cnt = 0;
boolean[] primes = new boolean[n + 1];
Arrays.fill(primes, true);
for (int i = 2; i <= n; ++i) {
if (primes[i]) {
++cnt;
for (int j = i + i; j <= n; j += i) {
primes[j] = false;
}
}
}
return cnt;
}
}
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
| using ll = long long;
const int MOD = 1e9 + 7;
class Solution {
public:
int numPrimeArrangements(int n) {
int cnt = count(n);
ll ans = f(cnt) * f(n - cnt);
return (int) (ans % MOD);
}
ll f(int n) {
ll ans = 1;
for (int i = 2; i <= n; ++i) ans = (ans * i) % MOD;
return ans;
}
int count(int n) {
vector<bool> primes(n + 1, true);
int cnt = 0;
for (int i = 2; i <= n; ++i) {
if (primes[i]) {
++cnt;
for (int j = i + i; j <= n; j += i) primes[j] = false;
}
}
return cnt;
}
};
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
| func numPrimeArrangements(n int) int {
count := func(n int) int {
cnt := 0
primes := make([]bool, n+1)
for i := range primes {
primes[i] = true
}
for i := 2; i <= n; i++ {
if primes[i] {
cnt++
for j := i + i; j <= n; j += i {
primes[j] = false
}
}
}
return cnt
}
mod := int(1e9) + 7
f := func(n int) int {
ans := 1
for i := 2; i <= n; i++ {
ans = (ans * i) % mod
}
return ans
}
cnt := count(n)
ans := f(cnt) * f(n-cnt)
return ans % mod
}
|
