1 files changed, 16 insertions, 16 deletions

diff --git a/2024_rust/src/bin/day5.rs b/2024_rust/src/bin/day5.rs
index fe22295..9a97def 100644
--- a/2024_rust/src/bin/day5.rs
+++ b/2024_rust/src/bin/day5.rs
@@ -36,7 +36,7 @@ struct RuleStatus {
 }
 
 impl RuleStatus {
-    fn new(rules: &Vec<Rule>) -> Self {
+    fn new(rules: &[Rule]) -> Self {
         let mut previous = HashMap::new();
         for &Rule { before, after } in rules.iter() {
             match previous.get_mut(&after) {
@@ -80,8 +80,8 @@ fn update_from_str(s: &str) -> Update {
         .collect()
 }
 
-fn is_update_valid(update: &Update, rules: &Vec<Rule>) -> bool {
-    let mut status = RuleStatus::new(&rules);
+fn is_update_valid(update: &Update, rules: &[Rule]) -> bool {
+    let mut status = RuleStatus::new(rules);
     for page in update.iter() {
         if !status.step(page) {
             return false;
@@ -111,15 +111,15 @@ impl FromStr for Input {
         };
 
         // Read rules
-        while let Some(l) = lines.next() {
-            if l == "" {
+        for l in lines.by_ref() {
+            if l.is_empty() {
                 break;
             }
             input.rules.push(Rule::from_str(l).unwrap());
         }
 
         // Read updates
-        while let Some(l) = lines.next() {
+        for l in lines.by_ref() {
             input.updates.push(update_from_str(l));
         }
 
@@ -130,8 +130,8 @@ impl FromStr for Input {
 fn sum_valid_updates(Input { rules, updates }: &Input) -> u32 {
     updates
         .iter()
-        .filter(|u| is_update_valid(u, &rules))
-        .map(|u| middle_page(u))
+        .filter(|u| is_update_valid(u, rules))
+        .map(middle_page)
         .sum()
 }
 
@@ -141,16 +141,16 @@ fn p1(input: &str) -> String {
 }
 
 // Remove useless rules for this particular update
-fn filter_rules(rules: &Vec<Rule>, update: &Update) -> Vec<Rule> {
+fn filter_rules(rules: &[Rule], update: &Update) -> Vec<Rule> {
     let updated: HashSet<&Page> = update.iter().collect();
     rules
         .iter()
-        .cloned()
         .filter(|r| updated.contains(&r.before))
+        .cloned()
         .collect()
 }
 
-fn sort_rules(rules: &Vec<Rule>) -> Vec<Rule> {
+fn sort_rules(rules: &[Rule]) -> Vec<Rule> {
     let mut sorted: Vec<Rule> = vec![];
     let mut afters: HashMap<Page, u8> = HashMap::new();
     for a in rules.iter().map(|r| r.after) {
@@ -158,11 +158,11 @@ fn sort_rules(rules: &Vec<Rule>) -> Vec<Rule> {
     }
 
     // Allocate new "droppable" rules by wrapping the originals into Options
-    let mut rules: Vec<Option<&Rule>> = rules.iter().map(|r| Some(r)).collect();
+    let mut rules: Vec<Option<&Rule>> = rules.iter().map(Some).collect();
     while rules.iter().any(|x| x.is_some()) {
         for rule in rules.iter_mut() {
             let Some(r) = *rule else { continue };
-            if let None = afters.get(&r.before) {
+            if !afters.contains_key(&r.before) {
                 sorted.push(r.clone());
                 match afters.get_mut(&r.after) {
                     None => {
@@ -183,7 +183,7 @@ fn sort_rules(rules: &Vec<Rule>) -> Vec<Rule> {
     sorted
 }
 
-fn update_reorder(update: &Update, rules: &Vec<Rule>) -> Option<Update> {
+fn update_reorder(update: &Update, rules: &[Rule]) -> Option<Update> {
     let filtered_rules = filter_rules(rules, update);
     let sorted_rules = sort_rules(&filtered_rules);
     let mut result: Update = vec![];
@@ -208,8 +208,8 @@ fn update_reorder(update: &Update, rules: &Vec<Rule>) -> Option<Update> {
 fn sum_reordered_updates(Input { rules, updates }: &Input) -> u32 {
     updates
         .iter()
-        .filter(|u| !is_update_valid(u, &rules)) // drop valid updates
-        .filter_map(|u| update_reorder(u, &rules)) // reorder updates
+        .filter(|u| !is_update_valid(u, rules)) // drop valid updates
+        .filter_map(|u| update_reorder(u, rules)) // reorder updates
         .map(|u| middle_page(&u))
         .sum()
 }