Toot

Rust

Pretty similar to the other rust answer. This definitely requires

spoilermemoization

of some form, but when done right, is very performant. 122ms for both.

mod tests {

use std::collections::HashMap;

fn count_solutions(

    design: &str,

    patterns: &[&str],

    seen_designs: &mut HashMap<String, i64>,

) -> i64 {

    if design.is_empty() {

        return 1;

    if let Some(s) = seen_designs.get(design) {

        return *s;

    let mut count = 0;

    for pattern in patterns {

        if design.starts_with(pattern) {

            count += count_solutions(&design[pattern.len()..], patterns, seen_designs);

    seen_designs.insert(design.to_string(), count);

    count

#[test]

fn day19_both_test() {

    let input = std::fs::read_to_string("src/input/day_19.txt").unwrap();

    let parts = input.split_once("\n\n").unwrap();

    let patterns = parts.0.split(", ").collect::<Vec<&str>>();

    let designs = parts.1.split('\n').collect::<Vec<&str>>();

    let mut count = 0;

    let mut total = 0;

    let mut seen_designs = HashMap::new();

    for design in designs {

        let shortlist = patterns

            .iter()

            .filter_map(|p| {

                if design.contains(p) {

                    return Some(*p);

                None

})

            .collect::<Vec<&str>>();

        let sol_count = count_solutions(design, &shortlist, &mut seen_designs);

        total += sol_count;

        count += (sol_count != 0) as usize;

    println!("{}", count);

    println!("{}", total);

}

Mentions