RUST GYM Leetcode 1175 Prime Arrangements Rust Solution

1175. Prime Arrangements

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

Rust Solution

struct Solution;

impl Solution {
    fn number_of_primes(n: usize) -> i32 {
        let mut a: Vec<bool> = vec![true; n + 1];
        a[0] = false;
        a[1] = false;
        let mut i: usize = 2;
        while i * i <= n {
            if a[i] {
                let mut j: usize = 2;
                while i * j <= n {
                    a[i * j] = false;
                    j += 1;
                }
            }
            i += 1;
        }
        let mut res = 0;
        for k in 0..=n {
            if a[k] {
                res += 1;
            }
        }
        res
    }

    fn num_prime_arrangements(n: i32) -> i32 {
        let primes = Self::number_of_primes(n as usize);
        let mut product = 1i64;
        for i in 1..=primes {
            product *= i as i64;
            product %= 1_000_000_007;
        }
        for i in 1..=(n - primes) {
            product *= i as i64;
            product %= 1_000_000_007;
        }
        product as i32
    }
}

#[test]
fn test() {
    assert_eq!(Solution::num_prime_arrangements(5), 12);
    assert_eq!(Solution::num_prime_arrangements(100), 682_289_015);
}

Having problems with this solution? Click here to submit an issue on github.