adventofcode

commit

0d19eb76766256b424e9a7511516dece5091cece

parent

1db2b94025adb8299a3133cb7d5b30e903ce5c0b

Author

Tobias Bengfort <tobias.bengfort@posteo.de>

Date

2021-12-24 10:20

stack execution

Diffstat

1 files changed, 48 insertions, 31 deletions

diff --git a/2021/24/part1.rs b/2021/24/part1.rs

@@ -1,57 +1,74 @@
    1    -1 use std::collections::HashMap;
    2     1 use std::env::args;
    3     2 use std::fs::File;
    4     3 use std::io::BufRead;
    5     4 use std::io::BufReader;
    6     5 
   -1     6 #[derive(PartialEq, Debug)]
   -1     7 enum Token {
   -1     8     Add,
   -1     9     Mul,
   -1    10     Div,
   -1    11     Mod,
   -1    12     Eql,
   -1    13     Int(i16),
   -1    14     Var(char),
   -1    15     Input(u8),
   -1    16 }
   -1    17 
    7    18 fn s2c(s: &str) -> char {
    8    19     assert_eq!(s.len(), 1);
    9    20     return s.chars().next().unwrap();
   10    21 }
   11    22 
   12    -1 #[derive(Debug)]
   13    -1 struct Condition {
   14    -1     not: bool,
   15    -1     value: i16,
   16    -1 }
   17    -1 
   18    -1 fn op_i(op: &str, a: Option<&Condition>, bi: i16) -> Condition {
   19    -1     return Condition {not: false, value: 0};
   20    -1 }
   21    -1 
   22    -1 fn op_c(op: &str, a: Option<&Condition>, b: Option<&Condition>) -> Condition {
   23    -1     return Condition {not: false, value: 0};
   24    -1 }
   25    -1 
   26    23 fn main() {
   27    24     let path = args().nth(1).unwrap();
   28    25     let file = File::open(path).unwrap();
   29    26 
   30    -1     let mut inputs = 0;
   31    -1     let mut conditions: HashMap<char, Condition> = HashMap::new();
   32    -1 
   33    -1     conditions.insert('z', Condition {not: false, value: 0});
   -1    27     let mut input = 0;
   -1    28     let mut stack = vec![Token::Var('z')];
   34    29 
   35    30     // FIXME: reverse
   36    -1     for line in BufReader::new(file).lines() {
   -1    31     for (i, line) in BufReader::new(file).lines().enumerate() {
   37    32         let l = line.unwrap();
   38    33 
   39    34         match l.split(" ").collect::<Vec<&str>>()[..] {
   40    -1             ["inp", s] => {
   41    -1                 let c = s2c(s);
   42    -1                 println!("{:?}", conditions.get(&c));
   43    -1                 conditions.remove(&c);
   44    -1                 inputs += 1;
   -1    35             ["inp", a] => {
   -1    36                 let mut new = vec![];
   -1    37                 for token in stack {
   -1    38                     if token == Token::Var(s2c(a)) {
   -1    39                         new.push(Token::Input(input));
   -1    40                     } else {
   -1    41                         new.push(token);
   -1    42                     }
   -1    43                 }
   -1    44                 stack = new;
   -1    45                 input += 1;
   45    46             },
   46    47             [op, a, b] => {
   47    -1                 let ac = s2c(a);
   48    -1                 conditions.insert(ac, match b.parse::<i16>() {
   49    -1                     Ok(bi) => op_i(op, conditions.get(&ac), bi),
   50    -1                     Err(_) => op_c(op, conditions.get(&ac), conditions.get(&s2c(b))),
   51    -1                 });
   -1    48                 let mut new = vec![];
   -1    49                 for token in stack {
   -1    50                     if token == Token::Var(s2c(a)) {
   -1    51                         new.push(match op {
   -1    52                             "add" => Token::Add,
   -1    53                             "mul" => Token::Mul,
   -1    54                             "div" => Token::Div,
   -1    55                             "mod" => Token::Mod,
   -1    56                             "eql" => Token::Eql,
   -1    57                             _ => unreachable!(),
   -1    58                         });
   -1    59                         new.push(Token::Var(s2c(a)));
   -1    60                         new.push(match b.parse::<i16>() {
   -1    61                             Ok(bi) => Token::Int(bi),
   -1    62                             Err(_) => Token::Var(s2c(b)),
   -1    63                         });
   -1    64                     } else {
   -1    65                         new.push(token);
   -1    66                     }
   -1    67                 }
   -1    68                 stack = new;
   52    69             },
   53    70             _ => unreachable!(),
   54    71         }
   -1    72         println!("{} {:?}", i, stack);
   55    73     }
   56    -1     println!("{:?}", conditions);
   57    74 }