##### Welcome to Subscribe On Youtube

Formatted question description: https://leetcode.ca/all/1175.html

# 1175. Prime Arrangements (Easy)

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:

• 1 <= n <= 100

Related Topics:
Math

## Solution 1. Sieve of Eratosthenes

// OJ: https://leetcode.com/problems/prime-arrangements/
// Time: O(NloglogN)
// Space: O(N)
class Solution {
int countPrimes(int n) {
if (n <= 1) return 0;
vector<int> prime(n + 1, true);
int ans = 0, bound = sqrt(n);
for (int i = 2; i <= n; ++i) {
if (!prime[i]) continue;
++ans;
if (i > bound) continue;
for (int j = i * i; j <= n; j += i) prime[j] = false;
}
return ans;
}
public:
int numPrimeArrangements(int n) {
int cnt = countPrimes(n), ans = 1, mod = 1e9 + 7;
for (int i = 1; i <= cnt; ++i) ans = ((long)ans * i) % mod;
for (int i = 1; i <= n - cnt; ++i) ans = ((long)ans * i) % mod;
return ans;
}
};

• class Solution {
public int numPrimeArrangements(int n) {
final int MODULO = 1000000007;
int primeCount = 0;
for (int i = 1; i <= n; i++) {
if (isPrime(i))
primeCount++;
}
int notPrimeCount = n - primeCount;
long arrangements = 1L;
for (long i = 1L; i <= primeCount; i++)
arrangements = (arrangements * i) % MODULO;
for (long i = 1L; i <= notPrimeCount; i++)
arrangements = (arrangements * i) % MODULO;
return (int) arrangements;
}

public boolean isPrime(int num) {
if (num == 1)
return false;
if (num == 2 || num == 3 || num == 5 || num == 7)
return true;
if (num % 2 == 0 || num % 3 == 0 || num % 5 == 0 || num % 7 == 0)
return false;
int sqrt = (int) Math.sqrt(num);
for (int i = 11; i <= sqrt; i += 2) {
if (num % i == 0)
return false;
}
return true;
}
}

############

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

• // OJ: https://leetcode.com/problems/prime-arrangements/
// Time: O(NloglogN)
// Space: O(N)
class Solution {
int countPrimes(int n) {
if (n <= 1) return 0;
vector<int> prime(n + 1, true);
int ans = 0, bound = sqrt(n);
for (int i = 2; i <= n; ++i) {
if (!prime[i]) continue;
++ans;
if (i > bound) continue;
for (int j = i * i; j <= n; j += i) prime[j] = false;
}
return ans;
}
public:
int numPrimeArrangements(int n) {
int cnt = countPrimes(n), ans = 1, mod = 1e9 + 7;
for (int i = 1; i <= cnt; ++i) ans = ((long)ans * i) % mod;
for (int i = 1; i <= n - cnt; ++i) ans = ((long)ans * i) % mod;
return ans;
}
};

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

############

# 1175. Prime Arrangements
# https://leetcode.com/problems/prime-arrangements

class Solution:
def numPrimeArrangements(self, n: int) -> int:
primes = [True] * (n + 1)

for prime in range(2, int(math.sqrt(n)) + 1):
if primes[prime]:
for composite in range(prime * prime, n + 1, prime):
primes[composite] = False

cnt = sum(primes[2:])

return math.factorial(cnt) * math.factorial(n - cnt) % (10**9 + 7)


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