Solve p0034, make math functions more generic

README.rst

@@ -48,7 +48,7 @@ LivInTheLookingGlass’s Project Euler solutions
 |            | Pypy 3.6+ |br|          |        |                   |
 |            | GraalPy 23.1+           |        |                   |
 +------------+-------------------------+--------+-------------------+
-| Rust       | 1.69+                   | 14     | |Rust|            |
+| Rust       | 1.69+                   | 15     | |Rust|            |
 +------------+-------------------------+--------+-------------------+
 | Documentation (in progress)                   | |Pages|           |
 +-----------------------------------------------+-------------------+

docs/index.rst

@@ -166,7 +166,7 @@ This project is divided into several Makefiles, connected by a root Makefile whi
 +-----------+------------+------------+------------+------------+------------+------------+
 |:prob:`33` |            |            |            |            |:py-d:`0033`|            |
 +-----------+------------+------------+------------+------------+------------+------------+
-|:prob:`34` |:c-d:`0034` |:cp-d:`0034`|            |            |:py-d:`0034`|            |
+|:prob:`34` |:c-d:`0034` |:cp-d:`0034`|            |            |:py-d:`0034`|:rs-d:`0034`|
 +-----------+------------+------------+------------+------------+------------+------------+
 |:prob:`35` |            |            |            |            |:py-d:`0035`|            |
 +-----------+------------+------------+------------+------------+------------+------------+

docs/rust/math.rst

@@ -3,7 +3,12 @@ math.rs
 
 View source code `here on GitHub! <https://github.com/LivInTheLookingGlass/Euler/blob/master/rust/src/math.rs>`_
 
-.. rust:fn:: math::n_choose_r(n: usize, r: usize) -> i128
+.. rust:fn:: math::factorial<I: NumAssign + From<u8>>(n: u8) -> I
+
+  Returns the factorial of a given number. Note that it only accepts a ``u8`` because
+  any number that requires a larger type is *guaranteed* to overflow.
+
+.. rust:fn:: math::n_choose_r<I: NumAssign + From<i8> + From<usize>>(n: usize, r: usize) -> I
 
   Returns the number of ways to choose r items from a set of n.
 

docs/rust/p0015.rst

@@ -6,7 +6,7 @@ View source code `here on GitHub! <https://github.com/LivInTheLookingGlass/Euler
 Includes
 --------
 
-- `primes <./math.html>`_
+- `math <./math.html>`_
 
 Problem Solution
 ----------------

docs/rust/p0034.rst

@@ -0,0 +1,18 @@
+Rust Implementation of Problem 34
+=================================
+
+View source code `here on GitHub! <https://github.com/LivInTheLookingGlass/Euler/blob/master/rust/src/p0034.rs>`_
+
+Includes
+--------
+
+- `math <./math.html>`_
+
+Problem Solution
+----------------
+
+.. rust:fn:: p0034::p0034() -> i128
+
+.. literalinclude:: ../../rust/src/p0034.rs
+   :language: rust
+   :linenos:

rust/README.rst

@@ -71,5 +71,6 @@ Problems Solved
 -  ☒ `11 <./src/p0011.rs>`__
 -  ☒ `12 <./src/p0012.rs>`__
 -  ☒ `15 <./src/p0015.rs>`__
+-  ☒ `15 <./src/p0034.rs>`__
 -  ☒ `76 <./src/p0076.rs>`__
 

rust/src/main.rs

@@ -33,6 +33,7 @@ const ANSWERS: [ProblemRef; 14] = [
     ("p0011", p0011::p0011, 70600674),
     ("p0012", p0012::p0012, 76576500),
     ("p0015", p0015::p0015, 137846528820),
+    ("p0034", p0034::p0034, 40730),
     ("p0076", p0076::p0076, 190569291),
 ];
 

rust/src/math.rs

@@ -1,7 +1,18 @@
-pub fn n_choose_r(n: usize, r: usize) -> i128 {
+use num_traits::NumAssign;
+use num_traits::one;
+
+pub fn factorial<I: NumAssign + From<u8>>(n: u8) -> I {
+    let mut answer: I = one();
+    for i in 2..=n {
+        answer *= i.into();
+    }
+    return answer
+}
+
+pub fn n_choose_r<I: NumAssign + From<i8> + From<usize>>(n: usize, r: usize) -> I {
     // slow path for larger numbers
-    let mut answer: i128 = 1;
-    let mut tmp: i128;
+    let mut answer: I = one();
+    let mut tmp: I;
     let mut factors: Vec<i8> = vec![0; n + 1];
     // collect factors of final number
     for i in 2..=n {
@@ -30,25 +41,25 @@ pub fn n_choose_r(n: usize, r: usize) -> i128 {
     while i <= n {
         while factors[i] > 0 {
             tmp = answer;
-            answer *= i as i128;
+            answer *= i.into();
             while answer < tmp && j <= n {
                 while factors[j] < 0 {
-                    tmp /= j as i128;
+                    tmp /= j.into();
                     factors[j] += 1;
                 }
                 j += 1;
-                answer = tmp * i as i128;
+                answer = tmp * i.into();
             }
             if answer < tmp {
-                return -1;  // this indicates an overflow
+                return (-1).into();  // this indicates an overflow
             }
             factors[i] -= 1;
         }
         i += 1;
     }
     while j <= n {
         while factors[j] < 0 {
-            answer /= j as i128;
+            answer /= j.into();
             factors[j] += 1;
         }
         j += 1;

rust/src/p0034.rs

@@ -0,0 +1,32 @@
+/*
+Project Euler Problem 34
+
+This ended up being a filtering problem. The problem with my solution is that I
+am not satisfied with my filter at all. I feel like there is a more efficient
+way to go about it.
+
+Problem:
+
+145 is a curious number, as 1! + 4! + 5! = 1 + 24 + 120 = 145.
+
+Find the sum of all numbers which are equal to the sum of the factorial of
+their digits.
+
+Note: as 1! = 1 and 2! = 2 are not sums they are not included.
+*/
+use crate::math::factorial;
+
+pub fn p0034() -> i128 {
+    let mut answer: u32 = 0;
+    for x in 10..100000 {
+        let string: String = x.to_string();
+        let sum = 
+            string.bytes()
+                  .into_iter()
+                  .fold(0, |a, b| a + factorial::<u32>(b - '0' as u8));
+        if sum == x {
+            answer += x;
+        }
+    }
+    return answer.into();
+}