Problem:
Score : 400 points

Problem Statement

You are given an integer N. Among the divisors of N! (= 1 \times 2 \times ... \times N), how many Shichi-Go numbers (literally "Seven-Five numbers") are there?

Here, a Shichi-Go number is a positive integer that has exactly 75 divisors.

Note

When a positive integer A divides a positive integer B, A is said to a divisor of B.
For example, 6 has four divisors: 1, 2, 3 and 6.

Constraints

1 \leq N \leq 100

N is an integer.

Input

Input is given from Standard Input in the following format:

N

Output

Print the number of the Shichi-Go numbers that are divisors of N!.

Sample Input 1

9

Sample Output 1

0

There are no Shichi-Go numbers among the divisors of 9! = 1 \times 2 \times ... \times 9 = 362880.

Sample Input 2

10

Sample Output 2

1

There is one Shichi-Go number among the divisors of 10! = 3628800: 32400.

Sample Input 3

100

Sample Output 3

543

Solution in Rust (1.15.1) (judge verdict: Accepted)

use std::io::*;
use std::str::FromStr;

pub fn read<T: FromStr>() -> T {
    let stdin = stdin();
    let stdin = stdin.lock();
    let token: String = stdin
        .bytes()
        .map(|c| c.expect("failed to read char") as char)
        .skip_while(|c| c.is_whitespace())
        .take_while(|c| !c.is_whitespace())
        .collect();
    token.parse().ok().expect("failed to parse token")
}

use std::collections::HashMap;

fn score_prime_numbers(n: i64, score: &mut HashMap<i64, i64>) {
    let mut d = 2;
    let mut tmp = n;

    while d <= n {
        while tmp % d == 0 {
            let current = score.entry(d).or_insert(0);
            *current += 1;
            tmp /= d;
        }
        d += 1;
    }
}

fn main() {
    let n: i64 = read();
    let mut score: HashMap<i64, i64> = HashMap::new();

    for i in 1..n + 1 {
        score_prime_numbers(i, &mut score)
    }
    let mut a = vec![];
    for (k, v) in score.iter() {
        a.push(v);
    }
    let cnt_74 = a.iter().filter(|&x| **x >= 74).count();
    let cnt_24 = a.iter().filter(|&x| **x >= 24).count();
    let cnt_2 = a.iter().filter(|&x| **x >= 2).count();
    let cnt_4 = a.iter().filter(|&x| **x >= 4).count();
    let cnt_14 = a.iter().filter(|&x| **x >= 14).count();

    let mut ans = 0;
    // 74
    ans += cnt_74;
    // 24 * 2
    ans += cnt_24 * (cnt_2 - 1);
    // 14 * 4
    ans += cnt_14 * (cnt_4 - 1);
    // 2 * 4 * 4
    ans += cnt_4 * (cnt_4 - 1) / 2 * (cnt_2 - 2);
    println!("{}", ans)
}