add 95, 17

lib/primes/benches/benchmark.rs

@@ -10,5 +10,15 @@ fn bench_primes_between_10e5_and_10e6(c: &mut Criterion) {
     });
 }
 
-criterion_group!(benches, bench_primes_between_10e5_and_10e6);
+fn bench_primes_between_10_and_10e6(c: &mut Criterion) {
+    c.bench_function("primes 10 to 10e6", |b| {
+        b.iter(|| Primes::get_between(10, 1_000_000))
+    });
+}
+
+criterion_group!(
+    benches,
+    bench_primes_between_10_and_10e6,
+    bench_primes_between_10e5_and_10e6
+);
 criterion_main!(benches);

lib/proper_divisors/Cargo.toml

@@ -0,0 +1,10 @@
+[package]
+name = "proper_divisors"
+version = "0.1.0"
+edition = "2024"
+
+[dependencies]
+#num = "0.4.3"
+
+[dev-dependencies]
+rstest = "0.25.0"

lib/proper_divisors/src/lib.rs

@@ -0,0 +1,82 @@
+use std::collections::HashMap;
+
+#[derive(Debug)]
+pub struct ProperDivisors {
+    map: HashMap<usize, Vec<usize>>,
+    pub min: usize,
+    pub max: usize,
+}
+
+impl ProperDivisors {
+    pub fn get_between(smaller: usize, larger: usize) -> Self {
+        let mut result = HashMap::new();
+
+        for number in smaller..=larger {
+            let mut divisors = vec![1];
+
+            let limit = usize::isqrt(number);
+
+            for i in (2..=limit).rev() {
+                if number % i == 0 {
+                    let div_1 = i;
+                    let div_2 = number / i;
+
+                    divisors.push(div_1);
+
+                    if div_1 != div_2 {
+                        divisors.push(div_2);
+                    }
+                }
+            }
+
+            divisors.sort_unstable();
+            result.insert(number, divisors);
+        }
+
+        Self {
+            map: result,
+            min: smaller,
+            max: larger,
+        }
+    }
+
+    pub fn get(&self, number: usize) -> &[usize] {
+        self.map.get(&number).unwrap()
+    }
+}
+
+#[cfg(test)]
+mod tests {
+
+    use rstest::rstest;
+
+    use crate::ProperDivisors;
+
+    #[rstest]
+    #[case(6, vec![1, 2, 3])]
+    #[case(28, vec![1, 2, 4, 7, 14])]
+    #[case(12_496, vec![1, 2, 4, 8, 11, 16, 22, 44, 71, 88, 142, 176, 284, 568, 781, 1136, 1562, 3124, 6248])]
+    fn one_proper_divisor(#[case] input: usize, #[case] expected: Vec<usize>) {
+        let pd = ProperDivisors::get_between(input, input + 1);
+
+        assert_eq!(pd.get(input), expected);
+    }
+
+    #[test]
+    fn all_proper_divisors() {
+        let pd = ProperDivisors::get_between(6, 30);
+
+        assert_eq!(pd.get(6), &[1, 2, 3]);
+        assert_eq!(pd.get(28), &[1, 2, 4, 7, 14]);
+
+        println!("{:?}", pd.get(8));
+
+        let pd = ProperDivisors::get_between(12_496, 12_497);
+        assert_eq!(
+            pd.get(12_496),
+            &[
+                1, 2, 4, 8, 11, 16, 22, 44, 71, 88, 142, 176, 284, 568, 781, 1136, 1562, 3124, 6248
+            ]
+        );
+    }
+}