Completed '13. Roman to Int'

Author: OmnicWolf

Readme.md

@@ -4,7 +4,7 @@
 - Solutions Visualized – [@CoffeelessProgrammer | Instagram](https://www.instagram.com/coffeelessprogrammer/)
 
 ## Environment
-- <span>Rust v1.72.1</span>
+- <span>Rust v1.73.0</span>
 
 ## Problems Completed
 
@@ -16,6 +16,7 @@
   - <span>190. Reverse Bits</span>
   - <span>191. Number of 1 Bits</span>
 - **Strings**
+  - <span>13. Roman to Integer</span>
   - <span>67. Add Binary</span>
 
 ## Resources

src/bit_manipulation/mod.rs

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

src/bit_manipulation/reverse_bits.rs src/bit_manipulation/p0190_reverse_bits.rs

@@ -13,7 +13,6 @@ pub fn solve(mut x: u32) -> u32 {
   for i in 0..32 {
     // println!("\n({i}) x={:#32b}\nresult={:#32b}", x, result);
     result <<= 1;
-
     if (x & mask == 1) { result += 1 }
     x >>= 1;
   }

src/bit_manipulation/count_set_bits.rs src/bit_manipulation/p0191_count_set_bits.rs

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

src/math/mod.rs

@@ -0,0 +1,19 @@
+/*
+ * Problem: XXX. PROBLEM_NAME (DIFFICULTY)
+ * URL: LINK_HERE
+ *
+ * Runtime: 50 ms (100%)
+ * Memory Usage: 10 MB (100%)
+ */
+
+pub fn solve() -> u32 {}
+
+#[cfg(test)]
+mod template_tests {
+  use super::*;
+
+  #[test]
+  fn happy_path() {
+    assert_eq!(solve(), 0b00111001_01111000_00101001_01000000);
+  }
+}

src/math/sqrt.rs src/math/p0069_sqrt.rs

@@ -1,11 +1,11 @@
-pub mod roman_to_int;
-pub mod add_binary;
+pub mod p0013_roman_to_int;
+pub mod p0067_add_binary;
 
 pub fn run() {
   display_roman_to_int("XIV");
   display_roman_to_int("XLII");
 }
 
 fn display_roman_to_int(s: &str) {
-  println!("{} -> {}", s, roman_to_int::solve(String::from(s)));
+  println!("{} -> {}", s, p0013_roman_to_int::solve(s));
 }

src/pXXX_template.rs

@@ -1,36 +1,60 @@
 // #![allow(dead_code)]
 
+use std::collections::HashMap;
 use phf::phf_map;
 
 /*
  * Problem: 13. Roman to Integer (Easy)
  * URL: https://leetcode.com/problems/roman-to-integer/
  *
- * Runtime: ? ms (%)
- * Memory Usage: ? MB (%)
+ * Runtime: 0 ms (100%)
+ * Memory Usage: 2.32 MB (10.58%)
  */
 
-static ROMAN_NUMERALS_STR: phf::Map<&str, i32> = phf_map! {
-  "I" => 1,
-  "V" => 5,
-  "X" => 10,
-  "L" => 50,
-  "C" => 100,
-  "D" => 500,
-  "M" => 1000
-};
+const NUMERALS: [(char, u32); 7] = [
+  ('I', 1),
+  ('V', 5),
+  ('X', 10),
+  ('L', 50),
+  ('C', 100),
+  ('D', 500),
+  ('M', 1000),
+];
 
-static ROMAN_NUMERALS: phf::Map<char, i32> = phf_map! {
-  '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 subtract_previous = false;
 
-pub fn solve(s: String) -> i32 {
+  for (i, char) in s.chars().enumerate() {
+    let val = map.get(&char).unwrap();
+
+    if subtract_previous {
+      result += val - map.get(&(s.get(i-1..i).unwrap().as_bytes()[0] as char)).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;
+    }
+
+  }
+
+  result
+}
+
+pub fn solve_phf(s: String) -> i32 {
   let mut result: i32 = 0;
 
   let mut buf = [0; 1];
@@ -57,15 +81,15 @@ pub fn solve(s: String) -> i32 {
   return result;
 } 
 
-const NUMERALS: [(char, u32); 7] = [
-  ('I', 1),
-  ('V', 5),
-  ('X', 10),
-  ('L', 50),
-  ('C', 100),
-  ('D', 500),
-  ('M', 1000),
-];
+static ROMAN_NUMERALS_STR: phf::Map<&str, i32> = phf_map! {
+  "I" => 1,
+  "V" => 5,
+  "X" => 10,
+  "L" => 50,
+  "C" => 100,
+  "D" => 500,
+  "M" => 1000
+};
 
 /*
     Symbol       Value
@@ -80,4 +104,24 @@ const NUMERALS: [(char, u32); 7] = [
     I can be placed before V (5) and X (10) to make 4 and 9.
     X can be placed before L (50) and C (100) to make 40 and 90.
     C can be placed before D (500) and M (1000) to make 400 and 900.
- */
+ */
+
+#[cfg(test)]
+mod roman_to_int_tests {
+  use super::*;
+
+  #[test]
+  fn happy_path() {
+    assert_eq!(solve("LVIII"), 58);
+  }
+
+  #[test]
+  fn subtraction_before_additions() {
+    assert_eq!(solve("XLII"), 42);
+  }
+
+  #[test]
+  fn multiple_subtractions() {
+    assert_eq!(solve("MCMXCIV"), 1994);
+  }
+}