done with basic calc

Cargo.toml

@@ -1,10 +1,10 @@
 [workspace]
 members = [
-  "exercises/*/*",
+    "exercises/*/*",
-  "helpers/common",
+    "helpers/common",
-  "helpers/mdbook-exercise-linker",
+    "helpers/mdbook-exercise-linker",
-  "helpers/mdbook-link-shortener",
+    "helpers/mdbook-link-shortener",
-  "helpers/ticket_fields",
+    "helpers/ticket_fields",
 ]
 resolver = "2"
 

exercises/02_basic_calculator/03_if_else/src/lib.rs

@@ -2,7 +2,13 @@
 /// `13` if `n` is divisible by `3`,
 /// `17` otherwise.
 fn magic_number(n: u32) -> u32 {
-    todo!()
+    if n % 2 == 0 {
+        return 12;
+    } else if n % 3 == 0 {
+        return 13;
+    } else {
+        return 17;
+    }
 }
 
 #[cfg(test)]

exercises/02_basic_calculator/04_panics/src/lib.rs

@@ -2,7 +2,9 @@
 /// calculate the average speed of the journey.
 fn speed(start: u32, end: u32, time_elapsed: u32) -> u32 {
     // TODO: Panic with a custom message if `time_elapsed` is 0
-
+    if time_elapsed == 0 {
+        panic!("The journey took no time at all. That's impossible!");
+    }
     (end - start) / time_elapsed
 }
 

exercises/02_basic_calculator/05_factorial/src/lib.rs

@@ -10,6 +10,14 @@
 //
 // Use only what you learned! No loops yet, so you'll have to use recursion!
 
+fn factorial(n: u32) -> u32 {
+    if n == 0 || n == 1 {
+        return 1;
+    } else {
+        return n * factorial(n - 1);
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use crate::factorial;

exercises/02_basic_calculator/06_while/src/lib.rs

@@ -4,7 +4,16 @@ pub fn factorial(n: u32) -> u32 {
     // interprets as "I'll get back to this later", thus
     // suppressing type errors.
     // It panics at runtime.
-    todo!()
+    if n == 0 || n == 1 {
+        return 1;
+    }
+    let mut i = 1;
+    let mut prod = 1;
+    while i <= n {
+        prod = prod * i;
+        i = i + 1;
+    }
+    return prod;
 }
 
 #[cfg(test)]

exercises/02_basic_calculator/07_for/src/lib.rs

@@ -1,6 +1,13 @@
 // Rewrite the factorial function using a `for` loop.
 pub fn factorial(n: u32) -> u32 {
-    todo!()
+    if n == 0 || n == 1 {
+        return 1;
+    }
+    let mut prod = 1;
+    for i in 2..=n {
+        prod = prod * i;
+    }
+    prod
 }
 
 #[cfg(test)]

exercises/02_basic_calculator/08_overflow/Cargo.toml

@@ -8,3 +8,5 @@ edition = "2021"
 # compiler noise.
 # We'll re-enable them again once we explain how visibility works in Rust.
 dead_code = "allow"
+[profile.dev.package.copy]
+overflow-checks = false

exercises/02_basic_calculator/09_saturating/src/lib.rs

@@ -1,9 +1,10 @@
 pub fn factorial(n: u32) -> u32 {
-    let mut result = 1;
+    let mut result: u32 = 1;
     for i in 1..=n {
         // Use saturating multiplication to stop at the maximum value of u32
         // rather than overflowing and wrapping around
-        result *= i;
+        // result *= i;
+        result = result.saturating_mul(i);
     }
     result
 }

exercises/02_basic_calculator/10_as_casting/src/lib.rs

@@ -6,7 +6,7 @@ mod tests {
 
     #[test]
     fn u16_to_u32() {
-        let v: u32 = todo!();
+        let v: u32 = 47;
         assert_eq!(47u16 as u32, v);
     }
 
@@ -24,14 +24,14 @@ mod tests {
         // You could solve this by using exactly the same expression as above,
         // but that would defeat the purpose of the exercise. Instead, use a genuine
         // `i8` value that is equivalent to `255` when converted to `u8`.
-        let y: i8 = todo!();
+        let y: i8 = 255 as _;
 
         assert_eq!(x, y);
     }
 
     #[test]
     fn bool_to_u8() {
-        let v: u8 = todo!();
+        let v: u8 = 1 as _;
         assert_eq!(true as u8, v);
     }
 }