adventofcode

git clone https://git.ce9e.org/adventofcode.git

commit
c72b57251130d870803925ca2c5271f84d84e342
parent
0d19eb76766256b424e9a7511516dece5091cece
Author
Tobias Bengfort <tobias.bengfort@posteo.de>
Date
2021-12-24 11:00
foo

Diffstat

M 2021/24/part1.rs 148 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++---

1 files changed, 143 insertions, 5 deletions


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

@@ -3,7 +3,12 @@ use std::fs::File;
    3     3 use std::io::BufRead;
    4     4 use std::io::BufReader;
    5     5 
    6    -1 #[derive(PartialEq, Debug)]
   -1     6 fn s2c(s: &str) -> char {
   -1     7     assert_eq!(s.len(), 1);
   -1     8     return s.chars().next().unwrap();
   -1     9 }
   -1    10 
   -1    11 #[derive(PartialEq, Debug, Copy, Clone)]
    7    12 enum Token {
    8    13     Add,
    9    14     Mul,
@@ -15,9 +20,136 @@ enum Token {
   15    20     Input(u8),
   16    21 }
   17    22 
   18    -1 fn s2c(s: &str) -> char {
   19    -1     assert_eq!(s.len(), 1);
   20    -1     return s.chars().next().unwrap();
   -1    23 fn print_formular(formular: &mut std::slice::Iter<'_, Token>) {
   -1    24     match formular.next() {
   -1    25         Some(Token::Add) => {
   -1    26             print!("(");
   -1    27             print_formular(formular);
   -1    28             print!(" + ");
   -1    29             print_formular(formular);
   -1    30             print!(")");
   -1    31         },
   -1    32         Some(Token::Mul) => {
   -1    33             print!("(");
   -1    34             print_formular(formular);
   -1    35             print!(" * ");
   -1    36             print_formular(formular);
   -1    37             print!(")");
   -1    38         },
   -1    39         Some(Token::Div) => {
   -1    40             print!("(");
   -1    41             print_formular(formular);
   -1    42             print!(" / ");
   -1    43             print_formular(formular);
   -1    44             print!(")");
   -1    45         },
   -1    46         Some(Token::Mod) => {
   -1    47             print!("(");
   -1    48             print_formular(formular);
   -1    49             print!(" % ");
   -1    50             print_formular(formular);
   -1    51             print!(")");
   -1    52         },
   -1    53         Some(Token::Eql) => {
   -1    54             print!("(");
   -1    55             print_formular(formular);
   -1    56             print!(" == ");
   -1    57             print_formular(formular);
   -1    58             print!(")");
   -1    59         },
   -1    60         Some(Token::Int(i)) => {
   -1    61             print!("{}", i);
   -1    62         },
   -1    63         Some(Token::Var(c)) => {
   -1    64             print!("{}", c);
   -1    65         },
   -1    66         Some(Token::Input(i)) => {
   -1    67             print!("in{}", i);
   -1    68         },
   -1    69         _ => unreachable!(),
   -1    70     }
   -1    71 }
   -1    72 
   -1    73 fn optimize(input: Vec<Token>) -> Vec<Token> {
   -1    74     let mut stack = input;
   -1    75     let mut dirty = true;
   -1    76     while dirty {
   -1    77         let mut new = vec![];
   -1    78         dirty = false;
   -1    79         let mut i = 0;
   -1    80         while i < stack.len() - 2 {
   -1    81             match stack[i..i+3] {
   -1    82                 [Token::Mul, Token::Var(_), Token::Int(0)] => {
   -1    83                     new.push(Token::Int(0));
   -1    84                     i += 2;
   -1    85                     dirty = true;
   -1    86                 },
   -1    87                 [Token::Mul, Token::Int(0), Token::Var(_)] => {
   -1    88                     new.push(Token::Int(0));
   -1    89                     i += 2;
   -1    90                     dirty = true;
   -1    91                 },
   -1    92                 [Token::Mul, Token::Int(1), Token::Var(b)] => {
   -1    93                     new.push(Token::Var(b));
   -1    94                     i += 2;
   -1    95                     dirty = true;
   -1    96                 },
   -1    97                 [Token::Mul, Token::Var(a), Token::Int(1)] => {
   -1    98                     new.push(Token::Var(a));
   -1    99                     i += 2;
   -1   100                     dirty = true;
   -1   101                 },
   -1   102                 [Token::Add, Token::Int(0), Token::Var(b)] => {
   -1   103                     new.push(Token::Var(b));
   -1   104                     i += 2;
   -1   105                     dirty = true;
   -1   106                 },
   -1   107                 [Token::Add, Token::Var(a), Token::Int(0)] => {
   -1   108                     new.push(Token::Var(a));
   -1   109                     i += 2;
   -1   110                     dirty = true;
   -1   111                 },
   -1   112                 [Token::Div, Token::Var(a), Token::Int(1)] => {
   -1   113                     new.push(Token::Var(a));
   -1   114                     i += 2;
   -1   115                     dirty = true;
   -1   116                 },
   -1   117                 [Token::Add, Token::Int(a), Token::Int(b)] => {
   -1   118                     new.push(Token::Int(a + b));
   -1   119                     i += 2;
   -1   120                     dirty = true;
   -1   121                 },
   -1   122                 [Token::Mul, Token::Int(a), Token::Int(b)] => {
   -1   123                     new.push(Token::Int(a * b));
   -1   124                     i += 2;
   -1   125                     dirty = true;
   -1   126                 },
   -1   127                 [Token::Div, Token::Int(a), Token::Int(b)] => {
   -1   128                     new.push(Token::Int(a / b));
   -1   129                     i += 2;
   -1   130                     dirty = true;
   -1   131                 },
   -1   132                 [Token::Mod, Token::Int(a), Token::Int(b)] => {
   -1   133                     new.push(Token::Int(a % b));
   -1   134                     i += 2;
   -1   135                     dirty = true;
   -1   136                 },
   -1   137                 [Token::Eql, Token::Int(a), Token::Int(b)] => {
   -1   138                     new.push(Token::Int(if a == b {1} else {0}));
   -1   139                     i += 2;
   -1   140                     dirty = true;
   -1   141                 },
   -1   142                 _ => new.push(stack[i]),
   -1   143             }
   -1   144             i += 1;
   -1   145         }
   -1   146         while i < stack.len() {
   -1   147             new.push(stack[i]);
   -1   148             i += 1;
   -1   149         }
   -1   150         stack = new;
   -1   151     }
   -1   152     return stack;
   21   153 }
   22   154 
   23   155 fn main() {
@@ -69,6 +201,12 @@ fn main() {
   69   201             },
   70   202             _ => unreachable!(),
   71   203         }
   72    -1         println!("{} {:?}", i, stack);
   -1   204 
   -1   205         stack = optimize(stack);
   -1   206 
   -1   207         // println!("{} {:?}", i, stack);
   -1   208         println!("{}", i);
   -1   209         // print_formular(&mut stack.iter());
   -1   210         // println!("");
   73   211     }
   74   212 }