Add Sum of Digits (#498)

Author: ayhaneyikan

src/math/mod.rs

@@ -38,6 +38,7 @@ mod signum;
 mod simpson_integration;
 mod sine;
 mod square_root;
+mod sum_of_digits;
 mod trial_division;
 mod zellers_congruence_algorithm;
 
@@ -87,5 +88,6 @@ pub use self::signum::signum;
 pub use self::simpson_integration::simpson_integration;
 pub use self::sine::sine;
 pub use self::square_root::{fast_inv_sqrt, square_root};
+pub use self::sum_of_digits::{sum_digits_iterative, sum_digits_recursive};
 pub use self::trial_division::trial_division;
 pub use self::zellers_congruence_algorithm::zellers_congruence_algorithm;

src/math/sum_of_digits.rs

@@ -0,0 +1,116 @@
+/// Iteratively sums the digits of a signed integer
+///
+/// ## Arguments
+///
+/// * `num` - The number to sum the digits of
+///
+/// ## Examples
+///
+/// ```
+/// use the_algorithms_rust::math::sum_digits_iterative;
+///
+/// assert_eq!(10, sum_digits_iterative(1234));
+/// assert_eq!(12, sum_digits_iterative(-246));
+/// ```
+pub fn sum_digits_iterative(num: i32) -> u32 {
+    // convert to unsigned integer
+    let mut num: u32 = num.unsigned_abs();
+    // initialize sum
+    let mut result: u32 = 0;
+
+    // iterate through digits
+    while num > 0 {
+        // extract next digit and add to sum
+        result += num % 10;
+        num /= 10; // chop off last digit
+    }
+    result
+}
+
+/// Recursively sums the digits of a signed integer
+///
+/// ## Arguments
+///
+/// * `num` - The number to sum the digits of
+///
+/// ## Examples
+///
+/// ```
+/// use the_algorithms_rust::math::sum_digits_recursive;
+///
+/// assert_eq!(10, sum_digits_recursive(1234));
+/// assert_eq!(12, sum_digits_recursive(-246));
+/// ```
+pub fn sum_digits_recursive(num: i32) -> u32 {
+    // convert to unsigned integer
+    let num: u32 = num.unsigned_abs();
+    // base case
+    if num < 10 {
+        return num;
+    }
+    // recursive case: add last digit to sum of remaining digits
+    num % 10 + sum_digits_recursive((num / 10) as i32)
+}
+
+#[cfg(test)]
+mod tests {
+    mod iterative {
+        // import relevant sum_digits function
+        use super::super::sum_digits_iterative as sum_digits;
+
+        #[test]
+        fn zero() {
+            assert_eq!(0, sum_digits(0));
+        }
+        #[test]
+        fn positive_number() {
+            assert_eq!(1, sum_digits(1));
+            assert_eq!(10, sum_digits(1234));
+            assert_eq!(14, sum_digits(42161));
+            assert_eq!(6, sum_digits(500010));
+        }
+        #[test]
+        fn negative_number() {
+            assert_eq!(1, sum_digits(-1));
+            assert_eq!(12, sum_digits(-246));
+            assert_eq!(2, sum_digits(-11));
+            assert_eq!(14, sum_digits(-42161));
+            assert_eq!(6, sum_digits(-500010));
+        }
+        #[test]
+        fn trailing_zeros() {
+            assert_eq!(1, sum_digits(1000000000));
+            assert_eq!(3, sum_digits(300));
+        }
+    }
+
+    mod recursive {
+        // import relevant sum_digits function
+        use super::super::sum_digits_recursive as sum_digits;
+
+        #[test]
+        fn zero() {
+            assert_eq!(0, sum_digits(0));
+        }
+        #[test]
+        fn positive_number() {
+            assert_eq!(1, sum_digits(1));
+            assert_eq!(10, sum_digits(1234));
+            assert_eq!(14, sum_digits(42161));
+            assert_eq!(6, sum_digits(500010));
+        }
+        #[test]
+        fn negative_number() {
+            assert_eq!(1, sum_digits(-1));
+            assert_eq!(12, sum_digits(-246));
+            assert_eq!(2, sum_digits(-11));
+            assert_eq!(14, sum_digits(-42161));
+            assert_eq!(6, sum_digits(-500010));
+        }
+        #[test]
+        fn trailing_zeros() {
+            assert_eq!(1, sum_digits(1000000000));
+            assert_eq!(3, sum_digits(300));
+        }
+    }
+}