Completed '70. Climbing Stairs'

Author: OmnicWolf

Readme.md

@@ -18,6 +18,8 @@
 - **Strings**
   - <span>13. Roman to Integer</span>
   - <span>67. Add Binary</span>
+- **Dynamic Programming**
+  - <span>70. climb Stairs</span>
 
 ## Resources
 

src/array/mod.rs

@@ -1,2 +1,13 @@
-pub fn run() {
-}
+pub fn run() {}
+
+
+
+const NUMERALS: [(char, u32); 7] = [
+  ('I', 1),
+  ('V', 5),
+  ('X', 10),
+  ('L', 50),
+  ('C', 100),
+  ('D', 500),
+  ('M', 1000),
+];

src/bit_manipulation/mod.rs

@@ -1,5 +1,4 @@
 pub mod p0190_reverse_bits;
 pub mod p0191_count_set_bits;
 
-pub fn run() {
-}
+pub fn run() {}

src/dp/mod.rs

@@ -0,0 +1,3 @@
+pub mod p0070_climbing_stairs;
+
+pub fn run() {}

src/dp/p0070_climbing_stairs.rs

@@ -0,0 +1,69 @@
+/*
+ * Problem: 70. Climbing Stairs (Easy)
+ * URL: https://leetcode.com/problems/climbing-stairs/
+ *
+ * Runtime: 0 ms (100%)
+ * Memory Usage: 2.01 MB (53.39%)
+ */
+
+static mut MEMO: [i32; 45] = [-1; 45];
+
+pub fn solve(n: i32) -> i32 {
+  return descend(i8::try_from(n).unwrap());
+}
+
+fn descend(n: i8) -> i32 {
+  if n < 0 { return 0 }
+  if n == 0 { return 1 }
+
+  let step = usize::try_from(n).unwrap() - 1;
+  unsafe {
+    if MEMO[step] != -1 { return MEMO[step] }
+  }
+
+  let mut combos = 0;
+
+  combos += descend(n-1);
+  combos += descend(n-2);
+
+  unsafe {
+    if MEMO[step] == -1 { MEMO[step] = combos; }
+  }
+
+  return combos;
+}
+
+#[cfg(test)]
+mod climbing_stairs_tests {
+  use super::*;
+
+  #[test]
+  fn stair_count_1() {
+    assert_eq!(solve(1), 1);
+  }
+
+  #[test]
+  fn stair_count_7() {
+    assert_eq!(solve(7), 21);
+  }
+
+  #[test]
+  fn stair_count_12() {
+    assert_eq!(solve(12), 233);
+  }
+
+  #[test]
+  fn stair_count_22() {
+    assert_eq!(solve(22), 28_657);
+  }
+
+  #[test]
+  fn stair_count_38() {
+    assert_eq!(solve(38), 63_245_986);
+  }
+
+  #[test]
+  fn stair_count_45() {
+    assert_eq!(solve(45), 1_836_311_903);
+  }
+}

src/main.rs

@@ -4,6 +4,7 @@ pub mod math;
 pub mod bit_manipulation;
 pub mod array;
 pub mod string;
+pub mod dp;
 
 fn main() {
     // array::run();

src/math/mod.rs

@@ -1,4 +1,3 @@
 pub mod p0069_sqrt;
 
-pub fn run() {
-}
+pub fn run() {}

src/string/p0013_roman_to_int.rs

@@ -8,20 +8,45 @@ use phf::phf_map;
  * URL: https://leetcode.com/problems/roman-to-integer/
  *
  * Runtime: 0 ms (100%)
- * Memory Usage: 2.32 MB (10.58%)
+ * Memory Usage: 2.06 MB (63.81%)
  */
 
-const NUMERALS: [(char, u32); 7] = [
-  ('I', 1),
-  ('V', 5),
-  ('X', 10),
-  ('L', 50),
-  ('C', 100),
-  ('D', 500),
-  ('M', 1000),
-];
-
 pub fn solve(s: &str) -> i32 {
+    let map: HashMap<char, i32> = HashMap::from([
+      ('I', 1),
+      ('V', 5),
+      ('X', 10),
+      ('L', 50),
+      ('C', 100),
+      ('D', 500),
+      ('M', 1000)
+    ]);
+    let mut result = 0;
+    let mut previous = '0';
+    let mut subtract_previous = false;
+
+    for (i, roman) in s.chars().enumerate() {
+        let val = map.get(&roman).unwrap();
+
+        if subtract_previous {
+            result += val - map.get(&previous).unwrap();
+            subtract_previous = false;
+            continue;
+        }
+
+        if i+1 < s.len() && val < map.get(&(s.get(i+1..i+2).unwrap().as_bytes()[0] as char)).unwrap() {
+            subtract_previous = true;
+        } else {
+            result += val;
+        }
+
+        previous = roman;
+    }
+
+    return result;
+}
+
+pub fn solve_rev(s: &str) -> i32 {
   let map: HashMap<char, i32> = HashMap::from([
     ('I', 1),
     ('V', 5),
@@ -32,29 +57,24 @@ pub fn solve(s: &str) -> i32 {
     ('M', 1000)
   ]);
   let mut result = 0;
-  let mut subtract_previous = false;
 
-  for (i, char) in s.chars().enumerate() {
-    let val = map.get(&char).unwrap();
+  let mut previous = 0;
 
-    if subtract_previous {
-      result += val - map.get(&(s.get(i-1..i).unwrap().as_bytes()[0] as char)).unwrap();
-      subtract_previous = false;
-      continue;
-    }
+  for (i, roman) in s.chars().rev().enumerate() {
+    let val = map.get(&roman).unwrap();
 
-    if i+1 < s.len() && val < map.get(&(s.get(i+1..i+2).unwrap().as_bytes()[0] as char)).unwrap() {
-      subtract_previous = true;
-    } else {
-      result += val;
+    if val < &previous {
+      result -= val
     }
+    else { result += val }
 
+    previous = val.clone();
   }
 
-  result
+  return result;
 }
 
-pub fn solve_phf(s: String) -> i32 {
+pub fn solve_phf(s: &str) -> i32 {
   let mut result: i32 = 0;
 
   let mut buf = [0; 1];
@@ -111,17 +131,38 @@ mod roman_to_int_tests {
   use super::*;
 
   #[test]
-  fn happy_path() {
-    assert_eq!(solve("LVIII"), 58);
+  fn roman_i() {
+    let roman_numeral = "I";
+    let ans = 1;
+    assert_eq!(solve(roman_numeral), ans);
+    assert_eq!(solve_rev(roman_numeral), ans);
+    assert_eq!(solve_phf(roman_numeral), ans);
+  }
+
+  #[test]
+  fn roman_lviii() {
+    let roman_numeral = "LVIII";
+    let ans = 58;
+    assert_eq!(solve(roman_numeral), ans);
+    assert_eq!(solve_rev(roman_numeral), ans);
+    assert_eq!(solve_phf(roman_numeral), ans);
   }
 
   #[test]
-  fn subtraction_before_additions() {
-    assert_eq!(solve("XLII"), 42);
+  fn roman_xlii() {
+    let roman_numeral = "XLII";
+    let ans = 42;
+    assert_eq!(solve(roman_numeral), ans);
+    assert_eq!(solve_rev(roman_numeral), ans);
+    assert_eq!(solve_phf(roman_numeral), ans);
   }
 
   #[test]
-  fn multiple_subtractions() {
-    assert_eq!(solve("MCMXCIV"), 1994);
+  fn roman_mcmxciv() {
+    let roman_numeral = "MCMXCIV";
+    let ans = 1994;
+    assert_eq!(solve(roman_numeral), ans);
+    assert_eq!(solve_rev(roman_numeral), ans);
+    assert_eq!(solve_phf(roman_numeral), ans);
   }
 }