Day 11: Cosmic Expansion

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)
  • Code block support is not fully rolled out yet but likely will be in the middle of the event. Try to share solutions as both code blocks and using something such as https://topaz.github.io/paste/ , pastebin, or github (code blocks to future proof it for when 0.19 comes out and since code blocks currently function in some apps and some instances as well if they are running a 0.19 beta)

FAQ

🔒 Thread is locked until there’s at least 100 2 star entries on the global leaderboard

🔓 Unlocked after 9 mins

  •  abclop99   ( @abclop99@beehaw.org ) 
    1•7 months ago
    Rust 
    use std::fs;
use std::path::PathBuf;

use clap::Parser;

use itertools::Itertools;
use std::ops::Range;

#[derive(Parser)]
#[command(author, version, about, long_about = None)]
struct Cli {
    input_file: PathBuf,
}

fn main() {
    // Parse CLI arguments
    let cli = Cli::parse();

    // Read file
    let input_text = fs::read_to_string(&cli.input_file)
        .expect(format!("File \"{}\" not found", cli.input_file.display()).as_str());

    let map: Vec> = input_text.lines().map(|r| r.chars().collect()).collect();

    let mut expanding_rows = vec![];
    // Expand rows
    map.iter().enumerate().for_each(|(row_num, r)| {
        if r.iter().filter(|c| **c == '.').count() == r.len() {
            expanding_rows.push(row_num);
        }
    });

    let mut expanding_cols = vec![];

    // Find expanding cols
    for col in 0..map[0].len() {
        // Determine if all '.'
        let expand = map.iter().filter(|row| row[col] == '.').count() == map.len();

        if expand {
            expanding_cols.push(col);
        }
    }

    // Find galaxies
    let mut galaxies: Vec<(usize, usize)> = vec![];
    for (row_num, row) in map.iter().enumerate() {
        for (col_num, char) in row.iter().enumerate() {
            if *char == '#' {
                galaxies.push((row_num.try_into().unwrap(), col_num.try_into().unwrap()));
            }
        }
    }

    println!("Num Galaxies: ({})", galaxies.len());

    println!(
        "Expanding rows: {:?}\tExpanding cols: {:?}",
        expanding_rows, expanding_cols
    );

    // Distance between each pair
    let expansion_1 = 2;
    let expansion_2 = 1_000_000;
    let mut sum_distances_1 = 0;
    let mut sum_distances_2 = 0;
    println!(
        "Total combinations: {}",
        galaxies.iter().tuple_combinations::<(_, _)>().count()
    );
    for (g1, g2) in galaxies.iter().tuple_combinations() {
        let vert_range: Range = if g1.0 < g2.0 {
            (g1.0)..(g2.0)
        } else {
            (g2.0)..(g1.0)
        };
        let horr_range: Range = if g1.1 < g2.1 {
            (g1.1)..(g2.1)
        } else {
            (g2.1)..(g1.1)
        };

        let vert_expansions = expanding_rows
            .iter()
            .filter(|r| vert_range.contains(*r))
            .count();
        let horr_expansions = expanding_cols
            .iter()
            .filter(|r| horr_range.contains(*r))
            .count();
        let expansions = vert_expansions + horr_expansions;

        let distance = vert_range.len() + horr_range.len();

        sum_distances_1 += distance + (expansions * (expansion_1 - 1));
        sum_distances_2 += distance + (expansions * (expansion_2 - 1));
    }

    println!("Total distance: {}", sum_distances_1);
    println!("Part 2 distance: {}", sum_distances_2);
}