clippy nursery 🍼

Author: rene-d

2015/Cargo.toml

@@ -1,5 +1,4 @@
 
 [workspace]
 members = ["day*"]
-exclude = ["day21"]
 resolver = "2"

2015/day10/day10.rs

@@ -16,20 +16,20 @@ fn solve(start_sequence: &str, turns: u32) {
 
         let mut count = 0;
         let mut previous = '\0';
-        for current in look {
-            if previous != '\0' && previous != current {
+        for current in &look {
+            if previous != '\0' && previous != *current {
                 say.extend(count.to_string().chars());
                 say.push(previous);
                 count = 0;
             }
             count += 1;
-            previous = current;
+            previous = *current;
         }
 
         say.extend(count.to_string().chars());
         say.push(previous);
 
-        look = say.clone();
+        look.clone_from(&say);
     }
     println!("{}", look.len());
 }

2015/day13/day13.rs

@@ -8,7 +8,7 @@ fn calc(names: &HashSet<String>, happiness: &HashMap<(String, String), i32>) ->
     let perm_names = &mut names.iter().collect::<Vec<&String>>();
     let permutator = HeapPermutationIterator::new(perm_names);
 
-    let mut happiness_max = std::i32::MIN;
+    let mut happiness_max = i32::MIN;
 
     for permutated in permutator {
         let mut happiness_sum = 0;

2015/day19/day19.rs

@@ -8,8 +8,8 @@ struct Puzzle {
 }
 
 impl Puzzle {
-    fn new() -> Puzzle {
-        Puzzle {
+    const fn new() -> Self {
+        Self {
             replacements: vec![],
             medicine_molecule: String::new(),
         }
@@ -23,7 +23,7 @@ impl Puzzle {
             if let Some((a, b)) = line.split_once(" => ") {
                 self.replacements.push((a.to_string(), b.to_owned()));
             } else if !line.is_empty() {
-                self.medicine_molecule = line.to_owned();
+                line.clone_into(&mut self.medicine_molecule);
             }
         }
     }

2015/day20/day20.rs

@@ -7,8 +7,8 @@ struct Puzzle {
 }
 
 impl Puzzle {
-    fn new() -> Puzzle {
-        Puzzle { house_present: 0 }
+    const fn new() -> Self {
+        Self { house_present: 0 }
     }
 
     fn configure(&mut self, filename: &str) {

2015/day21/Cargo.toml

@@ -0,0 +1,11 @@
+[package]
+name = "day21"
+version = "0.1.0"
+edition = "2021"
+
+[dependencies]
+aoc = { path = "../../aoc" }
+
+[[bin]]
+name = "day21"
+path = "day21.rs"

2015/day21/day21.rs

@@ -0,0 +1,198 @@
+//! [Day 21: RPG Simulator 20XX](https://adventofcode.com/2015/day/21)
+
+//! [Day 21: RPG Simulator 20XX](https://adventofcode.com/2015/day/21)
+use std::cmp::{max, min};
+use std::str::FromStr;
+
+#[derive(Debug, Clone)]
+struct Character {
+    _name: String,
+    hitpoints: i32,
+    damage: i32,
+    armor: i32,
+}
+
+impl Character {
+    fn new(name: &str, hitpoints: i32, damage: i32, armor: i32) -> Self {
+        Self {
+            _name: name.to_string(),
+            hitpoints,
+            damage,
+            armor,
+        }
+    }
+
+    fn attack(&self, enemy: &mut Self) {
+        let damage = max(0, self.damage - enemy.armor);
+        enemy.hitpoints -= damage;
+
+        if enemy.hitpoints < 0 {
+            enemy.hitpoints = 0;
+        }
+
+        // Optional: Uncomment for debugging
+        // println!(
+        //     "The {} deals {}-{} = {} damage; the {} goes down to {} hit points.",
+        //     self.name, self.damage, enemy.armor, damage, enemy.name, enemy.hitpoints
+        // );
+    }
+}
+
+fn combat(c1: &mut Character, c2: &mut Character) -> i32 {
+    loop {
+        c1.attack(c2);
+        if c2.hitpoints == 0 {
+            return 1;
+        }
+
+        c2.attack(c1);
+        if c1.hitpoints == 0 {
+            return 2;
+        }
+    }
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+struct Item {
+    cost: i32,
+    damage: i32,
+    armor: i32,
+}
+
+fn parse_items(input: &str) -> Vec<Item> {
+    input
+        .lines()
+        .filter(|line| !line.trim().is_empty())
+        .map(|line| {
+            let parts: Vec<&str> = line.split_whitespace().collect();
+            let cost = i32::from_str(parts[parts.len() - 3]).unwrap();
+            let damage = i32::from_str(parts[parts.len() - 2]).unwrap();
+            let armor = i32::from_str(parts[parts.len() - 1]).unwrap();
+            Item {
+                cost,
+                damage,
+                armor,
+            }
+        })
+        .collect()
+}
+
+fn play(boss: &Character) -> (i32, i32) {
+    let weapons = parse_items(
+        r"
+Dagger        8     4       0
+Shortsword   10     5       0
+Warhammer    25     6       0
+Longsword    40     7       0
+Greataxe     74     8       0
+",
+    );
+
+    let mut armors = parse_items(
+        r"
+Leather      13     0       1
+Chainmail    31     0       2
+Splintmail   53     0       3
+Bandedmail   75     0       4
+Platemail   102     0       5
+",
+    );
+
+    let mut rings = parse_items(
+        r"
+Damage +1    25     1       0
+Damage +2    50     2       0
+Damage +3   100     3       0
+Defense +1   20     0       1
+Defense +2   40     0       2
+Defense +3   80     0       3
+",
+    );
+
+    // Add "no armor" and "no ring" options
+    armors.push(Item {
+        cost: 0,
+        damage: 0,
+        armor: 0,
+    });
+    rings.push(Item {
+        cost: 0,
+        damage: 0,
+        armor: 0,
+    });
+
+    let mut min_win_cost = i32::MAX;
+    let mut max_loose_cost = 0;
+
+    for w in &weapons {
+        for a in &armors {
+            for r1 in &rings {
+                for r2 in &rings {
+                    // Cannot buy two of the same rings
+                    if r1 == r2 {
+                        continue;
+                    }
+
+                    let cost = w.cost + a.cost + r1.cost + r2.cost;
+                    let damage = w.damage + a.damage + r1.damage + r2.damage;
+                    let armor = w.armor + a.armor + r1.armor + r2.armor;
+
+                    let mut player = Character::new("player", 100, damage, armor);
+                    let mut boss_copy = boss.clone();
+
+                    if combat(&mut player, &mut boss_copy) == 1 {
+                        min_win_cost = min(min_win_cost, cost);
+                    } else {
+                        max_loose_cost = max(max_loose_cost, cost);
+                    }
+                }
+            }
+        }
+    }
+
+    (min_win_cost, max_loose_cost)
+}
+
+struct Puzzle {
+    min_win_cost: i32,
+    max_loose_cost: i32,
+}
+
+impl Puzzle {
+    const fn new() -> Self {
+        Self {
+            min_win_cost: 0,
+            max_loose_cost: 0,
+        }
+    }
+
+    /// Get the puzzle input.
+    fn solve(&mut self, path: &str) {
+        let data = std::fs::read_to_string(path).unwrap_or_else(|_| {
+            eprintln!("cannot read input file {path}");
+            std::process::exit(1);
+        });
+
+        let mut boss = Character::new("boss", 0, 0, 0);
+
+        for line in data.lines() {
+            let parts: Vec<&str> = line.split(": ").collect();
+            match parts.first() {
+                Some(&"Hit Points") => boss.hitpoints = parts[1].parse().unwrap(),
+                Some(&"Damage") => boss.damage = parts[1].parse().unwrap(),
+                Some(&"Armor") => boss.armor = parts[1].parse().unwrap(),
+                _ => {}
+            }
+        }
+
+        (self.min_win_cost, self.max_loose_cost) = play(&boss);
+    }
+}
+
+fn main() {
+    let args = aoc::parse_args();
+    let mut puzzle = Puzzle::new();
+    puzzle.solve(args.path.as_str());
+    println!("{}", puzzle.min_win_cost);
+    println!("{}", puzzle.max_loose_cost);
+}

2015/day22/day22.rs

@@ -31,7 +31,7 @@ struct State {
 }
 
 impl State {
-    fn new(boss_dmg: i32, boss_hp: i32, hp: i32, mana: i32) -> Self {
+    const fn new(boss_dmg: i32, boss_hp: i32, hp: i32, mana: i32) -> Self {
         Self {
             boss_dmg,
             boss_hp,
@@ -149,8 +149,8 @@ struct Puzzle {
 }
 
 impl Puzzle {
-    fn new() -> Puzzle {
-        Puzzle {
+    const fn new() -> Self {
+        Self {
             boss_hp: 0,
             boss_dmg: 0,
         }

2015/day23/day23.rs

@@ -33,8 +33,8 @@ struct Puzzle {
 }
 
 impl Puzzle {
-    fn new() -> Puzzle {
-        Puzzle { program: vec![] }
+    const fn new() -> Self {
+        Self { program: vec![] }
     }
 
     /// Get the puzzle input.

2015/day24/day24.rs

@@ -7,8 +7,8 @@ struct Puzzle {
 }
 
 impl Puzzle {
-    fn new() -> Puzzle {
-        Puzzle { packages: vec![] }
+    const fn new() -> Self {
+        Self { packages: vec![] }
     }
 
     /// Get the puzzle input.