koivunej

use std::{io::BufRead, ops::ControlFlow};

fn main() {
    let mut context = Context::default();

    let mut s = String::new();

    let mut input = std::io::stdin().lock();

    let mut nums = Vec::new();

koivunej

use std::{collections::HashMap, io::BufRead};

fn main() {
    let (instr, adjacent) = parse(std::io::stdin().lock());

    let phase1 = solve(&instr, &adjacent);

    let phase2 = solve_many(&instr, &adjacent);

    assert_eq!(phase1, 14429);

koivunej

use std::io::BufRead;

fn main() {
    let mut parsed = parse(std::io::stdin().lock());

    let phase1 = total_winnings(&mut parsed);

    assert_eq!(phase1, 250232501);

    let mut parsed = parsed

koivunej

fn main() {
    // Time:        56     71     79     99
    // Distance:   334   1135   1350   2430
    let input = [(56, 334), (71, 1135), (79, 1350), (99, 2430)];

    let phase1 = input
        .iter()
        .copied()
        .map(|(race_millis, minimum_distance)| {
            ways_to_win_with_immediate_accel(race_millis, minimum_distance)

koivunej

use std::{collections::BTreeMap, io::BufRead, ops::Range};

fn main() {
    let t = parse(std::io::stdin().lock());
    println!("{t:?}");

    assert_eq!(t.0, 218513636); // unsure how long, had to put the car warming up
    assert_ne!(t.1, 81956385, "high");
    assert_eq!(t.1, 81956384);
}

koivunej

use std::collections::HashMap;

fn main() {
    const INPUT: &str = include_str!("../input");
    let (parts, ratios) = find_parts(INPUT);

    let part1 = parts.iter().sum::<u64>();
    println!("{part1}");
    let part2 = ratios.iter().sum::<u64>();
    println!("{part2}");

koivunej

fn main() {
    let stdin = std::io::stdin();
    let stdin = stdin.lock();

    let mut phases = (Phase1::default(), Phase2::default());
    ingest(stdin, &mut phases);

    println!("{phases:?}");
}

koivunej

use std::{io::BufRead, ops::Range, str::FromStr};

use broilerplate::InputLines;
use spanstuff::{Spanned, SpannedErr};

fn main() {
    let stdin = std::io::stdin();
    let stdin = stdin.lock();

    let (sum_of_possible_game_ids, min_dices_power) = match solve(stdin, &[12, 13, 14]) {

koivunej

AsRef<V> trick with Arc<T>

Quick "blog post" or note mainly for future myself. I have often wanted to have "Arc projections," which would be like Arc<V> but holding up the same reference count as the original Arc<T>, like:

struct Shared {
  answer: u32
}

koivunej

Not sending this as a PR as I assume it's too dirty hack. data_types.rs used can be found at: https://github.com/tafia/quick-protobuf/blob/master/examples/codegen/data_types.rs

time rustfmt --write-mode=display data_types.rs >/dev/null timings:

rustfmt: installed with rustup run nightly cargo install rustfmt

real    1m14.506s
real    1m15.186s
real 1m14.968s