Add day 20

Author: LiquidFun

2020/20/20.rs

@@ -53,19 +53,15 @@ impl Tile {
 fn solve(corner: &Tile, all_tiles: &Vec<Tile>) -> usize {
     let size = (0..).find(|i| i*i == all_tiles.len() / 8).unwrap();
 
-    let mut leftmost = corner.clone();
+    let mut leftmost = corner.rotated().rotated().flipped();
     let mut used = HashSet::new();
-
-    let mut field: Vec<Vec<char>> = Vec::new();
+    let mut field: Vec<String> = Vec::new();
 
     for y in 0..size {
-        let mut current = leftmost.clone();
-        if y != 0 {
-            current = all_tiles.iter().filter(|t| !used.contains(&t.id)).find(|tile| tile.top() == leftmost.bot()).unwrap().clone();
-        }
+        let mut current = all_tiles.iter().filter(|t| !used.contains(&t.id)).find(|tile| tile.top() == leftmost.bot()).unwrap().clone();
         leftmost = current.clone();
         used.insert(current.id);
-        current.inner().rows.iter().for_each(|n| field.push(format!("{n:08b}").chars().collect()));
+        current.inner().rows.iter().for_each(|n| field.push(format!("{n:08b}")));
         for _ in 1..size {
             current = all_tiles.iter().filter(|t| !used.contains(&t.id)).find(|tile| tile.left() == current.right()).unwrap().clone();
             used.insert(current.id);
@@ -75,12 +71,11 @@ fn solve(corner: &Tile, all_tiles: &Vec<Tile>) -> usize {
             }
         }
     }
-    let lines = field.iter().map(|vec| vec.iter().join("")).collect_vec();
     let dragon1 = Regex::new(r"..................1.").unwrap();
     let dragon2 = Regex::new(r"1....11....11....111").unwrap();
     let dragon3 = Regex::new(r".1..1..1..1..1..1...").unwrap();
     let mut dragons = 0;
-    for (a, b, c) in lines.iter().tuple_windows() {
+    for (a, b, c) in field.iter().tuple_windows() {
         for i in 0..a.len() {
             if dragon1.is_match(&a.chars().skip(i).take(20).join(""))
                 && dragon2.is_match(&b.chars().skip(i).take(20).join(""))
@@ -89,33 +84,31 @@ fn solve(corner: &Tile, all_tiles: &Vec<Tile>) -> usize {
             }
         }
     }
-    lines.join("").matches("1").count() - dragons
+    field.join("").matches("1").count() - dragons
 }
 
 fn main() {
     let input = stdin().lines().filter_map(Result::ok).join("\n").replace(".", "0").replace("#", "1");
     let blocks = input.split("\n\n").collect_vec();
 
-    let mut tiles = Vec::new();
+    let mut all_tiles = Vec::new();
     let mut edges: HashMap<usize, HashSet<usize>> = HashMap::new();
 
     for block in blocks {
         let num: usize = block.lines().next().unwrap().trim_matches(['T', 'i', 'l', 'e', ' ', ':']).parse().unwrap();
         let tile = Tile::new(num, block.lines().skip(1).collect());
-        tiles.push(tile.clone());
+        all_tiles.extend(tile.variations());
 
         for (edge, _) in tile.top_edges() {
             edges.entry(edge).or_insert_with(HashSet::new).insert(num);
         }
     }
 
-    let all_tiles = tiles.iter().flat_map(|tile| tile.variations()).collect_vec();
-
     let corners = all_tiles.iter()
         .filter(|t| edges.get(&t.top()).unwrap().len() == 1)
         .filter(|t| edges.get(&t.left()).unwrap().len() == 1)
         .collect_vec();
 
-    println!("{:?}", corners.iter().map(|tile| tile.id).unique().reduce(|acc, a| acc * a).unwrap());
-    println!("{:?}", corners.iter().map(|corner| solve(corner, &all_tiles)).min().unwrap());
+    println!("{}", corners.iter().map(|tile| tile.id).unique().reduce(|acc, a| acc * a).unwrap());
+    println!("{}", corners.iter().map(|corner| solve(corner, &all_tiles)).min().unwrap());
 }