Add problem 874: Walking Robot Simulation

Author: EFanZh

src/lib.rs

@@ -716,6 +716,7 @@ pub mod problem_0868_binary_gap;
 pub mod problem_0869_reordered_power_of_2;
 pub mod problem_0870_advantage_shuffle;
 pub mod problem_0872_leaf_similar_trees;
+pub mod problem_0874_walking_robot_simulation;
 pub mod problem_1143_longest_common_subsequence;
 pub mod problem_1192_critical_connections_in_a_network;
 pub mod problem_1342_number_of_steps_to_reduce_a_number_to_zero;

src/problem_0874_walking_robot_simulation/iterative.rs

@@ -0,0 +1,65 @@
+pub struct Solution;
+
+// ------------------------------------------------------ snip ------------------------------------------------------ //
+
+use std::collections::HashSet;
+use std::convert::TryInto;
+
+impl Solution {
+    pub fn robot_sim(commands: Vec<i32>, obstacles: Vec<Vec<i32>>) -> i32 {
+        let mut position = (0, 0);
+        let mut direction = (0, 1);
+
+        let obstacles = obstacles
+            .into_iter()
+            .map(|position| {
+                let [x, y]: [i32; 2] = position.as_slice().try_into().unwrap();
+
+                (x, y)
+            })
+            .collect::<HashSet<_>>();
+
+        let mut result = 0;
+
+        for command in commands {
+            match command {
+                -2 => direction = (-direction.1, direction.0),
+                -1 => direction = (direction.1, -direction.0),
+                mut distance => loop {
+                    let next_position = (position.0 + direction.0, position.1 + direction.1);
+
+                    if obstacles.contains(&next_position) {
+                        break;
+                    }
+
+                    position = next_position;
+                    distance -= 1;
+
+                    result = result.max(position.0.pow(2) + position.1.pow(2));
+
+                    if distance == 0 {
+                        break;
+                    }
+                },
+            }
+        }
+
+        result
+    }
+}
+
+// ------------------------------------------------------ snip ------------------------------------------------------ //
+
+impl super::Solution for Solution {
+    fn robot_sim(commands: Vec<i32>, obstacles: Vec<Vec<i32>>) -> i32 {
+        Self::robot_sim(commands, obstacles)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    #[test]
+    fn test_solution() {
+        super::super::tests::run::<super::Solution>();
+    }
+}

src/problem_0874_walking_robot_simulation/mod.rs

@@ -0,0 +1,25 @@
+pub mod iterative;
+
+pub trait Solution {
+    fn robot_sim(commands: Vec<i32>, obstacles: Vec<Vec<i32>>) -> i32;
+}
+
+#[cfg(test)]
+mod tests {
+    use super::Solution;
+
+    pub fn run<S: Solution>() {
+        let test_cases = [
+            ((&[4, -1, 3] as &[_], &[] as &[[_; 2]]), 25),
+            ((&[4, -1, 4, -2, 4], &[[2, 4]]), 65),
+            ((&[6, -1, -1, 6], &[]), 36),
+        ];
+
+        for ((commands, obstacles), expected) in test_cases {
+            assert_eq!(
+                S::robot_sim(commands.to_vec(), obstacles.iter().copied().map(Vec::from).collect()),
+                expected
+            );
+        }
+    }
+}