complete 6226.rs 7393.rs

storage/zeta/rs/completed/7393.rs

@@ -0,0 +1,90 @@
+use std::{
+    io::{read_to_string, stdin},
+    iter::zip,
+};
+
+fn get_primes(n: usize) -> Vec<usize> {
+    let mut primes = vec![2];
+    for i in (3..=n).step_by(2) {
+        for p in primes.iter() {
+            if i % p == 0 {
+                break;
+            } else if i < p * p {
+                primes.push(i);
+                break;
+            }
+        }
+    }
+    primes
+}
+
+fn legendre(n: usize, p: usize) -> usize {
+    let mut ppow = p;
+    let mut curr = n / ppow;
+    let mut res = curr;
+
+    while curr != 0 {
+        ppow = ppow * p;
+        curr = n / ppow;
+        res += curr;
+    }
+
+    res
+}
+
+fn prime_factorization(m: usize) -> Vec<(usize, usize)> {
+    let primes = get_primes(32000);
+    let mut curr = m;
+    let mut res = vec![];
+    for &p in primes.iter() {
+        let mut cnt = 0;
+        while curr % p == 0 {
+            curr /= p;
+            cnt += 1;
+        }
+        if cnt > 0 {
+            res.push((p, cnt));
+        }
+    }
+
+    if curr > 1 {
+        res.push((curr, 1));
+    }
+
+    res
+}
+
+fn combinatorics_p_cnt(n: usize, k: usize, p: usize) -> usize {
+    legendre(n, p) - legendre(n - k, p) - legendre(k, p)
+}
+
+fn main() {
+    let temp = read_to_string(stdin()).unwrap();
+    let mut iter = temp
+        .split_ascii_whitespace()
+        .map(|x| x.parse::<usize>().unwrap());
+
+    let (n, m) = (iter.next().unwrap(), iter.next().unwrap());
+
+    let factors = prime_factorization(m);
+
+    let mut res = vec![];
+
+    for k in 0..=(n - 1) {
+        let comb = factors
+            .iter()
+            .map(|&(p, _)| combinatorics_p_cnt(n - 1, k, p));
+
+        let flg = zip(comb, factors.iter()).all(|(q1, &q2)| q1 >= q2.1);
+
+        if flg {
+            res.push(k + 1);
+        }
+    }
+
+    println!("{}", res.len());
+    for i in res {
+        print!("{} ", i);
+    }
+    println!()
+}