From dbb5a4e5711fba371fbb011356bcd8a28cc963e4 Mon Sep 17 00:00:00 2001
From: Sebastiano Tronto <sebastiano@tronto.net>
Date: Tue, 8 Jul 2025 17:10:53 +0200
Subject: Day 22 2022

---
 2022/22/a.rs | 81 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 81 insertions(+)
 create mode 100644 2022/22/a.rs

(limited to '2022/22/a.rs')

diff --git a/2022/22/a.rs b/2022/22/a.rs
new file mode 100644
index 0000000..40f9c44
--- /dev/null
+++ b/2022/22/a.rs
@@ -0,0 +1,81 @@
+use std::cmp::max;
+mod common;
+use common::*;
+
+#[derive(Copy, Clone, Debug)]
+pub struct Position {
+    pub i: usize,
+    pub j: usize,
+    pub d: Direction
+}
+
+pub struct Map {
+    pub tiles: Vec<Vec<Tile>>
+}
+
+type StepFn = fn(&Map, Position) -> Position;
+
+impl Map {
+    pub fn from_stdin() -> Map {
+        let mut maxlen = 0;
+        let mut tiles = vec![];
+        let mut line = String::new();
+        while std::io::stdin().read_line(&mut line).unwrap() > 1 {
+            let v = line[0..line.len()-1].as_bytes().iter()
+                .map(|b| Tile::from_byte(*b)).collect::<Vec<_>>();
+            maxlen = max(maxlen, v.len());
+            tiles.push(v);
+            line.clear();
+        }
+        for v in &mut tiles {
+            while v.len() < maxlen { v.push(Tile::Skip); }
+        }
+        Map { tiles }
+    }
+
+    pub fn start_position(&self) -> Position {
+        let first_valid = self.tiles[0].iter()
+            .position(|t| *t == Tile::Walk).unwrap();
+        Position { i: 0, j: first_valid, d: Direction::Right }
+    }
+
+    pub fn walk(&self, pos: Position, n: usize, step: StepFn) -> Position {
+        let mut p = pos;
+        for _ in 0..n { p = step(self, p); }
+        p
+    }
+}
+
+fn step(map: &Map, position: Position) -> Position {
+    let imax = map.tiles.len();
+    let jmax = map.tiles[0].len();
+    let s = position.d.step();
+    let mut p = position;
+    loop {
+        let inext = ((s.0 + imax as i64) as usize + p.i) % imax;
+        let jnext = ((s.1 + jmax as i64) as usize + p.j) % jmax;
+        p = Position { i: inext, j: jnext, d: p.d };
+        match map.tiles[p.i][p.j] {
+            Tile::Walk => return p,
+            Tile::Wall => return position,
+            Tile::Skip => ()
+        }
+    }
+}
+
+fn password(p: Position) -> usize {
+    1000 * (p.i+1) + 4 * (p.j+1) + p.d.value()
+}
+
+fn main() {
+    let map = Map::from_stdin();
+    let (turns, steps) = read_instruction_line_from_stdin();
+    let mut position = map.start_position();
+
+    for i in 0..turns.len() {
+        position = map.walk(position, steps[i], step);
+        position.d = position.d.turn(turns[i]);
+    }
+    position = map.walk(position, steps[steps.len()-1], step);
+    println!("{}", password(position));
+}
-- 
cgit v1.3