Day 11: Reactor

Megathread guidelines

  • Keep top level comments as only solutions, if you want to say something other than a solution put it in a new post. (replies to comments can be whatever)
  • You can send code in code blocks by using three backticks, the code, and then three backticks or use something such as https://topaz.github.io/paste/ if you prefer sending it through a URL

FAQ

  • Amy@piefed.blahaj.zoneEnglish
    2·
    7 days ago

    Haskell

    Oh, this one was easy (dynamic programming at last!). Still haven’t figured out the right way to approach yesterday’s part two, though.

    import Data.List  
import Data.Map (Map)  
import Data.Map qualified as Map  

readInput =  
  Map.fromList  
    . map ((\(name : outs) -> (init name, outs)) . words)  
    . lines  

part1 input = go "you"  
  where  
    go "out" = 1  
    go name = maybe 0 (sum . map go) $ input Map.!? name  

part2 input = let (both, _, _, _) = pathsFrom "svr" in both  
  where  
    pathsFrom =  
      (Map.!)  
        . Map.insert "out" (0, 0, 0, 1)  
        . Map.fromList  
        . (zip <*> map findPaths)  
        $ Map.keys input ++ concat (Map.elems input)  
    findPaths n =  
      let (both, dac, fft, none) =  
            unzip4 $ maybe [] (map pathsFrom) (input Map.!? n)  
       in case n of  
            "dac" -> (sum both + sum fft, sum dac + sum none, 0, 0)  
            "fft" -> (sum both + sum dac, 0, sum fft + sum none, 0)  
            _ -> (sum both, sum dac, sum fft, sum none)  

main = do  
  input <- readInput <$> readFile "input11"  
  print $ part1 input  
  print $ part2 input
    • addie@feddit.uk
      2·
      7 days ago

      If you work out a solution to yesterday’s part 2 which isn’t just “cheat and rely on an external solver library”, I will be most impressed.

      Programming and mathematics have quite a large overlap and if you want to write tough puzzles it’ll be “deep in the woods” for both, but that question is very much on the maths side. And “are you able to pass arguments to Z3?” isn’t a very satisfying puzzle for me.

      • Avicenna@programming.dev
        2·
        7 days ago

        I did linear algebra with sympy over Q to reduce the search space to nullspace x [-N,N] grid (which is generally <=2 dimensional in these inputs and N<50 seems sufficient in most cases) then made easy work of it with vectorization. Similarly for part 2 did linear algebra over F2 but the search grid is also much smaller [0,1] x nullspace