adventofcode

commit

61c9984bc92b31279ef8b1f891f205c579b7f29c

parent

f975cb42d3b3c86c9b38d1392279829210be58a5

Author

Tobias Bengfort <tobias.bengfort@posteo.de>

Date

2022-12-07 18:03

combine into a single file

Diffstat

12 files changed, 115 insertions, 188 deletions

diff --git a/2022/01/part1.rs b/2022/01/solution.rs

@@ -20,8 +20,8 @@ fn main() {
   20    20     v.sort();
   21    21 
   22    22     let last = v.last().unwrap();
   23    -1     print!("{}\n", last);
   -1    23     println!("part1: {}", last);
   24    24 
   25    25     let sum: i32 = v.iter().rev().take(3).sum();
   26    -1     print!("{}\n", sum);
   -1    26     println!("part2: {}", sum);
   27    27 }

diff --git a/2022/02/part2.rs b/2022/02/part2.rs

@@ -1,26 +0,0 @@
    1    -1 #[path = "../lib.rs"] mod lib;
    2    -1 
    3    -1 fn main() {
    4    -1     let mut score = 0;
    5    -1 
    6    -1     for line in lib::iter_input() {
    7    -1         let opponent = match line.chars().nth(0) {
    8    -1             Some('A') => 0,
    9    -1             Some('B') => 1,
   10    -1             Some('C') => 2,
   11    -1             _ => unreachable!(),
   12    -1         };
   13    -1         let match_score = match line.chars().nth(2) {
   14    -1             Some('X') => 0,
   15    -1             Some('Y') => 1,
   16    -1             Some('Z') => 2,
   17    -1             _ => unreachable!(),
   18    -1         };
   19    -1 
   20    -1         let own = (2 + match_score + opponent) % 3;
   21    -1 
   22    -1         score += (own + 1) + (match_score * 3);
   23    -1     }
   24    -1 
   25    -1     println!("{}", score);
   26    -1 }

diff --git a/2022/02/part1.rs b/2022/02/solution.rs

@@ -1,26 +1,50 @@
    1     1 #[path = "../lib.rs"] mod lib;
    2     2 
    3    -1 fn main() {
   -1     3 fn parse_abc(c: Option<char>) -> u64 {
   -1     4     return match c {
   -1     5         Some('A') => 0,
   -1     6         Some('B') => 1,
   -1     7         Some('C') => 2,
   -1     8         _ => unreachable!(),
   -1     9     };
   -1    10 }
   -1    11 
   -1    12 fn parse_xyz(c: Option<char>) -> u64 {
   -1    13     return match c {
   -1    14         Some('X') => 0,
   -1    15         Some('Y') => 1,
   -1    16         Some('Z') => 2,
   -1    17         _ => unreachable!(),
   -1    18     };
   -1    19 }
   -1    20 
   -1    21 fn part1() -> u64 {
    4    22     let mut score = 0;
    5    23 
    6    24     for line in lib::iter_input() {
    7    -1         let opponent = match line.chars().nth(0) {
    8    -1             Some('A') => 0,
    9    -1             Some('B') => 1,
   10    -1             Some('C') => 2,
   11    -1             _ => unreachable!(),
   12    -1         };
   13    -1         let own = match line.chars().nth(2) {
   14    -1             Some('X') => 0,
   15    -1             Some('Y') => 1,
   16    -1             Some('Z') => 2,
   17    -1             _ => unreachable!(),
   18    -1         };
   19    -1 
   -1    25         let opponent = parse_abc(line.chars().nth(0));
   -1    26         let own = parse_xyz(line.chars().nth(2));
   20    27         let match_score = (4 + own - opponent) % 3;
   -1    28         score += (own + 1) + (match_score * 3);
   -1    29     }
   21    30 
   -1    31     return score;
   -1    32 }
   -1    33 
   -1    34 fn part2() -> u64 {
   -1    35     let mut score = 0;
   -1    36 
   -1    37     for line in lib::iter_input() {
   -1    38         let opponent = parse_abc(line.chars().nth(0));
   -1    39         let match_score = parse_xyz(line.chars().nth(2));
   -1    40         let own = (2 + match_score + opponent) % 3;
   22    41         score += (own + 1) + (match_score * 3);
   23    42     }
   24    43 
   25    -1     println!("{}", score);
   -1    44     return score;
   -1    45 }
   -1    46 
   -1    47 fn main() {
   -1    48     println!("part1: {}", part1());
   -1    49     println!("part2: {}", part2());
   26    50 }

diff --git a/2022/03/part1.rs b/2022/03/part1.rs

@@ -1,31 +0,0 @@
    1    -1 #[path = "../lib.rs"] mod lib;
    2    -1 
    3    -1 fn intersect(vec: Vec<String>) -> Option<u8> {
    4    -1     let base = vec.get(0)?;
    5    -1     for c in base.chars() {
    6    -1         if vec[1..].iter().all(|s| s.contains(c)) {
    7    -1             return Some(c as u8);
    8    -1         }
    9    -1     }
   10    -1     return None;
   11    -1 }
   12    -1 
   13    -1 fn byte_to_priority(byte: u8) -> u8 {
   14    -1     if byte >= b'a' {
   15    -1         return byte - b'a' + 1;
   16    -1     } else {
   17    -1         return byte - b'A' + 27;
   18    -1     }
   19    -1 }
   20    -1 
   21    -1 fn main() {
   22    -1     let mut score: u32 = 0;
   23    -1 
   24    -1     for line in lib::iter_input() {
   25    -1         let (head, tail) = line.split_at(line.len() / 2);
   26    -1         let common = intersect(vec![head, tail]).unwrap();
   27    -1         score += byte_to_priority(common) as u32;
   28    -1     }
   29    -1 
   30    -1     println!("{}", score);
   31    -1 }

diff --git a/2022/03/part2.rs b/2022/03/solution.rs

@@ -18,18 +18,36 @@ fn byte_to_priority(byte: u8) -> u8 {
   18    18     }
   19    19 }
   20    20 
   21    -1 fn main() {
   22    -1     let mut score: u32 = 0;
   -1    21 fn part1() -> u64 {
   -1    22     let mut score = 0;
   -1    23 
   -1    24     for line in lib::iter_input() {
   -1    25         let (head, tail) = line.split_at(line.len() / 2);
   -1    26         let vec = vec![head.to_string(), tail.to_string()];
   -1    27         let common = intersect(vec).unwrap();
   -1    28         score += byte_to_priority(common) as u64;
   -1    29     }
   -1    30 
   -1    31     return score;
   -1    32 }
   -1    33 
   -1    34 fn part2() -> u64 {
   -1    35     let mut score: u64 = 0;
   23    36     let mut vec = vec![];
   24    37 
   25    38     for line in lib::iter_input() {
   26    39         vec.push(line);
   27    40         if vec.len() == 3 {
   28    41             let common = intersect(vec).unwrap();
   29    -1             score += byte_to_priority(common) as u32;
   -1    42             score += byte_to_priority(common) as u64;
   30    43             vec = vec![];
   31    44         }
   32    45     }
   33    46 
   34    -1     println!("{}", score);
   -1    47     return score;
   -1    48 }
   -1    49 
   -1    50 fn main() {
   -1    51     println!("part1: {}", part1());
   -1    52     println!("part2: {}", part2());
   35    53 }

diff --git a/2022/04/part2.rs b/2022/04/part2.rs

@@ -1,31 +0,0 @@
    1    -1 #[path = "../lib.rs"] mod lib;
    2    -1 
    3    -1 fn split_once(s: &str, sep: char) -> Option<(&str, &str)> {
    4    -1     let x = s.find(sep)?;
    5    -1     return Some((&s[..x], &s[x+1..]));
    6    -1 }
    7    -1 
    8    -1 fn parse(line: String) -> Option<(u8, u8, u8, u8)> {
    9    -1     let (a, b) = split_once(&line, ',')?;
   10    -1     let (a1, a2) = split_once(a, '-')?;
   11    -1     let (b1, b2) = split_once(b, '-')?;
   12    -1     return Some((
   13    -1         a1.parse::<u8>().ok()?,
   14    -1         a2.parse::<u8>().ok()?,
   15    -1         b1.parse::<u8>().ok()?,
   16    -1         b2.parse::<u8>().ok()?,
   17    -1     ));
   18    -1 }
   19    -1 
   20    -1 fn main() {
   21    -1     let mut count = 0;
   22    -1 
   23    -1     for line in lib::iter_input() {
   24    -1         let (a1, a2, b1, b2) = parse(line).unwrap();
   25    -1         if a1 <= b2 && a2 >= b1 {
   26    -1             count += 1;
   27    -1         }
   28    -1     }
   29    -1 
   30    -1     println!("{}", count);
   31    -1 }

diff --git a/2022/04/part1.rs b/2022/04/solution.rs

@@ -17,7 +17,7 @@ fn parse(line: String) -> Option<(u8, u8, u8, u8)> {
   17    17     ));
   18    18 }
   19    19 
   20    -1 fn main() {
   -1    20 fn part1() -> u64 {
   21    21     let mut count = 0;
   22    22 
   23    23     for line in lib::iter_input() {
@@ -27,5 +27,23 @@ fn main() {
   27    27         }
   28    28     }
   29    29 
   30    -1     println!("{}", count);
   -1    30     return count;
   -1    31 }
   -1    32 
   -1    33 fn part2() -> u64 {
   -1    34     let mut count = 0;
   -1    35 
   -1    36     for line in lib::iter_input() {
   -1    37         let (a1, a2, b1, b2) = parse(line).unwrap();
   -1    38         if a1 <= b2 && a2 >= b1 {
   -1    39             count += 1;
   -1    40         }
   -1    41     }
   -1    42 
   -1    43     return count;
   -1    44 }
   -1    45 
   -1    46 fn main() {
   -1    47     println!("part1: {}", part1());
   -1    48     println!("part2: {}", part2());
   31    49 }

diff --git a/2022/05/part1.rs b/2022/05/part1.rs

@@ -1,43 +0,0 @@
    1    -1 #[path = "../lib.rs"] mod lib;
    2    -1 
    3    -1 fn get_int(line: &str, i: usize) -> Option<usize> {
    4    -1     let s = line.split(' ').nth(i)?;
    5    -1     return s.parse::<usize>().ok();
    6    -1 }
    7    -1 
    8    -1 fn main() {
    9    -1     let mut stacks: Vec<Vec<char>> = vec![];
   10    -1     let mut init = false;
   11    -1 
   12    -1     for line in lib::iter_input() {
   13    -1         if !init {
   14    -1             if line.len() == 0 {
   15    -1                 init = true;
   16    -1             } else {
   17    -1                 while stacks.len() * 4 < line.len() + 1 {
   18    -1                     stacks.push(vec![]);
   19    -1                 }
   20    -1                 for i in 0..stacks.len() {
   21    -1                     let c = line.chars().nth(i * 4 + 1).unwrap();
   22    -1                     if c != ' ' {
   23    -1                         stacks[i].insert(0, c);
   24    -1                     }
   25    -1                 }
   26    -1             }
   27    -1         } else {
   28    -1             let k = get_int(&line, 1).unwrap();
   29    -1             let a = get_int(&line, 3).unwrap();
   30    -1             let b = get_int(&line, 5).unwrap();
   31    -1 
   32    -1             for _ in 0..k {
   33    -1                 let c = stacks[a - 1].pop().unwrap();
   34    -1                 stacks[b - 1].push(c);
   35    -1             }
   36    -1         }
   37    -1     }
   38    -1 
   39    -1     for stack in stacks {
   40    -1         print!("{}", stack.last().unwrap());
   41    -1     }
   42    -1     print!("\n");
   43    -1 }

diff --git a/2022/05/part2.rs b/2022/05/solution.rs

@@ -5,9 +5,8 @@ fn get_int(line: &str, i: usize) -> Option<usize> {
    5     5     return s.parse::<usize>().ok();
    6     6 }
    7     7 
    8    -1 fn main() {
   -1     8 fn run(label: &str, reverse: bool) {
    9     9     let mut stacks: Vec<Vec<char>> = vec![];
   10    -1     let mut tmp = vec![];
   11    10     let mut init = false;
   12    11 
   13    12     for line in lib::iter_input() {
@@ -30,20 +29,35 @@ fn main() {
   30    29             let a = get_int(&line, 3).unwrap();
   31    30             let b = get_int(&line, 5).unwrap();
   32    31 
   33    -1             for _ in 0..k {
   34    -1                 let c = stacks[a - 1].pop().unwrap();
   35    -1                 tmp.push(c);
   36    -1             }
   -1    32             if reverse {
   -1    33                 for _ in 0..k {
   -1    34                     let c = stacks[a - 1].pop().unwrap();
   -1    35                     stacks[b - 1].push(c);
   -1    36                 }
   -1    37             } else {
   -1    38                 let mut tmp = vec![];
   -1    39 
   -1    40                 for _ in 0..k {
   -1    41                     let c = stacks[a - 1].pop().unwrap();
   -1    42                     tmp.push(c);
   -1    43                 }
   37    44 
   38    -1             while tmp.len() > 0 {
   39    -1                 let c = tmp.pop().unwrap();
   40    -1                 stacks[b - 1].push(c);
   -1    45                 while tmp.len() > 0 {
   -1    46                     let c = tmp.pop().unwrap();
   -1    47                     stacks[b - 1].push(c);
   -1    48                 }
   41    49             }
   42    50         }
   43    51     }
   44    52 
   -1    53     print!("{}: ", label);
   45    54     for stack in stacks {
   46    55         print!("{}", stack.last().unwrap());
   47    56     }
   48    57     print!("\n");
   49    58 }
   -1    59 
   -1    60 fn main() {
   -1    61     run("part1", true);
   -1    62     run("part2", false);
   -1    63 }

diff --git a/2022/06/part2.rs b/2022/06/part2.rs

@@ -1,21 +0,0 @@
    1    -1 #[path = "../lib.rs"] mod lib;
    2    -1 
    3    -1 fn get_start(chars: &Vec<char>, len: usize) -> Option<usize> {
    4    -1     for i in 0..chars.len() {
    5    -1         let max = chars.len().min(i + len);
    6    -1         let has_repeats = (i..max).any(|a| {
    7    -1             return ((a + 1)..max).any(|b| chars[a] == chars[b]);
    8    -1         });
    9    -1         if !has_repeats {
   10    -1             return Some(i + len);
   11    -1         }
   12    -1     }
   13    -1     return None
   14    -1 }
   15    -1 
   16    -1 fn main() {
   17    -1     for line in lib::iter_input() {
   18    -1         let chars = line.chars().collect();
   19    -1         println!("{}", get_start(&chars, 14).unwrap());
   20    -1     }
   21    -1 }

diff --git a/2022/06/part1.rs b/2022/06/solution.rs

@@ -13,9 +13,14 @@ fn get_start(chars: &Vec<char>, len: usize) -> Option<usize> {
   13    13     return None
   14    14 }
   15    15 
   16    -1 fn main() {
   -1    16 fn run(label: &str, len: usize) {
   17    17     for line in lib::iter_input() {
   18    18         let chars = line.chars().collect();
   19    -1         println!("{}", get_start(&chars, 4).unwrap());
   -1    19         println!("{}: {}", label, get_start(&chars, len).unwrap());
   20    20     }
   21    21 }
   -1    22 
   -1    23 fn main() {
   -1    24     run("part1", 4);
   -1    25     run("part1", 14);
   -1    26 }

diff --git a/2022/07/part1.rs b/2022/07/solution.rs

@@ -32,6 +32,6 @@ fn main() {
   32    32 
   33    33     let free = 70000000 - dirs[""];
   34    34 
   35    -1     println!("{}", dirs.values().filter(|x| **x <= 100000).sum::<u64>());
   36    -1     println!("{}", dirs.values().filter(|x| free + **x >= 30000000).min().unwrap());
   -1    35     println!("part1: {}", dirs.values().filter(|x| **x <= 100000).sum::<u64>());
   -1    36     println!("part2: {}", dirs.values().filter(|x| free + **x >= 30000000).min().unwrap());
   37    37 }