Completed 'House Robber' and 'Remove Element'

Author: OmnicWolf

Readme.md

@@ -15,11 +15,14 @@
 - **Bit Manipulation**
   - <span>190. Reverse Bits</span>
   - <span>191. Number of 1 Bits</span>
+- **Arrays**
+  - <span>27. Remove Element</span>
 - **Strings**
   - <span>13. Roman to Integer</span>
   - <span>67. Add Binary</span>
 - **Dynamic Programming**
-  - <span>70. climb Stairs</span>
+  - <span>70. Climb Stairs</span>
+  - <span>198. House Robber</span>
 
 ## Resources
 

src/array/mod.rs

@@ -1,6 +1,6 @@
-pub fn run() {}
-
+pub mod p0027_remove_element;
 
+pub fn run() {}
 
 const NUMERALS: [(char, u32); 7] = [
   ('I', 1),

src/array/p0027_remove_element.rs

@@ -0,0 +1,102 @@
+/*
+ * Problem: 27. Remove Element (Easy)
+ * URL: https://leetcode.com/problems/remove-element/
+ *
+ * Runtime: 1 ms (82.16%)
+ * Memory Usage: 2.00 MB (57.82%)
+ */
+
+
+pub fn solve(nums: &mut Vec<i32>, val: i32) -> i32 {
+  if nums.len() == 0 { return 0 }
+
+  let mut count = 0;
+
+  let mut lb = 0;
+  let mut rb = nums.len()-1; 
+
+  while lb <= rb {
+    if nums[lb] != val {
+      lb += 1;
+      continue;
+    }
+
+    if nums[rb] != val {
+      nums[lb] = nums[rb];
+    }
+
+    count += 1;
+    
+    match rb.checked_sub(1) {
+        None => break,
+        Some(_) => rb -= 1
+    }
+  }
+
+  return i32::try_from(nums.len()).unwrap() - count;
+}
+
+#[cfg(test)]
+mod remove_element_tests {
+  use super::*;
+
+  #[test]
+  fn happy_path() {
+    let mut nums = vec![0,1,2,2,3,0,4,2];
+    let val = 2;
+    let remaining_count = usize::try_from(solve(&mut nums, val)).unwrap();
+     
+    assert_eq!(remaining_count, 5);
+    assert_eq!(nums[0..remaining_count], vec![0,1,4,0,3]);
+  }
+
+  #[test]
+  fn all_val() {
+    let mut nums = vec![3,3,3,3,3];
+    let val = 3;
+    let remaining_count = usize::try_from(solve(&mut nums, val)).unwrap();
+     
+    assert_eq!(remaining_count, 0);
+    assert_eq!(nums[0..remaining_count], vec![]);
+  }
+
+  #[test]
+  fn last_val() {
+    let mut nums = vec![3,3,3,3,4];
+    let val = 3;
+    let remaining_count = usize::try_from(solve(&mut nums, val)).unwrap();
+     
+    assert_eq!(remaining_count, 1);
+    assert_eq!(nums[0..remaining_count], vec![4]);
+  }
+
+  #[test]
+  fn no_val() {
+    let mut nums = vec![50, 42];
+    let val = 65;
+    let remaining_count = usize::try_from(solve(&mut nums, val)).unwrap();
+     
+    assert_eq!(remaining_count, 2);
+    assert_eq!(nums[0..remaining_count], vec![50, 42]);
+  }
+
+  #[test]
+  fn more_val_than_remaining() {
+    let mut nums = vec![2,2,2,5,5];
+    let val = 2;
+    let remaining_count = usize::try_from(solve(&mut nums, val)).unwrap();
+     
+    assert_eq!(remaining_count, 2);
+    assert_eq!(nums[0..remaining_count], vec![5,5]);
+  }
+
+  #[test]
+  fn val_sandwich() {
+    let mut nums = vec![3,2,2,3];
+    let val = 3;
+    let remaining_count = usize::try_from(solve(&mut nums, val)).unwrap();
+     
+    assert_eq!(remaining_count, 2);
+    assert_eq!(nums[0..remaining_count], vec![2,2]);
+  }
+}

src/dp/mod.rs

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

src/dp/p0198_house_robber.rs

@@ -0,0 +1,74 @@
+use std::cmp;
+
+/*
+ * Problem: 198. House Robber (Medium)
+ * URL: https://leetcode.com/problems/house-robber/
+ *
+ * Runtime: 0 ms (100%)
+ * Memory Usage: 2.16 MB (23.83%)
+ */
+
+pub fn solve(mut nums: Vec<i32>) -> i32 {
+  if nums.len() < 2 { return nums[0] }
+
+  // Rob houses (fill memo)
+  for house in (0..nums.len()-2).rev() {
+    nums[house] = rob(house, &nums);
+  }
+  
+  return cmp::max(nums[0], nums[1]);  // Return optimal loot
+}
+
+fn rob(i: usize, nums: &Vec<i32>) -> i32 {
+  return nums[i] + cmp::max(
+    get_max_loot(i+2, &nums),
+    get_max_loot(i+3, &nums)
+  );
+}
+
+fn get_max_loot(house: usize, nums: &Vec<i32>) -> i32 {
+  return if(house > nums.len()-1) { 0 }
+  else {
+    nums[house]
+  }
+}
+
+#[cfg(test)]
+mod house_robber_tests {
+  use super::*;
+
+  #[test]
+  fn happy_path() {
+    assert_eq!(solve(vec![2,7,9,3,1]), 12);
+  }
+
+  #[test]
+  fn start_at_2nd_house() {
+    assert_eq!(solve(vec![1,3,1,1,1]), 4);
+  }
+
+  #[test]
+  fn skip_2() {
+    assert_eq!(solve(vec![8,0,1,9,2]), 17);
+  }
+
+  #[test]
+  fn single_house() {
+    assert_eq!(solve(vec![7]), 7);
+  }
+
+  #[test]
+  fn small_neighborhood() {
+    assert_eq!(solve(vec![42, 53]), 53);
+  }
+
+  #[test]
+  fn large_neighborhood() {
+    assert_eq!(solve(vec![114,117,207,117,235,82,90,67,143,146,53,108,200,91,80,223,58,170,110,236,81,90,222,160,165,195,187,199,114,235,197,187,69,129,64,214,228,78,188,67,205,94,205,169,241,202,144,240]),
+    4173);
+  }
+}
+
+
+
+