Day 8: Resonant Collinearity

Megathread guidelines

  • Keep top level comments as only solutions, if you want to say something other than a solution put it in a new post. (replies to comments can be whatever)
  • You can send code in code blocks by using three backticks, the code, and then three backticks or use something such as https://topaz.github.io/paste/ if you prefer sending it through a URL

FAQ

  • KatzenmannEnglish
    1·
    14 days ago

    Rust

    Pretty happy with my solution today. I took my time today as it was a bit of a slow day and did it in Rust instead of python. Having proper Vec2 types is very nice.

    Tap for spoiler 
    use std::{collections::HashMap, error::Error, io::Read};

use glam::{IVec2, Vec2};

fn permutations_of_size_two(antennas: &[Vec2]) -> Vec<[&Vec2; 2]> {
    let mut permutations = vec![];
    for (i, antenna) in antennas.iter().enumerate() {
        for j in 0..antennas.len() {
            if i == j {
                continue;
            }
            permutations.push([antenna, &antennas[j]])
        }
    }
    permutations
}

fn main() -> Result<(), Box<dyn Error>> {
    let mut input = String::new();
    std::io::stdin().read_to_string(&mut input)?;

    let height = input.lines().count() as i32;
    let width = input.lines().next().unwrap().len() as i32;

    let antenna_positions = input
        .lines()
        .enumerate()
        .flat_map(|(y, l)| 
            l.chars().enumerate().map(move |(x, c)| (Vec2::new(x as f32, y as f32), c))
        )
        .filter(|(_v, c)| *c != '.')
        .fold(HashMap::new(), |mut acc: HashMap<char, Vec<_>> , current| {
            acc.entry(current.1).or_default().push(current.0);
            acc
        });

    let mut antinodes = vec![];
    for (_c, antennas) in antenna_positions {
        let perms = permutations_of_size_two(&antennas);
        for [first, second] in perms {
            let mut i = 1.;
            loop {
                let antinode = (first + (second-first) * i).round();
                if (0..height).contains(&(antinode.x as i32)) &&
                    (0..width).contains(&(antinode.y as i32)) {
                        antinodes.push(antinode);
                } else {
                    break;
                }
                i += 1.;
            }
        }
    }

    let mut antinode_count = 0;
    let map = input
        .lines()
        .enumerate()
        .map(|(y, l)| 
            l.chars().enumerate().map(|(x, c)| {
                if antinodes.contains(&Vec2::new(x as f32, y as f32)) {
                    println!("({x},{y})");
                    antinode_count += 1;
                    return '#';
                }
                c
            }).collect::<String>()
        )
        .collect::<Vec<_>>()
        .join("\n");

    println!("{map}");
    println!("{antinode_count}");

    Ok(())
}