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

Java

  • 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;
        }
    }
    
  • // 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;
        }
    };
    
  • # 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)
            
    
    

All Problems

All Solutions