From 70a2317943e3e4aa5dc95d19d9dda961560c0cf5 Mon Sep 17 00:00:00 2001 From: Neil Smith Date: Fri, 20 Dec 2019 14:58:28 +0000 Subject: [PATCH] Done day 16 --- advent16/package.yaml | 60 ++++++++++++ advent16/src/advent16.hs | 65 +++++++++++++ data/advent16.txt | 1 + problems/day16.html | 192 +++++++++++++++++++++++++++++++++++++++ stack.yaml | 1 + 5 files changed, 319 insertions(+) create mode 100644 advent16/package.yaml create mode 100644 advent16/src/advent16.hs create mode 100644 data/advent16.txt create mode 100644 problems/day16.html diff --git a/advent16/package.yaml b/advent16/package.yaml new file mode 100644 index 0000000..fd86649 --- /dev/null +++ b/advent16/package.yaml @@ -0,0 +1,60 @@ +# This YAML file describes your package. Stack will automatically generate a +# Cabal file when you run `stack build`. See the hpack website for help with +# this file: . + +name: advent16 +synopsis: Advent of Code +version: '0.0.1' + +default-extensions: +- AllowAmbiguousTypes +- ApplicativeDo +- BangPatterns +- BlockArguments +- DataKinds +- DeriveFoldable +- DeriveFunctor +- DeriveGeneric +- DeriveTraversable +- EmptyCase +- FlexibleContexts +- FlexibleInstances +- FunctionalDependencies +- GADTs +- GeneralizedNewtypeDeriving +- ImplicitParams +- KindSignatures +- LambdaCase +- MonadComprehensions +- MonoLocalBinds +- MultiParamTypeClasses +- MultiWayIf +- NegativeLiterals +- NumDecimals +- OverloadedLists +- OverloadedStrings +- PartialTypeSignatures +- PatternGuards +- PatternSynonyms +- PolyKinds +- RankNTypes +- RecordWildCards +- ScopedTypeVariables +- TemplateHaskell +- TransformListComp +- TupleSections +- TypeApplications +- TypeInType +- TypeOperators +- ViewPatterns + + +executables: + advent16: + main: advent16.hs + source-dirs: src + dependencies: + - base >= 2 && < 6 + - text + - containers + diff --git a/advent16/src/advent16.hs b/advent16/src/advent16.hs new file mode 100644 index 0000000..816def5 --- /dev/null +++ b/advent16/src/advent16.hs @@ -0,0 +1,65 @@ +import Debug.Trace + +import Data.Char (digitToInt, intToDigit) + +-- import qualified Data.Map.Strict as M +-- import Data.Map.Strict ((!)) +import Data.List +-- import qualified Data.Set as S + + + +main :: IO () +main = do + text <- readFile "data/advent16.txt" + let digits = parseDigits text + -- print mem + print $ part1 digits + print $ part2 digits + -- print $ part2 mem + +part1 :: [Int] -> String +part1 digits = map intToDigit $ take 8 $ (fft digits)!!100 + +part2 digits = map intToDigit signal + where offset = read @Int $ map intToDigit $ take 7 digits + fullDigits = concat $ replicate 10000 digits + suffix = drop offset fullDigits + signal = take 8 $ (fastFft suffix)!!100 + +part2naive :: [Int] -> String +part2naive digits = map intToDigit signal + where fullDigits = concat $ replicate 10000 digits + result = (fft fullDigits)!!100 + offset = read @Int $ map intToDigit $ take 7 digits + signal = take 8 $ drop offset result + + +basePattern :: [Int] +basePattern = [0, 1, 0, -1] + +patternOf :: Int -> [Int] +patternOf index = drop 1 $ cycle $ concatMap (replicate index) basePattern + +elementAt :: [Int] -> Int -> Int +elementAt digits index = (abs $ sum $ zipWith (*) digits $ patternOf index) `mod` 10 + +fftStep :: [Int] -> [Int] +fftStep digits = map (elementAt digits) [1..(length digits)] + +fft :: [Int] -> [[Int]] +fft = iterate fftStep + +fastFft :: [Int] -> [[Int]] +fastFft = iterate fastFftStep + +fastFftStep :: [Int] -> [Int] +-- fastFftStep digits = map (\ds -> (sum ds) `mod` 10) $ tails digits +fastFftStep digits = scanr (\d s -> (d + s) `mod` 10) 0 digits + + +parseDigits :: String -> [Int] +parseDigits = map digitToInt + + + diff --git a/data/advent16.txt b/data/advent16.txt new file mode 100644 index 0000000..1cb7d4b --- /dev/null +++ b/data/advent16.txt @@ -0,0 +1 @@ +59709275180991144553584971145772909665510077889137728108418335914621187722143499835763391833539113913245874471724316543318206687063884235599476032241946131415288903315838365933464260961288979081653450180693829228376307468452214424448363604272171578101049695177870848804768766855959460302410160410252817677019061157656381257631671141130695064999297225192441065878259341014746742840736304437968599872885714729499069286593698777113907879332554209736653679474028316464493192062972874319626623316763537266681767610340623614648701699868901159785995894014509520642548386447251984766543776759949169049134947575625384064448900019906754502662096668908517457172 \ No newline at end of file diff --git a/problems/day16.html b/problems/day16.html new file mode 100644 index 0000000..527e5bd --- /dev/null +++ b/problems/day16.html @@ -0,0 +1,192 @@ + + + + +Day 16 - Advent of Code 2019 + + + + + + + +

Advent of Code

Neil Smith (AoC++) 32*

      /^2019$/

+ + + +
+ +

--- Day 16: Flawed Frequency Transmission ---

You're 3/4ths of the way through the gas giants. Not only do roundtrip signals to Earth take five hours, but the signal quality is quite bad as well. You can clean up the signal with the Flawed Frequency Transmission algorithm, or FFT.

+

As input, FFT takes a list of numbers. In the signal you received (your puzzle input), each number is a single digit: data like 15243 represents the sequence 1, 5, 2, 4, 3.

+

FFT operates in repeated phases. In each phase, a new list is constructed with the same length as the input list. This new list is also used as the input for the next phase.

+

Each element in the new list is built by multiplying every value in the input list by a value in a repeating pattern and then adding up the results. So, if the input list were 9, 8, 7, 6, 5 and the pattern for a given element were 1, 2, 3, the result would be 9*1 + 8*2 + 7*3 + 6*1 + 5*2 (with each input element on the left and each value in the repeating pattern on the right of each multiplication). Then, only the ones digit is kept: 38 becomes 8, -17 becomes 7, and so on.

+

While each element in the output array uses all of the same input array elements, the actual repeating pattern to use depends on which output element is being calculated. The base pattern is 0, 1, 0, -1. Then, repeat each value in the pattern a number of times equal to the position in the output list being considered. Repeat once for the first element, twice for the second element, three times for the third element, and so on. So, if the third element of the output list is being calculated, repeating the values would produce: 0, 0, 0, 1, 1, 1, 0, 0, 0, -1, -1, -1.

+

When applying the pattern, skip the very first value exactly once. (In other words, offset the whole pattern left by one.) So, for the second element of the output list, the actual pattern used would be: 0, 1, 1, 0, 0, -1, -1, 0, 0, 1, 1, 0, 0, -1, -1, ....

+

After using this process to calculate each element of the output list, the phase is complete, and the output list of this phase is used as the new input list for the next phase, if any.

+

Given the input signal 12345678, below are four phases of FFT. Within each phase, each output digit is calculated on a single line with the result at the far right; each multiplication operation shows the input digit on the left and the pattern value on the right:

+
Input signal: 12345678
+
+1*1  + 2*0  + 3*-1 + 4*0  + 5*1  + 6*0  + 7*-1 + 8*0  = 4
+1*0  + 2*1  + 3*1  + 4*0  + 5*0  + 6*-1 + 7*-1 + 8*0  = 8
+1*0  + 2*0  + 3*1  + 4*1  + 5*1  + 6*0  + 7*0  + 8*0  = 2
+1*0  + 2*0  + 3*0  + 4*1  + 5*1  + 6*1  + 7*1  + 8*0  = 2
+1*0  + 2*0  + 3*0  + 4*0  + 5*1  + 6*1  + 7*1  + 8*1  = 6
+1*0  + 2*0  + 3*0  + 4*0  + 5*0  + 6*1  + 7*1  + 8*1  = 1
+1*0  + 2*0  + 3*0  + 4*0  + 5*0  + 6*0  + 7*1  + 8*1  = 5
+1*0  + 2*0  + 3*0  + 4*0  + 5*0  + 6*0  + 7*0  + 8*1  = 8
+
+After 1 phase: 48226158
+
+4*1  + 8*0  + 2*-1 + 2*0  + 6*1  + 1*0  + 5*-1 + 8*0  = 3
+4*0  + 8*1  + 2*1  + 2*0  + 6*0  + 1*-1 + 5*-1 + 8*0  = 4
+4*0  + 8*0  + 2*1  + 2*1  + 6*1  + 1*0  + 5*0  + 8*0  = 0
+4*0  + 8*0  + 2*0  + 2*1  + 6*1  + 1*1  + 5*1  + 8*0  = 4
+4*0  + 8*0  + 2*0  + 2*0  + 6*1  + 1*1  + 5*1  + 8*1  = 0
+4*0  + 8*0  + 2*0  + 2*0  + 6*0  + 1*1  + 5*1  + 8*1  = 4
+4*0  + 8*0  + 2*0  + 2*0  + 6*0  + 1*0  + 5*1  + 8*1  = 3
+4*0  + 8*0  + 2*0  + 2*0  + 6*0  + 1*0  + 5*0  + 8*1  = 8
+
+After 2 phases: 34040438
+
+3*1  + 4*0  + 0*-1 + 4*0  + 0*1  + 4*0  + 3*-1 + 8*0  = 0
+3*0  + 4*1  + 0*1  + 4*0  + 0*0  + 4*-1 + 3*-1 + 8*0  = 3
+3*0  + 4*0  + 0*1  + 4*1  + 0*1  + 4*0  + 3*0  + 8*0  = 4
+3*0  + 4*0  + 0*0  + 4*1  + 0*1  + 4*1  + 3*1  + 8*0  = 1
+3*0  + 4*0  + 0*0  + 4*0  + 0*1  + 4*1  + 3*1  + 8*1  = 5
+3*0  + 4*0  + 0*0  + 4*0  + 0*0  + 4*1  + 3*1  + 8*1  = 5
+3*0  + 4*0  + 0*0  + 4*0  + 0*0  + 4*0  + 3*1  + 8*1  = 1
+3*0  + 4*0  + 0*0  + 4*0  + 0*0  + 4*0  + 3*0  + 8*1  = 8
+
+After 3 phases: 03415518
+
+0*1  + 3*0  + 4*-1 + 1*0  + 5*1  + 5*0  + 1*-1 + 8*0  = 0
+0*0  + 3*1  + 4*1  + 1*0  + 5*0  + 5*-1 + 1*-1 + 8*0  = 1
+0*0  + 3*0  + 4*1  + 1*1  + 5*1  + 5*0  + 1*0  + 8*0  = 0
+0*0  + 3*0  + 4*0  + 1*1  + 5*1  + 5*1  + 1*1  + 8*0  = 2
+0*0  + 3*0  + 4*0  + 1*0  + 5*1  + 5*1  + 1*1  + 8*1  = 9
+0*0  + 3*0  + 4*0  + 1*0  + 5*0  + 5*1  + 1*1  + 8*1  = 4
+0*0  + 3*0  + 4*0  + 1*0  + 5*0  + 5*0  + 1*1  + 8*1  = 9
+0*0  + 3*0  + 4*0  + 1*0  + 5*0  + 5*0  + 1*0  + 8*1  = 8
+
+After 4 phases: 01029498
+
+

Here are the first eight digits of the final output list after 100 phases for some larger inputs:

+
    +
  • 80871224585914546619083218645595 becomes 24176176.
    • +
  • 19617804207202209144916044189917 becomes 73745418.
    • +
  • 69317163492948606335995924319873 becomes 52432133.
    • +
+

After 100 phases of FFT, what are the first eight digits in the final output list?

+
+

Your puzzle answer was 15841929.

--- Part Two ---

Now that your FFT is working, you can decode the real signal.

+

The real signal is your puzzle input repeated 10000 times. Treat this new signal as a single input list. Patterns are still calculated as before, and 100 phases of FFT are still applied.

+

The first seven digits of your initial input signal also represent the message offset. The message offset is the location of the eight-digit message in the final output list. Specifically, the message offset indicates the number of digits to skip before reading the eight-digit message. For example, if the first seven digits of your initial input signal were 1234567, the eight-digit message would be the eight digits after skipping 1,234,567 digits of the final output list. Or, if the message offset were 7 and your final output list were 98765432109876543210, the eight-digit message would be 21098765. (Of course, your real message offset will be a seven-digit number, not a one-digit number like 7.)

+

Here is the eight-digit message in the final output list after 100 phases. The message offset given in each input has been highlighted. (Note that the inputs given below are repeated 10000 times to find the actual starting input lists.)

+
    +
  • 03036732577212944063491565474664 becomes 84462026.
    • +
  • 02935109699940807407585447034323 becomes 78725270.
    • +
  • 03081770884921959731165446850517 becomes 53553731.
    • +
+

After repeating your input signal 10000 times and running 100 phases of FFT, what is the eight-digit message embedded in the final output list?

+
+

Your puzzle answer was 39011547.

Both parts of this puzzle are complete! They provide two gold stars: **

+

At this point, you should return to your Advent calendar and try another puzzle.

+

If you still want to see it, you can get your puzzle input.

+

You can also this puzzle.

+
+ + + + + + \ No newline at end of file diff --git a/stack.yaml b/stack.yaml index 9a9c54c..e9556a5 100644 --- a/stack.yaml +++ b/stack.yaml @@ -53,6 +53,7 @@ packages: - advent13 - advent14 - advent15 +- advent16 # Dependency packages to be pulled from upstream that are not in the resolver. -- 2.34.1