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()));
    }
}

I’ve never heard of dulse before, but just looked it up. Certainly sounds interesting. What do you usually make with it? Or just add it to a soup?

I’m also not sure where I would buy that, but maybe some of the organic markets around here have some.

I’ve never made a vegan dashi, but that certainly sounds like an option, and relatively straightforward. I’m then thinking what I could make with it…when I think of a fishy dashi, I’d likely end up with some sort of noodle soup. Any other thoughts?

Rust

Part 1 was quite straightforward: just keep track of a frontier of every beam, and keep following it, adding splitter locations to a set. Easy.

I had to give some thought to Part 2 and ended up doing dynamic programming: for every position, keep track of how many timelines go through it, solving recursively where necesary.

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

use crate::{grid::{Coordinate, Direction, Grid}, solver::DaySolver};

pub struct Day07Solver;

impl DaySolver for Day07Solver {
    fn part1(&self, input: String) -> String {
        let grid = Grid::from_grid_string(
            &input,
            |c| match c {
                'S' => Location::Start,
                '^' => Location::Splitter,
                '.' => Location::Empty,
                _ => panic!("Invalid location type"),
            }
        );

        let mut reached_splitters: HashSet<Coordinate> = HashSet::new();

        let mut beam_coordinates: VecDeque<Coordinate> = grid.iter()
            .filter_map(|(c, l)| match l {
                Location::Start => Some(c),
                _ => None,
            })
            .collect();

        while let Some(next) = beam_coordinates.pop_front() {
            if let Some(next_coord) = grid.neighbor_in_direction(next, Direction::Down) {
                match grid[next_coord] {
                    Location::Start => { panic!("Encountered a second start!"); },
                    Location::Splitter => {
                        if !reached_splitters.contains(&next_coord) {
                            reached_splitters.insert(next_coord);
                            [
                                grid.neighbor_in_direction(next_coord, Direction::Left),
                                grid.neighbor_in_direction(next_coord, Direction::Right),
                            ]
                                .into_iter()
                                .flatten()
                                .for_each(|c| beam_coordinates.push_back(c));
                        }
                    },
                    Location::Empty => { beam_coordinates.push_back(next_coord); }
                }
            }
        }

        reached_splitters
            .len()
            .to_string()
    }

    fn part2(&self, input: String) -> String {
        let grid = Grid::from_grid_string(
            &input,
            |c| match c {
                'S' => Location::Start,
                '^' => Location::Splitter,
                '.' => Location::Empty,
                _ => panic!("Invalid location type"),
            }
        );

        let start_coord = grid.iter().find(|(_, l)| **l == Location::Start).unwrap().0;

        let mut num_timelines: HashMap<Coordinate, usize> = HashMap::new();
        count_timelines(&mut num_timelines, &grid, 1, start_coord);

        num_timelines[&start_coord].to_string()
    }
}

fn count_timelines(
    num_timelines: &mut HashMap<Coordinate, usize>,
    grid: &Grid<Location>,
    timelines_so_far: usize,
    coordinate: Coordinate,
) {
    if num_timelines.contains_key(&coordinate) {
        return
    }

    match grid[coordinate] {
        Location::Splitter => {
            let neighbors: Vec<Coordinate> = [
                grid.neighbor_in_direction(coordinate, Direction::Left),
                grid.neighbor_in_direction(coordinate, Direction::Right),
            ]
                .into_iter()
                .flatten()
                .collect();

            neighbors.iter()
                .for_each(|next| {
                    count_timelines(num_timelines, grid, timelines_so_far, *next);
                });

            let timelines_from_here = neighbors.iter().map(|c| num_timelines[c]).sum();
            num_timelines.insert(coordinate, timelines_from_here);
        },
        _ => {
            let timelines_from_here = if let Some(next) = grid.neighbor_in_direction(coordinate, Direction::Down) {
                count_timelines(num_timelines, grid, timelines_so_far, next);
                num_timelines[&next]
            } else {
                timelines_so_far
            };

            num_timelines.insert(coordinate, timelines_from_here);
        },
    };
}

#[derive(PartialEq, Eq, Copy, Clone)]
enum Location {
    Start,
    Splitter,
    Empty,
}

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

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

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


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

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

I absolutely love these sorts of things :).

I assume we are all familiar with User Inyerface? https://userinyerface.com/

Hrm, I wasn’t aware of that difference. In Germany, the “fastest” roads are called “Autobahn”, and they have no speed limit by default, and have no traffic lights. The next level down are called “Bundesstraße”: they have a default speed limit of 100 km/h, and sometimes run through towns (lower speed limit), and sometimes have only one lane in each direction.

I love explaining the Autobahn to my foreign friends. “It’s just the word for highway”. “All highways are called autobahns”. “Yes, sometimes there is a speed limit”. “Even where there’s no speed limit, we won’t be driving that fast”.

Cool that you’re trying something new out! I also often find prefix arguments a bit unintuitive in my flow.

First of all, you’re right that you could do (eat nil 4) to simulate the prefix argument. I do this in a number of my helpers.

For my advice on your code, I think it would be easier to understand if you used a let* block to assign meaningful variable names. I’m writing this from my phone, so it’s hard to give a detailed example, but:

(let* ((eat-buffers (match-buffers "\*eat\*"))
       (last-buffer (last (sort eat-buffers))))
 ;; Body
)

And so on. This would let you reuse some values, and would also reduce the amount of nesting in your code.

Edit: Missed a few parentheses, fixing syntax highlighting