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

• Java
• C++
• Python
• Go

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

All Problems

All Solutions