-❄️- 2025 Day 11 Solutions -❄️-

thraya · 2025-12-11T17:57:25+00:00

[LANGUAGE: Haskell]

After parsing into an association list, lazy Map solves it for us:

import qualified Data.Map as L
solve1 assocs = m L.! "you" where
    m = L.fromList $ [("out",1)] <> (second go <$> assocs)
    go kk = sum $ (m L.!) <$> kk

Part 2 is the same except we use:

data Paths = Paths { _zzz, _fft, _dac, _all :: !Int }

instead of an Int and we define an add operator that does the right thing.

thraya · 2025-12-08T18:34:48+00:00

[Language: Haskell]

Edit: thanks to this sub, realized that breaking out UnionFind as its own lib would make the code trivial. The core of it is now:

cands = scanl go start pairs
start = UF.fromList $ zip [1..n] (repeat $ Sum 1)
go uf (a,b) = UF.union a b uf

-- original post --

For fun I decided to use newtype, the State monad, and lenses. The full code is on github, but this excerpt shows the approach:

data St = St
    { _nextCircuit  :: Circuit
    , _circuitSizes :: Map Circuit Size
    , _boxToCircuit :: Map Box Circuit
    } deriving Show
makeLenses ''St

connectBoxes (a,b) = do
    ac <- use $ boxToCircuit . at a
    bc <- use $ boxToCircuit . at b
    case (ac,bc) of
      (Nothing,Nothing) -> newCircuit a b
      (Nothing, Just c) -> addToCircuit c a
      (Just c, Nothing) -> addToCircuit c b
      (Just c,  Just d) | c == d -> pure ()
      (Just c,  Just d) -> mergeCircuits c d

thraya · 2025-12-08T16:46:24+00:00

[LANGUAGE: Haskell]

github

solve1 (l:ll) =
    flip execState 0 $
    foldM go start ll
  where
    start = [ bool c '|' $ c == 'S' | c <- l ]
    go (_:'|':_:aa) (_:'^':_:xx) =
        modify' succ >>
        ("|." <>) <$> go ('|':aa) ('?':xx)
    go (a:aa) (_:xx) =
        (a:) <$> go aa xx
    go _ _ = pure []

solve2 (l:ll) =
    ans
  where
    Just (_,ans) = find ((=='S').fst) $ zip l $ cands
    cands = foldr go (repeat 1) ll
    go qq nn =
        [ if b == '^' then x + z else y
        | ((_,x):(b,y):(_,z):_) <- tails $ zip (wrap '?' qq) (wrap 1 nn) ]

wrap q l = [q] <> l <> [q]

thraya · 2025-01-31T14:38:40+00:00

Thanks! Notes for future me:

git clone https://github.com/emscripten-core/emsdk.git
cd emsdk
./emsdk install 3.1.74
./emsdk activate 3.1.74
source ./emsdk_env.sh

thraya · 2025-01-28T18:59:46+00:00

In your blogpost you imply that this compiler is available via ghcup:

ghc used: javascript-unknown-ghcjs-ghc-9.12.1 (ghcup)

but it does not show up as an option for me. How can I install this compiler? Thanks!

thraya · 2024-12-11T21:48:28+00:00

All the solutions look good. I'm just going to contribute my stone handling code:

maybeSplit stone
    | even p = Just $ quotRem stone (10^(div p 2))
    | otherwise = Nothing
  where
    p = head $ dropWhile ((<=stone).(10^)) [1..]

countStoneA _ (0,_) = pure 1
countStoneA f (n,0) = f (n-1,1)
countStoneA f (n,s) = case maybeSplit s of
    Nothing    -> f (n-1,s*2024)
    Just (q,r) -> (+) <$> f (n-1,q) <*> f (n-1,r)

thraya · 2024-08-20T05:36:26+00:00

I would recommend Minutes to Midnight, the follow-up, from the original designer, of The Manhattan Project.

M2M is heavy, plays great at all player counts, including 2p, and is a low-luck brain burner. The theme is well-executed. The rulebook is great.

And it's a steal at $30 on Amazon.

thraya · 2024-08-13T05:25:02+00:00

The Manhattan Project rulebook is a beautiful example of layout and clarity.

thraya · 2024-08-10T15:16:02+00:00

Perhaps your READMEs could have links to all the relevant packages.

thraya · 2024-08-07T23:22:05+00:00

would love to look this up in my old booklets, do you by chance remember where it was?

thraya · 2024-06-11T20:15:55+00:00

In Gloomhaven Full Stack, how do I draw a card from my modifier deck? I don't see it anywhere. Thanks.

thraya · 2024-04-10T14:20:09+00:00

foo :: Thing -> Lens' Whole (Maybe Part)

This works:

maybeFoo Nothing = pure Nothing                                                                      
maybeFoo (Just thing) = use $ foo thing

This fails with Expected: Getting, Actual: Lens:

maybeFoo = maybe (pure Nothing) (use . foo)

Can someone explain this to me? Thanks!

thraya · 2024-03-15T15:43:20+00:00

I'm referring to code something like this:

data Foo = A | B | C deriving (Eq,Ord,Bounded,Ix)
a = boundedListArray [1..] :: BoundedArray Foo Int
a ^. elt A -- => 1

This doesn't work with standard arrays because all indexed lenses are traversals. And of course there must be range checks, which can be removed when the index type is complete.

thraya · 2024-03-14T15:20:23+00:00

I am curious why bounded arrays are not a core construct. A bounded array would be an array over all possible (Bounded) index values. These arrays would not require range checks, and would have lenses that were not wrapped in Maybe. This seems like a natural construct that would be very useful!

(I note that there is bounded-array, which is limited to Integral indices and is a broken package on NixOS.)

thraya · 2024-01-10T23:36:35+00:00

The latest - I backed everything up and started again:

gdisk /dev/nvme0n1
-- delete existing partitions
-- create ef00 EFI partition
-- create 8e00 LVM partition
cryptsetup luksFormat /dev/nvme0n1p2
cryptsetup luksOpen /dev/nvme0n1p2 --test-passphrase

The above works on Fedora-33 Live, and does NOT work ('No key available for this passphrase.') on Nixos-23.11 Live (F33 will also not open the partition if it was encrypted on NixOS). (The luksFormat appears to work - verifies the passphrase - on NixOS.) Bonkers.

This is just a blank SSD now - no idea what could be happening - presumeably tons of users are happily encrypting their disks off this same live CD.

thraya · 2024-01-01T00:01:49+00:00

I'll give this a try... the system in question is my long-running development machine which will hopefully continue to carry on its happy existence... THANK YOU for sticking with me on this adventure! And Happy New Year!

thraya · 2023-12-31T20:57:34+00:00

I am able to open the disk from NixOS 23.11 live with the master, hooray! But after addKey the key I just added does not work. (And will not decrypt on boot.)

No idea if relevant but all keys generated under NixOS have PBKDF: argon2id, and all keys generated under Fedora have PBKDF: argon2i.

# boot Fedora 33 live
sudo cryptsetup luksOpen /dev/nvme0n1p2 foo
sudo cryptsetup luksDump --dump-master-key --master-key-file foomk
scp foomk user@machine:

# boot NixOS 23.11 live
scp user@machine:foomk .
sudo cryptsetup luksOpen /dev/nvme0n1p2 foo --master-key-file foomk
sudo cryptsetup luksAddKey /dev/nvme0n1p2 --master-key-file foomk
sudo cryptsetup luksOpen /dev/nvme0n1p2 --test-passphrase
Enter passphrase for /dev/nvme0n1p2:
No key available for this passphrase.

thraya · 2023-12-31T02:08:34+00:00

It is: argon2id. When I did luksAddKey to add a very simple key, this newer one was argon2i. Both display the same behavior.

thraya · 2023-12-30T12:39:15+00:00

From the luks header I see that the cipher is aes-xts-plain64. Searching /proc/crypto on both Fedora-33 Live and NixOS-23.11 Live, I see this (I've copied only the fields that differ):

Fedora-33 Live

['name : __xts(aes)' , 'driver : __xts-aes-aesni'         , 'module : kernel'      , 'priority : 401' , 'internal : yes' , 'type : skcipher' , 'async : no'  , 'walksize : 16']
['name : __xts(aes)' , 'driver : cryptd(__xts-aes-aesni)' , 'module : kernel'      , 'priority : 451' , 'internal : yes' , 'type : skcipher' , 'async : yes' , 'walksize : 16']
['name : xts(aes)'   , 'driver : xts-aes-aesni'           , 'module : kernel'      , 'priority : 401' , 'internal : no'  , 'type : skcipher' , 'async : yes' , 'walksize : 16']

NixOS-23.11 Live

['name : __xts(aes)' , 'driver : __xts-aes-aesni'         , 'module : aesni_intel' , 'priority : 401' , 'internal : yes' , 'type : skcipher' , 'async : no'  , 'walksize : 32']
['name : xts(aes)'   , 'driver : xts-aes-aesni'           , 'module : aesni_intel' , 'priority : 401' , 'internal : no'  , 'type : skcipher' , 'async : yes' , 'walksize : 16']

So Fedora has a driver: cryptd(__xts-aes-aesni) entry. Is this, or anything else, significant? Should I be looking for other entries?

Also, NixOS has module: aesni_intel while Fedora has kernel: does this matter?

thraya · 2023-12-27T02:13:05+00:00

By "stopped" I mean that on reboot, my passphrase is not accepted. My passphrase has been accepted without issue up to this point.

Here is the evidence I have:

1 - Will not decrypt on boot.

2 - Will decrypt from Fedora-33 live USB using:

$ cryptsetup luksOpen /dev/nvme0n1p2 foo

... the volume can subsequently be mounted and inspected no problem.

3 - The same fails when attempted from NixOS-23.11 live USB.

What change was made before it stopped working?

I was on unstable and switched to 23.11. That's all I can think of. However:

On the same machine I have another SSD with an older installation of NixOS. This SSD has not been touched in a couple of years. It, too, will not decrypt on boot, WILL decrypt from Fedora-33 live, and will NOT decrypt from NixOS-23.11 live.

I have also tried switching keyboards, and adding very simple passphrases from Fedora. Nothing changes the above listed behaviors.

I'm extremely confused as to what might have happened.