As a former Morris dancer, I would absolutely attend a festival where the headliner is a Morris side.

I got it out today, and ended up doing essentially this. Was a pain, but I’m very happy now.

Well, I kept at it, ans got it out today! 🎉

I was able to use a screwdriver to get a grip and twist out the part that was stuck, and then use my electronics pliers to get the plastic ring out.

Yes, this is a rental flat, but we will never buy such a faucet for ourselves. Massive pain.

I did that and broke off another piece, but I’m having trouble getting that piece out now. We’re getting ever closer to calling a plumber :).

It might be lime or calcium. The German word is Kalk, but it’s basically the hard water, as you say. Yes, we were doing exactly that (the water is very hard here), and tried to remove the aerator in order to clean that too, which we hadn’t done before, and that’s how it all broke.

I’ve now made progress in breaking off another piece, but we’re getting closer to just calling a plumber.

I just started Cult of the Lamb. I’ve tried so many roguelikes and struggled to enjoy them, but this one hits right. It’s not too too hard, and I like the style a lot.

I’ve beaten the first two bishops already, and am working my way towards the third.

I’m a huge fan of soda bread, which does not require sourdough (or yeast). You can go from “I have no bread” to “I am eating bread” in about 40 minutes.

The rising is done via buttermilk and baking soda.

Schau bitte dieses schöne Exemplar an

I’ve been using it for years, but I agree that it’s almost too configurable. Start small, and don’t ezplore the menus too deep :).

Honest question: how were race horses transported in the past? I assume you wouldn’t want them pulling a coach, even if they could, and riding them to a race could tire them out or risk injury?

Are there old “horse trailers” that would be pulled by coach horses?

I purchased my current phone (Fairphone 4) in January 2022. And that was because my last phone’s battery was dying, and the screen was very cracked.

I decided for a Fairphone because you can easily replace the battery (already done once) and the screen (not yet broken).

As of now, I still have no plans to buy a new phone.

I really enjoyed The Will of the Many, but it was mostly because of thr world and thr mysteries, I think. I agree that the YA-y relationship stuff was less my thing, but it didn’t bother me too much.

I binged the whole Gideon series when I was sick once. I found it enjoyable to read, but I agree that I do not get the hype around it.

I’m re-reading Eines Menschen Flügel by Andreas Eschbach. It’s about a society started by refugees from a far future civilization, and because touching the ground is deadly, modified their children to have wings.

I re-read the book every few years, because it describes essentially a utopian society and I find it very inspiring, while also just being interesting.

I remember renting Surf Ninjas on VHS back in the day. I would prefer not to think about how long ago that must be now.

Meat. I’m vegetarian, my wife is not. When we go out to eat, if she orders meat, there’s a good chance the meat dish will get put in front of me.

We were at a Christmas market on the weekend, and one booth had a sign that said “Make your husband happy”, and it was of course a butcher stand.

I believe learning languages is generally a net good. But to answer your question, it would help to know: why do you want to learn Russian?

If you just find the idea of the language interesting, then yes! Start leaning it. If you have motivation, that will help.

Is there specific media you’re looking to consume in its original language, Russian? Then yes, absolutely :).

Are you just trying to learn “any Slavic language”, to extend the language families you have knowledge of? You already have some Polish, so what is it about Russian that attracts you? Is there another language that might have more resonance or utility for you?

As far as I am aware, mostly sue to Soviet influence, Russian is probably the most-widely-understood Slavic language, so this does offer some advantages. I have spoken with Ukranians and Georgians who now don’t like speaking Russian, for obvious reasons, though I don’t know how widespread this feeling really is. And at least here in Germany, I feel like Croatian, Czech, or Slovakian would be a more useful day-to-day or holiday language, but itball depends on your goals.

And, as a dentist once told me in regards to dental floss, but it applies here too: The best language to learn is the one that you will actually learn. If there’s a language you’ll actually stick with, that’s good.

For anyone curious: after a lot of research and then failing to find hearts of palm in any supermarkets, I ended up going for vegan crab cakes with jackfruit. At the end of the day, they didn’t taste a huge amount like crab, but with lemon juice, dill, and nori, they evoked vague impressions of seafood, I think. And everyone had seconds or thirds, so they seemed to taste good enough, even for the non-vegetarians :).

I used essentially this recipe, but with jackfruit instead of hearts of palm, and with far more nori: https://www.veganfoodandliving.com/vegan-recipes/vegan-crab-cakes/

Thank you for the ideas!

I always have this thought. I’m doing it in Rust, so I check if there are negative numbers: if not, use usize. But I’m always terrified there will be an overflow somewhere.

If I were using Kotlin or Java, I might always use BigInteger just out of fear.

Rust

Part 1 was very straight forward. I overcomplicated it a bit by using an actual graph library, but I’m used to using it.

I originally tried to brute force Part 2, which of course failed. I then reverted to dynamic programming, which worked well.

use std::collections::{HashMap, VecDeque};

use graphrs::{Graph, GraphSpecs};

use crate::solver::DaySolver;

pub struct Day11Solver;

impl DaySolver for Day11Solver {
    fn part1(&self, input: String) -> String {
        let mut graph: Graph<String, ()> = Graph::new(GraphSpecs::directed_create_missing());
        let edges = input.lines()
            .flat_map(|line| {
                let (start, end_str) = line.split_once(": ").unwrap();
                end_str.split_whitespace()
                    .map(|end| (start.to_string(), end.to_string()))
            })
            .collect();
        graph.add_edge_tuples(edges).unwrap();

        let mut frontier = VecDeque::from([vec!["you".to_string()]]);

        let mut path_count = 0;

        while let Some(path) = frontier.pop_front() {
            let last = path.last().unwrap();

            if last == "out" {
                path_count += 1;
            } else {
                graph
                    .get_successor_node_names(last.to_string())
                    .unwrap()
                    .into_iter()
                    .filter(|next| !path.contains(next))
                    .map(|next| {
                        let mut new_path = path.clone();
                        new_path.push(next.clone());
                        new_path
                    })
                    .for_each(|new_path| frontier.push_back(new_path));
            }
        }

        path_count.to_string()
    }

    fn part2(&self, input: String) -> String {
        let mut graph: Graph<String, ()> = Graph::new(GraphSpecs::directed_create_missing());
        let edges = input.lines()
            .flat_map(|line| {
                let (start, end_str) = line.split_once(": ").unwrap();
                end_str.split_whitespace()
                    .map(|end| (start.to_string(), end.to_string()))
            })
            .collect();
        graph.add_edge_tuples(edges).unwrap();

        how_many_paths(
            &mut HashMap::new(),
            &graph,
            ("svr".to_string(), false, false),
        )
            .to_string()

    }
}

fn how_many_paths(
    cache: &mut HashMap<(String, bool, bool), usize>,
    graph: &Graph<String, ()>,
    current: (String, bool, bool),
) -> usize {
    if let Some(&c) = cache.get(&current) {
        c
    } else {
        let (node, has_dac, has_fft) = &current;
        if node == "out" {
            let count = if *has_dac && *has_fft { 1 } else { 0 };
            cache.insert(current, count);
            count
        } else {
            let count = graph
                .get_successor_node_names(node.clone())
                .unwrap()
                .into_iter()
                .map(|next| {
                    let next_state = (next.to_string(), *has_dac || next == "dac", *has_fft || next == "fft");
                    how_many_paths(cache, graph, next_state)
                })
                .sum();
            cache.insert(current, count);
            count
        }
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn part1() {
        let input = include_str!("../../inputs/test/11");

        let solver = Day11Solver {};
        assert_eq!("5", solver.part1(input.to_string()));
    }

    #[test]
    fn part2() {
        let input = include_str!("../../inputs/test/11-2");

        let solver = Day11Solver {};
        assert_eq!("2", solver.part2(input.to_string()));
    }
}