Uiua

This is the first one that caused me some headache because I didn't read the instructions carefully enough.
I kept trying to create a sorted list for when all available pages were used, which got me stuck in an endless loop.

Another fun part was figuring out to use memberof (∈) instead of find (⌕) in the last line of FindNext. So much time spent on debugging other areas of the code

Run with example input here

FindNext ← ⊙(
  ⊡1⍉,
  ⊃▽(▽¬)⊸∈
  ⊙⊙(⊡0⍉.)
  :⊙(⟜(▽¬∈))
)

# find the order of pages for a given set of rules
FindOrder ← (
  ◴♭.
  []
  ⍢(⊂FindNext|⋅(>1⧻))
  ⊙◌⊂
)

PartOne ← (
  &rs ∞ &fo "input-5.txt"
  ∩°□°⊟⊜□¬⌕"\n\n".
  ⊙(⊜(□⊜⋕≠@,.)≠@\n.↘1)
  ⊜(⊜⋕≠@|.)≠@\n.

  ⊙.
  ¤
  ⊞(◡(°□:)
    ⟜:⊙(°⊟⍉)
    =2+∩∈
    ▽
    FindOrder
    ⊸≍°□:
    ⊙◌
  )
  ≡◇(⊡⌊÷2⧻.)▽♭
  /+
)

PartTwo ← (
  &rs ∞ &fo "input-5.txt"
  ∩°□°⊟⊜□¬⌕"\n\n".
  ⊙(⊜(□⊜⋕≠@,.)≠@\n.↘1)
  ⊜(⊜⋕≠@|.)≠@\n.
  ⊙.
  ⍜¤⊞(
    ◡(°□:)
    ⟜:⊙(°⊟⍉)
    =2+∩∈
    ▽
    FindOrder
    ⊸≍°□:
    ⊟∩□
  )
  ⊙◌
  ⊃(⊡0)(⊡1)⍉
  ≡◇(⊡⌊÷2⧻.)▽¬≡°□
  /+
)

&p "Day 5:"
&pf "Part 1: "
&p PartOne
&pf "Part 2: "
&p PartTwo

I've got a "smart" solution and a really dumb one. I'll start with the smart one (incomplete but you can infer). I did four different ways to try to get it faster, less memory, etc.

// this is from a nuget package. My Mathy roommate told me this was a topological sort.
// It's also my preferred, since it'd perform better on larger data sets.
return lines
    .AsParallel()
    .Where(line => !IsInOrder(GetSoonestOccurrences(line), aggregateRules))
    .Sum(line => line.StableOrderTopologicallyBy(
            getDependencies: page =>
                aggregateRules.TryGetValue(page, out var mustPreceed) ? mustPreceed.Intersect(line) : Enumerable.Empty<Page>())
        .Middle()
    );

The dumb solution. These comparisons aren't fully transitive. I can't believe it works.

public static SortedSet<Page> Sort3(Page[] line,
    Dictionary<Page, System.Collections.Generic.HashSet<Page>> rules)
{
    // how the hell is this working?
    var sorted = new SortedSet<Page>(new Sort3Comparer(rules));
    foreach (var page in line)
        sorted.Add(page);
    return sorted;
}

public static Page[] OrderBy(Page[] line, Dictionary<Page, System.Collections.Generic.HashSet<Page>> rules)
{
    return line.OrderBy(identity, new Sort3Comparer(rules)).ToArray();
}

sealed class Sort3Comparer : IComparer<Page>
{
    private readonly Dictionary<Page, System.Collections.Generic.HashSet<Page>> _rules;

    public Sort3Comparer(Dictionary<Page, System.Collections.Generic.HashSet<Page>> rules) => _rules = rules;

    public int Compare(Page x, Page y)
    {
        if (_rules.TryGetValue(x, out var xrules))
        {
            if (xrules.Contains(y))
                return -1;
        }

        if (_rules.TryGetValue(y, out var yrules))
        {
            if (yrules.Contains(x))
                return 1;
        }

        return 0;
    }
}

Smalltalk

parsing logic is duplicated between the two, and I probably could use part2's logic for part 1, but yeah

part 1

day5p1: in
	| rules pages i j input |

	input := in lines.
	i := input indexOf: ''.
	rules := ((input copyFrom: 1 to: i-1) collect: [:l | (l splitOn: '|') collect: #asInteger]).
	pages := (input copyFrom: i+1 to: input size) collect: [:l | (l splitOn: ',') collect: #asInteger].
	
	^ pages sum: [ :p |
		(rules allSatisfy: [ :rule |
			i := p indexOf: (rule at: 1).
			j := p indexOf: (rule at: 2).
			(i ~= 0 & (j ~= 0)) ifTrue: [ i < j ] ifFalse: [ true ]
		])
			ifTrue: [p at: ((p size / 2) round: 0) ]
			ifFalse: [0].
	]

part 2

day5p2: in
	| rules pages i pnew input |

	input := in lines.
	i := input indexOf: ''.
	rules := ((input copyFrom: 1 to: i-1) collect: [:l | (l splitOn: '|') collect: #asInteger]).
	pages := (input copyFrom: i+1 to: input size) collect: [:l | (l splitOn: ',') collect: #asInteger].
	
	^ pages sum: [ :p |
		pnew := p sorted: [ :x :y | 
			rules anySatisfy: [ :r | (r at: 1) = x and: [ (r at: 2) = y]]
		].
		pnew ~= p
			ifTrue: [ pnew at: ((pnew size / 2) round: 0) ]
			ifFalse: [0].
	]

Rust

Kinda sorta got day 5 done on time.

use std::cmp::Ordering;

use crate::utils::{bytes_to_num, read_lines};

pub fn solution1() {
    let mut lines = read_input();
    let rules = parse_rules(&mut lines);

    let middle_rules_sum = lines
        .filter_map(|line| {
            let line_nums = rule_line_to_list(&line);
            line_nums
                .is_sorted_by(|&a, &b| is_sorted(&rules, (a, b)))
                .then_some(line_nums[line_nums.len() / 2])
        })
        .sum::<usize>();

    println!("Sum of in-order middle rules = {middle_rules_sum}");
}

pub fn solution2() {
    let mut lines = read_input();
    let rules = parse_rules(&mut lines);

    let middle_rules_sum = lines
        .filter_map(|line| {
            let mut line_nums = rule_line_to_list(&line);

            (!line_nums.is_sorted_by(|&a, &b| is_sorted(&rules, (a, b)))).then(|| {
                line_nums.sort_by(|&a, &b| {
                    is_sorted(&rules, (a, b))
                        .then_some(Ordering::Less)
                        .unwrap_or(Ordering::Greater)
                });

                line_nums[line_nums.len() / 2]
            })
        })
        .sum::<usize>();

    println!("Sum of middle rules = {middle_rules_sum}");
}

fn read_input() -> impl Iterator<Item = String> {
    read_lines("src/day5/input.txt")
}

fn parse_rules(lines: &mut impl Iterator<Item = String>) -> Vec<(usize, usize)> {
    lines
        .take_while(|line| !line.is_empty())
        .fold(Vec::new(), |mut rules, line| {
            let (a, b) = line.as_bytes().split_at(2);
            let a = bytes_to_num(a);
            let b = bytes_to_num(&b[1..]);

            rules.push((a, b));

            rules
        })
}

fn rule_line_to_list(line: &str) -> Vec<usize> {
    line.split(',')
        .map(|s| bytes_to_num(s.as_bytes()))
        .collect::<Vec<_>>()
}

fn is_sorted(rules: &[(usize, usize)], tuple: (usize, usize)) -> bool {
    rules.iter().any(|&r| r == tuple)
}

Reusing my bytes_to_num function from day 3 feels nice. Pretty fun challenge.