Add recursion.rs

Author: whbrown

labocédai/src/lib.rs

@@ -1,4 +1,5 @@
 pub mod simple_challenges;
+pub mod recursion;
 
 #[cfg(test)]
 mod tests {
@@ -47,11 +48,60 @@ mod tests {
 
         #[test]
         fn test_max_n_width_sub_array() {
-            assert_eq!(max_n_width_sub_array_sum(&[1, 2, 5, 2, 8, 1, 5], 2), Some(10));
-            assert_eq!(max_n_width_sub_array_sum(&[1, 2, 5, 2, 8, 1, 5], 4), Some(17));
+            assert_eq!(
+                max_n_width_sub_array_sum(&[1, 2, 5, 2, 8, 1, 5], 2),
+                Some(10)
+            );
+            assert_eq!(
+                max_n_width_sub_array_sum(&[1, 2, 5, 2, 8, 1, 5], 4),
+                Some(17)
+            );
             assert_eq!(max_n_width_sub_array_sum(&[4, 2, 1, 6], 1), Some(6));
             assert_eq!(max_n_width_sub_array_sum(&[4, 2, 1, 6, 2], 4), Some(13));
             assert_eq!(max_n_width_sub_array_sum(&[], 4), None);
         }
     }
+
+    mod recursion {
+        use crate::recursion::*;
+        #[test]
+        fn test_power() {
+            assert_eq!(power(2, 2), 2_usize.pow(2));
+            assert_eq!(power(6, 1), 6_usize.pow(1));
+            assert_eq!(power(2, 8), 2_usize.pow(8));
+            assert_eq!(power(0, 2), 0_usize.pow(2));
+            assert_eq!(power(2, 0), 2_usize.pow(0));
+        }
+
+        #[test]
+        fn test_factorial() {
+            assert_eq!(factorial(3), 3 * 2 * 1);
+            assert_eq!(factorial(5), 5 * 4 * 3 * 2 * 1);
+            assert_eq!(factorial(1), 1);
+            assert_eq!(factorial(0), 1);
+        }
+
+        #[test]
+        fn test_product_of_nums() {
+            assert_eq!(product_of_nums(&[1, 2, 3]), Some(1 * 2 * 3));
+            assert_eq!(product_of_nums(&[1, -2, 3]), Some(1 * -2 * 3));
+            assert_eq!(product_of_nums(&[1, -2, 0]), Some(1 * -2 * 0));
+            assert_eq!(product_of_nums(&[]), None);
+        }
+
+        #[test]
+        fn test_sum_up_to() {
+            assert_eq!(sum_up_to(5), 0 + 1 + 2 + 3 + 4 + 5);
+            assert_eq!(sum_up_to(1), 0 + 1);
+            assert_eq!(sum_up_to(0), 0);
+        }
+
+        #[test]
+        fn test_fibonacci() {
+            assert_eq!(fibonacci(4), 3);
+            assert_eq!(fibonacci(10), 55);
+            assert_eq!(fibonacci(28), 317811);
+            assert_eq!(fibonacci(35), 9227465);
+        }
+    }
 }

labocédai/src/recursion.rs

@@ -0,0 +1,39 @@
+pub fn power(base: usize, exponent: usize) -> usize {
+    if exponent == 0 {
+        return 1;
+    }
+    base * power(base, exponent - 1)
+}
+
+pub fn factorial(num: usize) -> usize {
+    if num <= 1 {
+        return 1;
+    }
+    num * factorial(num - 1)
+}
+
+pub fn product_of_nums(nums: &[isize]) -> Option<isize> {
+    if nums.len() == 0 {
+        return None;
+    }
+    let next_product = product_of_nums(&nums[1..]);
+    if let Some(product) = next_product {
+        return Some(nums[0] * product);
+    }
+    Some(nums[0])
+}
+
+pub fn sum_up_to(num: usize) -> usize {
+    if num == 0 {
+        return 0;
+    }
+    num + sum_up_to(num - 1)
+}
+
+pub fn fibonacci(n: usize) -> usize {
+    /* returns the nth number in the fibonacci sequence */
+    if n == 1 || n == 2 {
+        return 1;
+    }
+    fibonacci(n - 1) + fibonacci(n - 2)
+}

labocédai/src/simple_challenges.rs

@@ -1,4 +1,3 @@
-
 pub fn sum_up_to(num: usize) -> usize {
     (0..=num).into_iter().fold(0, |acc, n| acc + n)
 }
@@ -72,21 +71,17 @@ pub fn max_n_width_sub_array_sum(nums: &[isize], n: usize) -> Option<isize> {
     if nums.len() < n {
         return None;
     }
-    let mut max_sum: Option<isize> = None;
-    let mut j = n;
+    let mut sum = sum_nums(&nums[0..n]);
+    let mut max_sum = sum;
     for (i, _) in nums.iter().enumerate() {
-        if i + n <= nums.len() {
-            let sum = sum_nums(&nums[i..j]);
-            match max_sum {
-                Some(s) => {
-                    if sum > s {
-                        max_sum = Some(sum);
-                    }
-                },
-                None => max_sum = Some(sum)
+        if i > 0 && i + n <= nums.len() {
+            sum -= nums[i - 1];
+            sum += nums[i + n - 1];
+
+            if sum > max_sum {
+                max_sum = sum
             }
-            j += 1;
         }
     }
-    max_sum
+    Some(max_sum)
 }