LeetCode 1175. Prime Arrangements Solution in Java, C++, Python & Go | Explanation + Code

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:

• 1 <= n <= 100

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 × log log n).

PythonJavaC++Go

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)(code-box)

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; } }(code-box)

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; } };(code-box)

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 }(code-box)