add prime sieves (#21)

Author: cameroncuster

examples/primes.rs

@@ -0,0 +1,48 @@
+// verification-helper: PROBLEM https://onlinejudge.u-aizu.ac.jp/courses/library/6/NTL/all/NTL_1_C
+
+use proconio::input;
+use programming_team_code_rust::primes::Primes;
+
+fn is_prime_naive(n: usize) -> bool {
+    if n <= 1 {
+        return false;
+    }
+    for i in 2..n {
+        if i * i > n {
+            break;
+        }
+        if n % i == 0 {
+            return false;
+        }
+    }
+    true
+}
+
+fn main() {
+    input! {
+        a: [usize],
+    }
+
+    let primes = Primes::new(1001);
+    // test is prime
+    for &elem in &a {
+        assert_eq!(primes.is_prime(elem), is_prime_naive(elem));
+    }
+    // test factorize (via LCM)
+    let mut lcm_exps = vec![0; 1001];
+    for &elem in &a {
+        let mut exps = vec![0; 1001];
+        let mut prev_factor = 0;
+        for factor in primes.factorize(elem) {
+            assert!(prev_factor <= factor);
+            exps[factor] += 1;
+            lcm_exps[factor] = lcm_exps[factor].max(exps[factor]);
+            prev_factor = factor;
+        }
+    }
+    let mut lcm = 1;
+    for i in 2i32..1001 {
+        lcm *= i.pow(lcm_exps[i as usize]);
+    }
+    println!("{}", lcm);
+}

src/lib.rs

@@ -2,4 +2,5 @@ pub mod dijk;
 pub mod dsu;
 pub mod fenwick;
 pub mod lca;
+pub mod primes;
 pub mod rmq;

src/primes.rs

@@ -0,0 +1,33 @@
+pub struct Primes {
+    min_fact: Vec<usize>,
+}
+impl Primes {
+    pub fn new(n: usize) -> Primes {
+        let mut min_fact = (0..n).collect::<Vec<_>>();
+        let mut i = 2;
+        while i * i < n {
+            if min_fact[i] == i {
+                let mut j = i * i;
+                while j < n {
+                    min_fact[j] = min_fact[j].min(i);
+                    j += i;
+                }
+            }
+            i += 1;
+        }
+        Primes { min_fact }
+    }
+    pub fn is_prime(&self, x: usize) -> bool {
+        x >= 2 && self.min_fact[x] == x
+    }
+    // returns the prime factors of `x` in sorted order
+    pub fn factorize(&self, mut x: usize) -> Vec<usize> {
+        let mut facts = vec![];
+        while x > 1 {
+            let p = self.min_fact[x];
+            facts.push(p);
+            x /= p;
+        }
+        facts
+    }
+}