Skip Navigation

InitialsDiceBearhttps://github.com/dicebear/dicebearhttps://creativecommons.org/publicdomain/zero/1.0/„Initials” (https://github.com/dicebear/dicebear) by „DiceBear”, licensed under „CC0 1.0” (https://creativecommons.org/publicdomain/zero/1.0/)GE
Posts
2
Comments
306
Joined
2 yr. ago

  • Haskell

    Runs in 10 ms. I was stuck for most of the day on the bdv and cdv instructions, as I didn't read that the numerator was still register A. Once I got past that, it was pretty straight forward.

  • Haskell. For part 2 I just wrote 10000 text files and went through them by hand. I quickly noticed that every 103 seconds, an image started to form, so it didn't take that long to find the tree.

  • Haskell, 14 ms. The hardest part was the parser today. I somehow thought that the buttons could have negative values in X or Y too, so it's a bit overcomplicated.

     haskell
        
    import Text.ParserCombinators.ReadP
    
    int, signedInt :: ReadP Int
    int = read <$> (many1 $ choice $ map char ['0' .. '9'])
    signedInt = ($) <$> choice [id <$ char '+', negate <$ char '-'] <*> int
    
    machine :: ReadP ((Int, Int), (Int, Int), (Int, Int))
    machine = do
        string "Button A: X"
        xa <- signedInt
        string ", Y"
        ya <- signedInt
        string "\nButton B: X"
        xb <- signedInt
        string ", Y"
        yb <- signedInt
        string "\nPrize: X="
        x0 <- int
        string ", Y="
        y0 <- int
        return ((xa, ya), (xb, yb), (x0, y0))
    
    machines :: ReadP [((Int, Int), (Int, Int), (Int, Int))]
    machines = sepBy machine (string "\n\n")
    
    calc :: ((Int, Int), (Int, Int), (Int, Int)) -> Maybe (Int, Int)
    calc ((ax, ay), (bx, by), (x0, y0)) = case
            ( (x0 * by - y0 * bx) `divMod` (ax * by - ay * bx)
            , (x0 * ay - y0 * ax) `divMod` (bx * ay - by * ax)
            ) of
        ((a, 0), (b, 0)) -> Just (a, b)
        _                -> Nothing
    
    enlarge :: (a, b, (Int, Int)) -> (a, b, (Int, Int))
    enlarge (u, v, (x0, y0)) = (u, v, (10000000000000 + x0, 10000000000000 + y0))
    
    solve :: [((Int, Int), (Int, Int), (Int, Int))] -> Int
    solve ts = sum
        [ 3 * a + b
        | Just (a, b) <- map calc ts
        ]
    
    main :: IO ()
    main = do
        ts <- fst . last . readP_to_S machines <$> getContents
        mapM_ (print . solve) [ts, map enlarge ts]
    
      
  • You're right, I had it backwards. Hydrostatic equilibrium makes it that the combined force vector of gravity and the centrifugal force is perpendicular to the planet surface everywhere.

  • This. Planets are in hydrostatic equilibrium, meaning that the combined acceleration by gravity and the centrifugal "force" is equal all over the world (except for local differences due to mountains and dense crust).

  • Connect for Lemmy App @lemmy.ca

    Bug: Connect sometimes forgets an account

    Asklemmy @lemmy.ml

    Is "to put something" grammatically correct?