diff --git a/2018/01/README.md b/2018/01/README.md new file mode 100644 index 0000000..5dcf1cd --- /dev/null +++ b/2018/01/README.md @@ -0,0 +1,49 @@ +# 2018 Day 1: Chronal Calibration +Copyright (c) Eric Wastl +#### [Direct Link](https://adventofcode.com/2018/day/1) + +## Part 1 + +After feeling like you've been falling for a few minutes, you look at the device's tiny screen. "Error: Device must be calibrated before first use. Frequency drift detected. Cannot maintain destination lock." Below the message, the device shows a sequence of changes in frequency (your puzzle input). A value like `+6` means the current frequency increases by `6`; a value like `-3` means the current frequency decreases by `3`. + +For example, if the device displays frequency changes of `+1, -2, +3, +1`, then starting from a frequency of zero, the following changes would occur: + +- Current frequency ` 0`, change of `+1`; resulting frequency ` 1`. +- Current frequency ` 1`, change of `-2`; resulting frequency `-1`. +- Current frequency `-1`, change of `+3`; resulting frequency ` 2`. +- Current frequency ` 2`, change of `+1`; resulting frequency ` 3`. + +In this example, the resulting frequency is `3`. + +Here are other example situations: + +- `+1, +1, +1` results in ` 3` +- `+1, +1, -2` results in ` 0` +- `-1, -2, -3` results in `-6` + +Starting with a frequency of zero, **what is the resulting frequency** after all of the changes in frequency have been applied? + +## Part 2 + +You notice that the device repeats the same frequency change list over and over. To calibrate the device, you need to find the first frequency it reaches **twice**. + +For example, using the same list of changes above, the device would loop as follows: + +- Current frequency ` 0`, change of `+1`; resulting frequency ` 1`. +- Current frequency ` 1`, change of `-2`; resulting frequency `-1`. +- Current frequency `-1`, change of `+3`; resulting frequency ` 2`. +- Current frequency ` 2`, change of `+1`; resulting frequency ` 3`. +- (At this point, the device continues from the start of the list.) +- Current frequency ` 3`, change of `+1`; resulting frequency ` 4`. +- Current frequency ` 4`, change of `-2`; resulting frequency ` 2`, which has already been seen. + +In this example, the first frequency reached twice is `2`. Note that your device might need to repeat its list of frequency changes many times before a duplicate frequency is found, and that duplicates might be found while in the middle of processing the list. + +Here are other examples: + +- `+1, -1` first reaches `0` twice. +- `+3, +3, +4, -2, -4` first reaches `10` twice. +- `-6, +3, +8, +5, -6` first reaches `5` twice. +- `+7, +7, -2, -7, -4` first reaches `14` twice. + +**What is the first frequency your device reaches twice?** \ No newline at end of file diff --git a/2018/day01.py b/2018/01/code.py similarity index 78% rename from 2018/day01.py rename to 2018/01/code.py index 601c9d3..22bfc53 100644 --- a/2018/day01.py +++ b/2018/01/code.py @@ -1,12 +1,8 @@ """ https://adventofcode.com/2018/day/1 """ def readFile(): - import os.path as p - dName = p.dirname(__file__) - fName = p.basename(__file__).split(".")[0] - l = [] - with open(p.join(dName, "input", f"{fName}.txt"), "r") as f: + with open(f"{__file__.rstrip('code.py')}input.txt", "r") as f: line = f.readline() while line: l.append(int(line)) diff --git a/2018/input/day01.txt b/2018/01/input.txt similarity index 100% rename from 2018/input/day01.txt rename to 2018/01/input.txt diff --git a/2018/01/solution.txt b/2018/01/solution.txt new file mode 100644 index 0000000..1effbe1 --- /dev/null +++ b/2018/01/solution.txt @@ -0,0 +1,2 @@ +Part 1: 433 +Part 2: 256 \ No newline at end of file diff --git a/2018/02/README.md b/2018/02/README.md new file mode 100644 index 0000000..13852c8 --- /dev/null +++ b/2018/02/README.md @@ -0,0 +1,49 @@ +# 2018 Day 2: Inventory Management System +Copyright (c) Eric Wastl +#### [Direct Link](https://adventofcode.com/2018/day/2) + +## Part 1 + +You stop falling through time, catch your breath, and check the screen on the device. "Destination reached. Current Year: 1518. Current Location: North Pole Utility Closet 83N10." You made it! Now, to find those anomalies. + +Outside the utility closet, you hear footsteps and a voice. "...I'm not sure either. But now that so many people have chimneys, maybe he could sneak in that way?" Another voice responds, "Actually, we've been working on a new kind of **suit** that would let him fit through tight spaces like that. But, I heard that a few days ago, they lost the prototype fabric, the design plans, everything! Nobody on the team can even seem to remember important details of the project!" + +"Wouldn't they have had enough fabric to fill several boxes in the warehouse? They'd be stored together, so the box IDs should be similar. Too bad it would take forever to search the warehouse for **two similar box IDs**..." They walk too far away to hear any more. + +Late at night, you sneak to the warehouse - who knows what kinds of paradoxes you could cause if you were discovered - and use your fancy wrist device to quickly scan every box and produce a list of the likely candidates (your puzzle input). + +To make sure you didn't miss any, you scan the likely candidate boxes again, counting the number that have an ID containing **exactly two of any letter** and then separately counting those with **exactly three of any letter**. You can multiply those two counts together to get a rudimentary [checksum](https://en.wikipedia.org/wiki/Checksum) and compare it to what your device predicts. + +For example, if you see the following box IDs: + +- `abcdef` contains no letters that appear exactly two or three times. +- `bababc` contains two `a` and three `b`, so it counts for both. +- `abbcde` contains two `b`, but no letter appears exactly three times. +- `abcccd` contains three `c`, but no letter appears exactly two times. +- `aabcdd` contains two `a` and two `d`, but it only counts once. +- `abcdee` contains two `e`. +- `ababab` contains three `a` and three `b`, but it only counts once. + +Of these box IDs, four of them contain a letter which appears exactly twice, and three of them contain a letter which appears exactly three times. Multiplying these together produces a checksum of `4 * 3 = 12`. + +**What is the checksum** for your list of box IDs? + +## Part 2 + +Confident that your list of box IDs is complete, you're ready to find the boxes full of prototype fabric. + +The boxes will have IDs which differ by exactly one character at the same position in both strings. For example, given the following box IDs: + +``` +abcde +fghij +klmno +pqrst +fguij +axcye +wvxyz +``` + +The IDs `abcde` and `axcye` are close, but they differ by two characters (the second and fourth). However, the IDs `fghij` and `fguij` differ by exactly one character, the third (`h` and `u`). Those must be the correct boxes. + +**What letters are common between the two correct box IDs?** (In the example above, this is found by removing the differing character from either ID, producing `fgij`.) \ No newline at end of file diff --git a/2018/day02.py b/2018/02/code.py similarity index 88% rename from 2018/day02.py rename to 2018/02/code.py index bb98bc5..cb43cd3 100644 --- a/2018/day02.py +++ b/2018/02/code.py @@ -1,12 +1,8 @@ """ https://adventofcode.com/2018/day/2 """ def readFile(): - import os.path as p - dName = p.dirname(__file__) - fName = p.basename(__file__).split(".")[0] - l = [] - with open(p.join(dName, "input", f"{fName}.txt"), "r") as f: + with open(f"{__file__.rstrip('code.py')}input.txt", "r") as f: line = f.readline() while line: l.append(line) diff --git a/2018/input/day02.txt b/2018/02/input.txt similarity index 100% rename from 2018/input/day02.txt rename to 2018/02/input.txt diff --git a/2018/02/solution.txt b/2018/02/solution.txt new file mode 100644 index 0000000..4376c0a --- /dev/null +++ b/2018/02/solution.txt @@ -0,0 +1,2 @@ +Part 1: 6175 +Part 2: asgwjcmzredihqoutcylvzinx \ No newline at end of file diff --git a/2018/03/README.md b/2018/03/README.md new file mode 100644 index 0000000..6e134bc --- /dev/null +++ b/2018/03/README.md @@ -0,0 +1,63 @@ +# 2018 Day 3: No Matter How You Slice It +Copyright (c) Eric Wastl +#### [Direct Link](https://adventofcode.com/2018/day/3) + +## Part 1 + +The Elves managed to locate the chimney-squeeze prototype fabric for Santa's suit (thanks to someone who helpfully wrote its box IDs on the wall of the warehouse in the middle of the night). Unfortunately, anomalies are still affecting them - nobody can even agree on how to **cut** the fabric. + +The whole piece of fabric they're working on is a very large square - at least `1000` inches on each side. + +Each Elf has made a **claim** about which area of fabric would be ideal for Santa's suit. All claims have an ID and consist of a single rectangle with edges parallel to the edges of the fabric. Each claim's rectangle is defined as follows: + +- The number of inches between the left edge of the fabric and the left edge of the rectangle. +- The number of inches between the top edge of the fabric and the top edge of the rectangle. +- The width of the rectangle in inches. +- The height of the rectangle in inches. + +A claim like #123 @ 3,2: 5x4 means that claim ID 123 specifies a rectangle 3 inches from the left edge, 2 inches from the top edge, 5 inches wide, and 4 inches tall. Visually, it claims the square inches of fabric represented by # (and ignores the square inches of fabric represented by .) in the diagram below: + +``` +........... +........... +...#####... +...#####... +...#####... +...#####... +........... +........... +........... +``` + +The problem is that many of the claims **overlap**, causing two or more claims to cover part of the same areas. For example, consider the following claims: + +``` +#1 @ 1,3: 4x4 +#2 @ 3,1: 4x4 +#3 @ 5,5: 2x2 +``` + +Visually, these claim the following areas: + +``` +........ +...2222. +...2222. +.11XX22. +.11XX22. +.111133. +.111133. +........ +``` + +The four square inches marked with X are claimed by **both 1 and 2**. (Claim 3, while adjacent to the others, does not overlap either of them.) + +If the Elves all proceed with their own plans, none of them will have enough fabric. **How many square inches of fabric are within two or more claims?** + +## Part 2 + +Amidst the chaos, you notice that exactly one claim doesn't overlap by even a single square inch of fabric with any other claim. If you can somehow draw attention to it, maybe the Elves will be able to make Santa's suit after all! + +For example, in the claims above, only claim `3` is intact after all claims are made. + +**What is the ID of the only claim that doesn't overlap?** \ No newline at end of file diff --git a/2018/day03.py b/2018/03/code.py similarity index 90% rename from 2018/day03.py rename to 2018/03/code.py index ff8f6ee..f7e6c47 100644 --- a/2018/day03.py +++ b/2018/03/code.py @@ -1,12 +1,8 @@ """ https://adventofcode.com/2018/day/3 """ def readFile(): - import os.path as p - dName = p.dirname(__file__) - fName = p.basename(__file__).split(".")[0] - l = [] - with open(p.join(dName, "input", f"{fName}.txt"), "r") as f: + with open(f"{__file__.rstrip('code.py')}input.txt", "r") as f: line = f.readline() while line: s = line.split(" ") diff --git a/2018/input/day03.txt b/2018/03/input.txt similarity index 100% rename from 2018/input/day03.txt rename to 2018/03/input.txt diff --git a/2018/03/solution.txt b/2018/03/solution.txt new file mode 100644 index 0000000..e84c88e --- /dev/null +++ b/2018/03/solution.txt @@ -0,0 +1,2 @@ +Part 1: 112378 +Part 2: 603 \ No newline at end of file diff --git a/2018/04/README.md b/2018/04/README.md new file mode 100644 index 0000000..3d53a61 --- /dev/null +++ b/2018/04/README.md @@ -0,0 +1,68 @@ +# 2018 Day 4: Repose Record +Copyright (c) Eric Wastl +#### [Direct Link](https://adventofcode.com/2018/day/4) + +## Part 1 + +You've sneaked into another supply closet - this time, it's across from the prototype suit manufacturing lab. You need to sneak inside and fix the issues with the suit, but there's a guard stationed outside the lab, so this is as close as you can safely get. + +As you search the closet for anything that might help, you discover that you're not the first person to want to sneak in. Covering the walls, someone has spent an hour starting every midnight for the past few months secretly observing this guard post! They've been writing down the ID of **the one guard on duty that night** - the Elves seem to have decided that one guard was enough for the overnight shift - as well as when they fall asleep or wake up while at their post (your puzzle input). + +For example, consider the following records, which have already been organized into chronological order: + +``` +[1518-11-01 00:00] Guard #10 begins shift +[1518-11-01 00:05] falls asleep +[1518-11-01 00:25] wakes up +[1518-11-01 00:30] falls asleep +[1518-11-01 00:55] wakes up +[1518-11-01 23:58] Guard #99 begins shift +[1518-11-02 00:40] falls asleep +[1518-11-02 00:50] wakes up +[1518-11-03 00:05] Guard #10 begins shift +[1518-11-03 00:24] falls asleep +[1518-11-03 00:29] wakes up +[1518-11-04 00:02] Guard #99 begins shift +[1518-11-04 00:36] falls asleep +[1518-11-04 00:46] wakes up +[1518-11-05 00:03] Guard #99 begins shift +[1518-11-05 00:45] falls asleep +[1518-11-05 00:55] wakes up +``` + +Timestamps are written using `year-month-day hour:minute format`. The guard falling asleep or waking up is always the one whose shift most recently started. Because all asleep/awake times are during the midnight hour (`00:00` - `00:59`), only the minute portion (`00` - `59`) is relevant for those events. + +Visually, these records show that the guards are asleep at these times: + +``` +Date ID Minute + 000000000011111111112222222222333333333344444444445555555555 + 012345678901234567890123456789012345678901234567890123456789 +11-01 #10 .....####################.....#########################..... +11-02 #99 ........................................##########.......... +11-03 #10 ........................#####............................... +11-04 #99 ....................................##########.............. +11-05 #99 .............................................##########..... +``` + +The columns are Date, which shows the month-day portion of the relevant day; ID, which shows the guard on duty that day; and Minute, which shows the minutes during which the guard was asleep within the midnight hour. (The Minute column's header shows the minute's ten's digit in the first row and the one's digit in the second row.) Awake is shown as `.`, and asleep is shown as `#`. + +Note that guards count as asleep on the minute they fall asleep, and they count as awake on the minute they wake up. For example, because Guard #10 wakes up at 00:25 on 1518-11-01, minute 25 is marked as awake. + +If you can figure out the guard most likely to be asleep at a specific time, you might be able to trick that guard into working tonight so you can have the best chance of sneaking in. You have two strategies for choosing the best guard/minute combination. + +**Strategy 1:** Find the guard that has the most minutes asleep. What minute does that guard spend asleep the most? + +In the example above, Guard #10 spent the most minutes asleep, a total of 50 minutes (20+25+5), while Guard #99 only slept for a total of 30 minutes (10+10+10). Guard #**10** was asleep most during minute **24** (on two days, whereas any other minute the guard was asleep was only seen on one day). + +While this example listed the entries in chronological order, your entries are in the order you found them. You'll need to organize them before they can be analyzed. + +**What is the ID of the guard you chose multiplied by the minute you chose?** (In the above example, the answer would be `10 * 24 = 240`.) + +## Part 2 + +**Strategy 2:** Of all guards, which guard is most frequently asleep on the same minute? + +In the example above, Guard #**99** spent minute **45** asleep more than any other guard or minute - three times in total. (In all other cases, any guard spent any minute asleep at most twice.) + +**What is the ID of the guard you chose multiplied by the minute you chose?** (In the above example, the answer would be `99 * 45 = 4455`.) \ No newline at end of file diff --git a/2018/day04.py b/2018/04/code.py similarity index 91% rename from 2018/day04.py rename to 2018/04/code.py index 5df9514..0c485a2 100644 --- a/2018/day04.py +++ b/2018/04/code.py @@ -1,13 +1,8 @@ """ https://adventofcode.com/2018/day/4 """ def readFile(): - import os.path as p - dName = p.dirname(__file__) - fName = p.basename(__file__).split(".")[0] - - with open(p.join(dName, "input", f"{fName}.txt"), "r") as f: + with open(f"{__file__.rstrip('code.py')}input.txt", "r") as f: l = [line[:-1] for line in f.readlines()] - l.sort() return l diff --git a/2018/input/day04.txt b/2018/04/input.txt similarity index 100% rename from 2018/input/day04.txt rename to 2018/04/input.txt diff --git a/2018/04/solution.txt b/2018/04/solution.txt new file mode 100644 index 0000000..ab5c13a --- /dev/null +++ b/2018/04/solution.txt @@ -0,0 +1,2 @@ +Part 1: 73646 +Part 2: 4727 \ No newline at end of file diff --git a/2018/05/README.md b/2018/05/README.md new file mode 100644 index 0000000..fb0e1c7 --- /dev/null +++ b/2018/05/README.md @@ -0,0 +1,48 @@ +# 2018 Day 5: Alchemical Reduction +Copyright (c) Eric Wastl +#### [Direct Link](https://adventofcode.com/2018/day/5) + +## Part 1 + +You've managed to sneak in to the prototype suit manufacturing lab. The Elves are making decent progress, but are still struggling with the suit's size reduction capabilities. + +While the very latest in 1518 alchemical technology might have solved their problem eventually, you can do better. You scan the chemical composition of the suit's material and discover that it is formed by extremely long [polymers](https://en.wikipedia.org/wiki/Polymer) (one of which is available as your puzzle input). + +The polymer is formed by smaller **units** which, when triggered, react with each other such that two adjacent units of the same type and opposite polarity are destroyed. Units' types are represented by letters; units' polarity is represented by capitalization. For instance, `r` and `R` are units with the same type but opposite polarity, whereas `r` and `s` are entirely different types and do not react. + +For example: + +- In `aA`, `a` and `A` react, leaving nothing behind. +- In `abBA`, `bB` destroys itself, leaving `aA`. As above, this then destroys itself, leaving nothing. +- In `abAB`, no two adjacent units are of the same type, and so nothing happens. +- In `aabAAB`, even though `aa` and `AA` are of the same type, their polarities match, and so nothing happens. + +Now, consider a larger example, `dabAcCaCBAcCcaDA`: + +``` +dabAcCaCBAcCcaDA The first 'cC' is removed. +dabAaCBAcCcaDA This creates 'Aa', which is removed. +dabCBAcCcaDA Either 'cC' or 'Cc' are removed (the result is the same). +dabCBAcaDA No further actions can be taken. +``` + +After all possible reactions, the resulting polymer contains **10 units**. + +**How many units remain after fully reacting the polymer you scanned?** (Note: in this puzzle and others, the input is large; if you copy/paste your input, make sure you get the whole thing.) + +## Part 2 + +Time to improve the polymer. + +One of the unit types is causing problems; it's preventing the polymer from collapsing as much as it should. Your goal is to figure out which unit type is causing the most problems, remove all instances of it (regardless of polarity), fully react the remaining polymer, and measure its length. + +For example, again using the polymer `dabAcCaCBAcCcaDA` from above: + +- Removing all `A`/`a` units produces `dbcCCBcCcD`. Fully reacting this polymer produces `dbCBcD`, which has length 6. +- Removing all `B`/`b` units produces `daAcCaCAcCcaDA`. Fully reacting this polymer produces `daCAcaDA`, which has length 8. +- Removing all `C`/`c` units produces `dabAaBAaDA`. Fully reacting this polymer produces `daDA`, which has length 4. +- Removing all `D`/`d` units produces `abAcCaCBAcCcaA`. Fully reacting this polymer produces `abCBAc`, which has length 6. + +In this example, removing all `C`/`c` units was best, producing the answer **4**. + +**What is the length of the shortest polymer you can produce** by removing all units of exactly one type and fully reacting the result? \ No newline at end of file diff --git a/2018/day05.py b/2018/05/code.py similarity index 79% rename from 2018/day05.py rename to 2018/05/code.py index 24f8c34..14ea505 100644 --- a/2018/day05.py +++ b/2018/05/code.py @@ -1,11 +1,7 @@ """ https://adventofcode.com/2018/day/5 """ def readFile(): - import os.path as p - dName = p.dirname(__file__) - fName = p.basename(__file__).split(".")[0] - - with open(p.join(dName, "input", f"{fName}.txt"), "r") as f: + with open(f"{__file__.rstrip('code.py')}input.txt", "r") as f: return list(f.read()) def part1(vals): diff --git a/2018/input/day05.txt b/2018/05/input.txt similarity index 100% rename from 2018/input/day05.txt rename to 2018/05/input.txt diff --git a/2018/05/solution.txt b/2018/05/solution.txt new file mode 100644 index 0000000..6a9fb6c --- /dev/null +++ b/2018/05/solution.txt @@ -0,0 +1,2 @@ +Part 1: 10496 +Part 2: 5774 \ No newline at end of file diff --git a/2018/06/README.md b/2018/06/README.md new file mode 100644 index 0000000..b806fd0 --- /dev/null +++ b/2018/06/README.md @@ -0,0 +1,99 @@ +# 2018 Day 6: Chronal Coordinates +Copyright (c) Eric Wastl +#### [Direct Link](https://adventofcode.com/2018/day/6) + +## Part 1 + +The device on your wrist beeps several times, and once again you feel like you're falling. + +"Situation critical," the device announces. "Destination indeterminate. Chronal interference detected. Please specify new target coordinates." + +The device then produces a list of coordinates (your puzzle input). Are they places it thinks are safe or dangerous? It recommends you check manual page 729. The Elves did not give you a manual. + +**If they're dangerous**, maybe you can minimize the danger by finding the coordinate that gives the largest distance from the other points. + +Using only the [Manhattan distance](https://en.wikipedia.org/wiki/Taxicab_geometry), determine the **area** around each coordinate by counting the number of [integer](https://en.wikipedia.org/wiki/Integer) X,Y locations that are **closest** to that coordinate (and aren't **tied in distance** to any other coordinate). + +Your goal is to find the size of the **largest area** that isn't infinite. For example, consider the following list of coordinates: + +``` +1, 1 +1, 6 +8, 3 +3, 4 +5, 5 +8, 9 +``` + +If we name these coordinates `A` through `F`, we can draw them on a grid, putting `0,0` at the top left: + +``` +.......... +.A........ +.......... +........C. +...D...... +.....E.... +.B........ +.......... +.......... +........F. +``` + +This view is partial - the actual grid extends infinitely in all directions. Using the Manhattan distance, each location's closest coordinate can be determined, shown here in lowercase: + +``` +aaaaa.cccc +aAaaa.cccc +aaaddecccc +aadddeccCc +..dDdeeccc +bb.deEeecc +bBb.eeee.. +bbb.eeefff +bbb.eeffff +bbb.ffffFf +``` + +Locations shown as `.` are equally far from two or more coordinates, and so they don't count as being closest to any. + +In this example, the areas of coordinates A, B, C, and F are infinite - while not shown here, their areas extend forever outside the visible grid. However, the areas of coordinates D and E are finite: D is closest to 9 locations, and E is closest to 17 (both including the coordinate's location itself). Therefore, in this example, the size of the largest area is **17**. + +**What is the size of the largest area** that isn't infinite? + +## Part 2 + +On the other hand, **if the coordinates are safe**, maybe the best you can do is try to find a **region** near as many coordinates as possible. + +For example, suppose you want the sum of the [Manhattan distance](https://en.wikipedia.org/wiki/Taxicab_geometry) to all of the coordinates to be **less than 32**. For each location, add up the distances to all of the given coordinates; if the total of those distances is less than 32, that location is within the desired region. Using the same coordinates as above, the resulting region looks like this: + +``` +.......... +.A........ +.......... +...###..C. +..#D###... +..###E#... +.B.###.... +.......... +.......... +........F. +``` + +In particular, consider the highlighted location `4,3` located at the top middle of the region. Its calculation is as follows, where `abs()` is the [absolute value](https://en.wikipedia.org/wiki/Absolute_value) function: + +- Distance to coordinate A: `abs(4-1) + abs(3-1) = 5` +- Distance to coordinate B: `abs(4-1) + abs(3-6) = 6` +- Distance to coordinate C: `abs(4-8) + abs(3-3) = 4` +- Distance to coordinate D: `abs(4-3) + abs(3-4) = 2` +- Distance to coordinate E: `abs(4-5) + abs(3-5) = 3` +- Distance to coordinate F: `abs(4-8) + abs(3-9) = 10` +- Total distance: `5 + 6 + 4 + 2 + 3 + 10 = 30` + +Because the total distance to all coordinates (`30`) is less than 32, the location is **within** the region. + +This region, which also includes coordinates D and E, has a total size of **16**. + +Your actual region will need to be much larger than this example, though, instead including all locations with a total distance of less than **10000**. + +**What is the size of the region containing all locations which have a total distance to all given coordinates of less than 10000?** \ No newline at end of file diff --git a/2018/day06.py b/2018/06/code.py similarity index 94% rename from 2018/day06.py rename to 2018/06/code.py index 3449aaa..8c76a9e 100644 --- a/2018/day06.py +++ b/2018/06/code.py @@ -1,11 +1,7 @@ """ https://adventofcode.com/2018/day/6 """ def readFile(): - import os.path as p - dName = p.dirname(__file__) - fName = p.basename(__file__).split(".")[0] - - with open(p.join(dName, "input", f"{fName}.txt"), "r") as f: + with open(f"{__file__.rstrip('code.py')}input.txt", "r") as f: lines = [line[:-1].split(", ") for line in f.readlines()] return [Point(int(line[0]), int(line[1])) for line in lines] diff --git a/2018/input/day06.txt b/2018/06/input.txt similarity index 100% rename from 2018/input/day06.txt rename to 2018/06/input.txt diff --git a/2018/06/solution.txt b/2018/06/solution.txt new file mode 100644 index 0000000..0cc120e --- /dev/null +++ b/2018/06/solution.txt @@ -0,0 +1,2 @@ +Part 1: 3251 +Part 2: 47841 \ No newline at end of file diff --git a/2018/07/README.md b/2018/07/README.md new file mode 100644 index 0000000..a16329e --- /dev/null +++ b/2018/07/README.md @@ -0,0 +1,84 @@ +# 2018 Day 7: The Sum of Its Parts +Copyright (c) Eric Wastl +#### [Direct Link](https://adventofcode.com/2018/day/7) + +## Part 1 + +You find yourself standing on a snow-covered coastline; apparently, you landed a little off course. The region is too hilly to see the North Pole from here, but you do spot some Elves that seem to be trying to unpack something that washed ashore. It's quite cold out, so you decide to risk creating a paradox by asking them for directions. + +"Oh, are you the search party?" Somehow, you can understand whatever Elves from the year 1018 speak; you assume it's [Ancient Nordic Elvish](https://adventofcode.com/2015/day/6). Could the device on your wrist also be a translator? "Those clothes don't look very warm; take this." They hand you a heavy coat. + +"We do need to find our way back to the North Pole, but we have higher priorities at the moment. You see, believe it or not, this box contains something that will solve all of Santa's transportation problems - at least, that's what it looks like from the pictures in the instructions." It doesn't seem like they can read whatever language it's in, but you can: "Sleigh kit. Some assembly required." + +"'Sleigh'? What a wonderful name! You must help us assemble this 'sleigh' at once!" They start excitedly pulling more parts out of the box. + +The instructions specify a series of **steps** and requirements about which steps must be finished before others can begin (your puzzle input). Each step is designated by a single letter. For example, suppose you have the following instructions: + +``` +Step C must be finished before step A can begin. +Step C must be finished before step F can begin. +Step A must be finished before step B can begin. +Step A must be finished before step D can begin. +Step B must be finished before step E can begin. +Step D must be finished before step E can begin. +Step F must be finished before step E can begin. +``` + +Visually, these requirements look like this: + +``` + -->A--->B-- + / \ \ +C -->D----->E + \ / + ---->F----- +``` + +Your first goal is to determine the order in which the steps should be completed. If more than one step is ready, choose the step which is first alphabetically. In this example, the steps would be completed as follows: + +- Only **`C`** is available, and so it is done first. +- Next, both `A` and `F` are available. **`A`** is first alphabetically, so it is done next. +- Then, even though `F` was available earlier, steps `B` and `D` are now also available, and **`B`** is the first alphabetically of the three. +- After that, only `D` and `F` are available. `E` is not available because only some of its prerequisites are complete. Therefore, **`D`** is completed next. +- **`F`** is the only choice, so it is done next. +- Finally, **`E`** is completed. + +So, in this example, the correct order is `CABDFE`. + +**In what order should the steps in your instructions be completed?** + +## Part 2 + +As you're about to begin construction, four of the Elves offer to help. "The sun will set soon; it'll go faster if we work together." Now, you need to account for multiple people working on steps simultaneously. If multiple steps are available, workers should still begin them in alphabetical order. + +Each step takes 60 seconds plus an amount corresponding to its letter: A=1, B=2, C=3, and so on. So, step A takes `60+1=61` seconds, while step Z takes `60+26=86` seconds. No time is required between steps. + +To simplify things for the example, however, suppose you only have help from one Elf (a total of two workers) and that each step takes 60 fewer seconds (so that step A takes 1 second and step Z takes 26 seconds). Then, using the same instructions as above, this is how each second would be spent: + +``` +Second Worker 1 Worker 2 Done + 0 C . + 1 C . + 2 C . + 3 A F C + 4 B F CA + 5 B F CA + 6 D F CAB + 7 D F CAB + 8 D F CAB + 9 D . CABF + 10 E . CABFD + 11 E . CABFD + 12 E . CABFD + 13 E . CABFD + 14 E . CABFD + 15 . . CABFDE +``` + +Each row represents one second of time. The Second column identifies how many seconds have passed as of the beginning of that second. Each worker column shows the step that worker is currently doing (or `.` if they are idle). The Done column shows completed steps. + +Note that the order of the steps has changed; this is because steps now take time to finish and multiple workers can begin multiple steps simultaneously. + +In this example, it would take **15** seconds for two workers to complete these steps. + +With 5 workers and the **60+ second** step durations described above, **how long will it take to complete all of the steps**? diff --git a/2018/day07.py b/2018/07/code.py similarity index 94% rename from 2018/day07.py rename to 2018/07/code.py index 1c32865..a0d0946 100644 --- a/2018/day07.py +++ b/2018/07/code.py @@ -1,12 +1,8 @@ """ https://adventofcode.com/2018/day/5 """ def readFile(): - import os.path as p - dName = p.dirname(__file__) - fName = p.basename(__file__).split(".")[0] - nodes = {} - with open(p.join(dName, "input", f"{fName}.txt"), "r") as f: + with open(f"{__file__.rstrip('code.py')}input.txt", "r") as f: lines = [(line[5:6], line[36:37]) for line in f.readlines()] for l in lines: if l[0] not in nodes: diff --git a/2018/input/day07.txt b/2018/07/input.txt similarity index 100% rename from 2018/input/day07.txt rename to 2018/07/input.txt diff --git a/2018/07/solution.txt b/2018/07/solution.txt new file mode 100644 index 0000000..3264446 --- /dev/null +++ b/2018/07/solution.txt @@ -0,0 +1,2 @@ +Part 1: ADEFKLBVJQWUXCNGORTMYSIHPZ +Part 2: 1120 \ No newline at end of file diff --git a/2018/08/README.md b/2018/08/README.md new file mode 100644 index 0000000..7a4600a --- /dev/null +++ b/2018/08/README.md @@ -0,0 +1,60 @@ +# 2018 Day 8: Memory Maneuver +Copyright (c) Eric Wastl +#### [Direct Link](https://adventofcode.com/2018/day/8) + +## Part 1 + +The sleigh is much easier to pull than you'd expect for something its weight. Unfortunately, neither you nor the Elves know which way the North Pole is from here. + +You check your wrist device for anything that might help. It seems to have some kind of navigation system! Activating the navigation system produces more bad news: "Failed to start navigation system. Could not read software license file." + +The navigation system's license file consists of a list of numbers (your puzzle input). The numbers define a data structure which, when processed, produces some kind of [tree](https://en.wikipedia.org/wiki/Tree_(data_structure)) that can be used to calculate the license number. + +The **tree** is made up of **nodes**; a single, outermost node forms the tree's root, and it contains all other nodes in the tree (or contains nodes that contain nodes, and so on). + +Specifically, a node consists of: + +- A **header**, which is always exactly two numbers: + - The quantity of child nodes. + - The quantity of metadata entries. +- Zero or more **child nodes** (as specified in the header). +- One or more **metadata entries** (as specified in the header). + +Each child node is itself a node that has its own header, child nodes, and metadata. For example: + +``` +2 3 0 3 10 11 12 1 1 0 1 99 2 1 1 2 +A---------------------------------- + B----------- C----------- + D----- +``` + +In this example, each node of the tree is also marked with an underline starting with a letter for easier identification. In it, there are four nodes: + +- `A`, which has `2` child nodes (`B`, `C`) and `3` metadata entries (`1`, `1`, `2`). +- `B`, which has `0` child nodes and `3` metadata entries (`10`, `11`, `12`). +- `C`, which has `1` child node (`D`) and `1` metadata entry (`2`). +- `D`, which has `0` child nodes and `1` metadata entry (`99`). + +The first check done on the license file is to simply add up all of the metadata entries. In this example, that sum is `1+1+2+10+11+12+2+99=138`. + +**What is the sum of all metadata entries?** + +## Part 2 + +The second check is slightly more complicated: you need to find the value of the root node (`A` in the example above). + +The **value of a node** depends on whether it has child nodes. + +If a node has **no child nodes**, its value is the sum of its metadata entries. So, the value of node `B` is `10+11+12=33`, and the value of node `D` is `99`. + +However, if a node **does have child nodes**, the metadata entries become indexes which refer to those child nodes. A metadata entry of `1` refers to the first child node, `2` to the second, `3` to the third, and so on. The value of this node is the sum of the values of the child nodes referenced by the metadata entries. If a referenced child node does not exist, that reference is skipped. A child node can be referenced multiple time and counts each time it is referenced. A metadata entry of `0` does not refer to any child node. + +For example, again using the above nodes: + +- Node `C` has one metadata entry, `2`. Because node `C` has only one child node, `2` references a child node which does not exist, and so the value of node `C` is `0`. +- Node `A` has three metadata entries: `1`, `1`, and `2`. The `1` references node `A`'s first child node, `B`, and the `2` references node `A`'s second child node, `C`. Because node `B` has a value of `33` and node `C` has a value of `0`, the value of node `A` is `33+33+0=66`. + +So, in this example, the value of the root node is `66`. + +**What is the value of the root node?** \ No newline at end of file diff --git a/2018/day08.py b/2018/08/code.py similarity index 91% rename from 2018/day08.py rename to 2018/08/code.py index 4514823..a65b49d 100644 --- a/2018/day08.py +++ b/2018/08/code.py @@ -1,11 +1,7 @@ """ https://adventofcode.com/2018/day/8 """ def readFile(): - import os.path as p - dName = p.dirname(__file__) - fName = p.basename(__file__).split(".")[0] - - with open(p.join(dName, "input", f"{fName}.txt"), "r") as f: + with open(f"{__file__.rstrip('code.py')}input.txt", "r") as f: data = f.read() return [int(val) for val in data.split(" ")] diff --git a/2018/input/day08.txt b/2018/08/input.txt similarity index 100% rename from 2018/input/day08.txt rename to 2018/08/input.txt diff --git a/2018/08/solution.txt b/2018/08/solution.txt new file mode 100644 index 0000000..0d6cc71 --- /dev/null +++ b/2018/08/solution.txt @@ -0,0 +1,2 @@ +Part 1: 42768 +Part 2: 34348 \ No newline at end of file diff --git a/2018/09/README.md b/2018/09/README.md new file mode 100644 index 0000000..1fd2e75 --- /dev/null +++ b/2018/09/README.md @@ -0,0 +1,64 @@ +# 2018 Day 9: Marble Mania +Copyright (c) Eric Wastl +#### [Direct Link](https://adventofcode.com/2018/day/9) + +## Part 1 + +You talk to the Elves while you wait for your navigation system to initialize. To pass the time, they introduce you to their favorite [marble](https://en.wikipedia.org/wiki/Marble_(toy)) game. + +The Elves play this game by taking turns arranging the marbles in a **circle** according to very particular rules. The marbles are numbered starting with `0` and increasing by `1` until every marble has a number. + +First, the marble numbered `0` is placed in the circle. At this point, while it contains only a single marble, it is still a circle: the marble is both clockwise from itself and counter-clockwise from itself. This marble is designated the **current marble**. + +Then, each Elf takes a turn placing the **lowest-numbered remaining marble** into the circle between the marbles that are `1` and `2` marbles **clockwise** of the current marble. (When the circle is large enough, this means that there is one marble between the marble that was just placed and the current marble.) The marble that was just placed then becomes the **current marble**. + +However, if the marble that is about to be placed has a number which is a multiple of `23`, **something entirely different happens**. First, the current player keeps the marble they would have placed, adding it to their **score**. In addition, the marble `7` marbles **counter-clockwise** from the current marble is **removed** from the circle and **also** added to the current player's score. The marble located immediately **clockwise** of the marble that was removed becomes the new **current marble**. + +For example, suppose there are 9 players. After the marble with value `0` is placed in the middle, each player (shown in square brackets) takes a turn. The result of each of those turns would produce circles of marbles like this, where clockwise is to the right and the resulting current marble is in parentheses: + +``` +[-] (0) +[1] 0 (1) +[2] 0 (2) 1 +[3] 0 2 1 (3) +[4] 0 (4) 2 1 3 +[5] 0 4 2 (5) 1 3 +[6] 0 4 2 5 1 (6) 3 +[7] 0 4 2 5 1 6 3 (7) +[8] 0 (8) 4 2 5 1 6 3 7 +[9] 0 8 4 (9) 2 5 1 6 3 7 +[1] 0 8 4 9 2(10) 5 1 6 3 7 +[2] 0 8 4 9 2 10 5(11) 1 6 3 7 +[3] 0 8 4 9 2 10 5 11 1(12) 6 3 7 +[4] 0 8 4 9 2 10 5 11 1 12 6(13) 3 7 +[5] 0 8 4 9 2 10 5 11 1 12 6 13 3(14) 7 +[6] 0 8 4 9 2 10 5 11 1 12 6 13 3 14 7(15) +[7] 0(16) 8 4 9 2 10 5 11 1 12 6 13 3 14 7 15 +[8] 0 16 8(17) 4 9 2 10 5 11 1 12 6 13 3 14 7 15 +[9] 0 16 8 17 4(18) 9 2 10 5 11 1 12 6 13 3 14 7 15 +[1] 0 16 8 17 4 18 9(19) 2 10 5 11 1 12 6 13 3 14 7 15 +[2] 0 16 8 17 4 18 9 19 2(20)10 5 11 1 12 6 13 3 14 7 15 +[3] 0 16 8 17 4 18 9 19 2 20 10(21) 5 11 1 12 6 13 3 14 7 15 +[4] 0 16 8 17 4 18 9 19 2 20 10 21 5(22)11 1 12 6 13 3 14 7 15 +[5] 0 16 8 17 4 18(19) 2 20 10 21 5 22 11 1 12 6 13 3 14 7 15 +[6] 0 16 8 17 4 18 19 2(24)20 10 21 5 22 11 1 12 6 13 3 14 7 15 +[7] 0 16 8 17 4 18 19 2 24 20(25)10 21 5 22 11 1 12 6 13 3 14 7 15 +``` + +The goal is to be the **player with the highest score** after the last marble is used up. Assuming the example above ends after the marble numbered `25`, the winning score is `23+9=**32**` (because player 5 kept marble `23` and removed marble `9`, while no other player got any points in this very short example game). + +Here are a few more examples: + +- `10` players; last marble is worth `1618` points: high score is **`8317`** +- `13` players; last marble is worth `7999` points: high score is **`146373`** +- `17` players; last marble is worth `1104` points: high score is **`2764`** +- `21` players; last marble is worth `6111` points: high score is **`54718`** +- `30` players; last marble is worth `5807` points: high score is **`37305`** + +**What is the winning Elf's score?** + +## Part 2 + +Amused by the speed of your answer, the Elves are curious: + +**What would the new winning Elf's score be if the number of the last marble were 100 times larger?** diff --git a/2018/day09.py b/2018/09/code.py similarity index 92% rename from 2018/day09.py rename to 2018/09/code.py index 269c192..55a9187 100644 --- a/2018/day09.py +++ b/2018/09/code.py @@ -1,11 +1,7 @@ """ https://adventofcode.com/2018/day/9 """ def readFile(): - import os.path as p - dName = p.dirname(__file__) - fName = p.basename(__file__).split(".")[0] - - with open(p.join(dName, "input", f"{fName}.txt"), "r") as f: + with open(f"{__file__.rstrip('code.py')}input.txt", "r") as f: data = f.read().split(" ") return (int(data[0]), int(data[6])) diff --git a/2018/input/day09.txt b/2018/09/input.txt similarity index 100% rename from 2018/input/day09.txt rename to 2018/09/input.txt diff --git a/2018/09/solution.txt b/2018/09/solution.txt new file mode 100644 index 0000000..684a62b --- /dev/null +++ b/2018/09/solution.txt @@ -0,0 +1,2 @@ +Part 1: 429287 +Part 2: 3624387659 \ No newline at end of file diff --git a/2018/10/README.md b/2018/10/README.md new file mode 100644 index 0000000..433e326 --- /dev/null +++ b/2018/10/README.md @@ -0,0 +1,157 @@ +# 2018 Day 10: The Stars Align +Copyright (c) Eric Wastl +#### [Direct Link](https://adventofcode.com/2018/day/10) + +## Part 1 + +It's no use; your navigation system simply isn't capable of providing walking directions in the arctic circle, and certainly not in 1018. + +The Elves suggest an alternative. In times like these, North Pole rescue operations will arrange points of light in the sky to guide missing Elves back to base. Unfortunately, the message is easy to miss: the points move slowly enough that it takes hours to align them, but have so much momentum that they only stay aligned for a second. If you blink at the wrong time, it might be hours before another message appears. + +You can see these points of light floating in the distance, and record their position in the sky and their velocity, the relative change in position per second (your puzzle input). The coordinates are all given from your perspective; given enough time, those positions and velocities will move the points into a cohesive message! + +Rather than wait, you decide to fast-forward the process and calculate what the points will eventually spell. + +For example, suppose you note the following points: + +``` +position=< 9, 1> velocity=< 0, 2> +position=< 7, 0> velocity=<-1, 0> +position=< 3, -2> velocity=<-1, 1> +position=< 6, 10> velocity=<-2, -1> +position=< 2, -4> velocity=< 2, 2> +position=<-6, 10> velocity=< 2, -2> +position=< 1, 8> velocity=< 1, -1> +position=< 1, 7> velocity=< 1, 0> +position=<-3, 11> velocity=< 1, -2> +position=< 7, 6> velocity=<-1, -1> +position=<-2, 3> velocity=< 1, 0> +position=<-4, 3> velocity=< 2, 0> +position=<10, -3> velocity=<-1, 1> +position=< 5, 11> velocity=< 1, -2> +position=< 4, 7> velocity=< 0, -1> +position=< 8, -2> velocity=< 0, 1> +position=<15, 0> velocity=<-2, 0> +position=< 1, 6> velocity=< 1, 0> +position=< 8, 9> velocity=< 0, -1> +position=< 3, 3> velocity=<-1, 1> +position=< 0, 5> velocity=< 0, -1> +position=<-2, 2> velocity=< 2, 0> +position=< 5, -2> velocity=< 1, 2> +position=< 1, 4> velocity=< 2, 1> +position=<-2, 7> velocity=< 2, -2> +position=< 3, 6> velocity=<-1, -1> +position=< 5, 0> velocity=< 1, 0> +position=<-6, 0> velocity=< 2, 0> +position=< 5, 9> velocity=< 1, -2> +position=<14, 7> velocity=<-2, 0> +position=<-3, 6> velocity=< 2, -1> +``` + +Each line represents one point. Positions are given as `` pairs: X represents how far left (negative) or right (positive) the point appears, while Y represents how far up (negative) or down (positive) the point appears. + +At `0` seconds, each point has the position given. Each second, each point's velocity is added to its position. So, a point with velocity `<1, -2>` is moving to the right, but is moving upward twice as quickly. If this point's initial position were `<3, 9>`, after 3 seconds, its position would become `<6, 3>`. + +Over time, the points listed above would move like this: + +``` +Initially: +........#............. +................#..... +.........#.#..#....... +...................... +#..........#.#.......# +...............#...... +....#................. +..#.#....#............ +.......#.............. +......#............... +...#...#.#...#........ +....#..#..#.........#. +.......#.............. +...........#..#....... +#...........#......... +...#.......#.......... + +After 1 second: +...................... +...................... +..........#....#...... +........#.....#....... +..#.........#......#.. +...................... +......#............... +....##.........#...... +......#.#............. +.....##.##..#......... +........#.#........... +........#...#.....#... +..#...........#....... +....#.....#.#......... +...................... +...................... + +After 2 seconds: +...................... +...................... +...................... +..............#....... +....#..#...####..#.... +...................... +........#....#........ +......#.#............. +.......#...#.......... +.......#..#..#.#...... +....#....#.#.......... +.....#...#...##.#..... +........#............. +...................... +...................... +...................... + +After 3 seconds: +...................... +...................... +...................... +...................... +......#...#..###...... +......#...#...#....... +......#...#...#....... +......#####...#....... +......#...#...#....... +......#...#...#....... +......#...#...#....... +......#...#..###...... +...................... +...................... +...................... +...................... + +After 4 seconds: +...................... +...................... +...................... +............#......... +........##...#.#...... +......#.....#..#...... +.....#..##.##.#....... +.......##.#....#...... +...........#....#..... +..............#....... +....#......#...#...... +.....#.....##......... +...............#...... +...............#...... +...................... +...................... +``` + +After 3 seconds, the message appeared briefly: **`HI`**. Of course, your message will be much longer and will take many more seconds to appear. + +**What message will eventually appear in the sky?** + +## Part 2 + +Good thing you didn't have to wait, because that would have taken a long time - much longer than the **`3`** seconds in the example above. + +Impressed by your sub-hour communication capabilities, the Elves are curious: **exactly how many seconds would they have needed to wait for that message to appear?** \ No newline at end of file diff --git a/2018/day10.py b/2018/10/code.py similarity index 93% rename from 2018/day10.py rename to 2018/10/code.py index 1029394..8766f6a 100644 --- a/2018/day10.py +++ b/2018/10/code.py @@ -1,11 +1,7 @@ """ https://adventofcode.com/2018/day/10 """ def readFile(): - import os.path as p - dName = p.dirname(__file__) - fName = p.basename(__file__).split(".")[0] - - with open(p.join(dName, "input", f"{fName}.txt"), "r") as f: + with open(f"{__file__.rstrip('code.py')}input.txt", "r") as f: lines = f.readlines() points = [] for line in lines: diff --git a/2018/input/day10.txt b/2018/10/input.txt similarity index 100% rename from 2018/input/day10.txt rename to 2018/10/input.txt diff --git a/2018/10/solution.txt b/2018/10/solution.txt new file mode 100644 index 0000000..ebd92cd --- /dev/null +++ b/2018/10/solution.txt @@ -0,0 +1,12 @@ +Part 1: + # # # # # # . . . # # # # . . . # . . . . # . . # . . . . # . . . . . # # # . . # . . . . . . . . . . # # # . . # # # # # # + # . . . . . . . # . . . . # . . # . . . # . . . # . . . . # . . . . . . # . . . # . . . . . . . . . . . # . . . # . . . . . + # . . . . . . . # . . . . . . . # . . # . . . . . # . . # . . . . . . . # . . . # . . . . . . . . . . . # . . . # . . . . . + # . . . . . . . # . . . . . . . # . # . . . . . . # . . # . . . . . . . # . . . # . . . . . . . . . . . # . . . # . . . . . + # # # # # . . . # . . . . . . . # # . . . . . . . . # # . . . . . . . . # . . . # . . . . . . . . . . . # . . . # # # # # . + # . . . . . . . # . . . . . . . # # . . . . . . . . # # . . . . . . . . # . . . # . . . . . . . . . . . # . . . # . . . . . + # . . . . . . . # . . . . . . . # . # . . . . . . # . . # . . . . . . . # . . . # . . . . . . . . . . . # . . . # . . . . . + # . . . . . . . # . . . . . . . # . . # . . . . . # . . # . . . # . . . # . . . # . . . . . . . # . . . # . . . # . . . . . + # . . . . . . . # . . . . # . . # . . . # . . . # . . . . # . . # . . . # . . . # . . . . . . . # . . . # . . . # . . . . . + # # # # # # . . . # # # # . . . # . . . . # . . # . . . . # . . . # # # . . . . # # # # # # . . . # # # . . . . # . . . . . +Part 2: 10880 \ No newline at end of file diff --git a/2018/11/README.md b/2018/11/README.md new file mode 100644 index 0000000..b3dd803 --- /dev/null +++ b/2018/11/README.md @@ -0,0 +1,78 @@ +# 2018 Day 11: Chronal Charge +Copyright (c) Eric Wastl +#### [Direct Link](https://adventofcode.com/2018/day/11) + +## Part 1 + +You watch the Elves and their sleigh fade into the distance as they head toward the North Pole. + +Actually, you're the one fading. The falling sensation returns. + +The low fuel warning light is illuminated on your wrist-mounted device. Tapping it once causes it to project a hologram of the situation: a **300x300** grid of fuel cells and their current power levels, some negative. You're not sure what negative power means in the context of time travel, but it can't be good. + +Each fuel cell has a coordinate ranging from **1 to 300** in both the X (horizontal) and Y (vertical) direction. In `X,Y` notation, the top-left cell is `1,1`, and the top-right cell is `300,1`. + +The interface lets you select **any 3x3 square** of fuel cells. To increase your chances of getting to your destination, you decide to choose the 3x3 square with the **largest total power**. + +The power level in a given fuel cell can be found through the following process: + +- Find the fuel cell's **rack ID**, which is its **X coordinate plus 10**. +- Begin with a power level of the **rack ID** times the **Y coordinate**. +- Increase the power level by the value of the **grid serial number** (your puzzle input). +- Set the power level to itself multiplied by the **rack ID**. +- Keep only the **hundreds digit** of the power level (so `12345` becomes 3; numbers with no hundreds digit become `0`). +- **Subtract 5** from the power level. + +For example, to find the power level of the fuel cell at 3,5 in a grid with serial number `8`: + +- The rack ID is `3 + 10 = 13`. +- The power level starts at `13 * 5 = 65`. +- Adding the serial number produces `65 + 8 = 73`. +- Multiplying by the rack ID produces `73 * 13 = 949`. +- The hundreds digit of `949` is `9`. +- Subtracting 5 produces `9 - 5 = 4`. + +So, the power level of this fuel cell is **`4`**. + +Here are some more example power levels: + +- Fuel cell at `122, 79`, grid serial number `57`: power level `-5`. +- Fuel cell at `217,196`, grid serial number `39`: power level `0`. +- Fuel cell at `101,153`, grid serial number `71`: power level `4`. + +Your goal is to find the 3x3 square which has the largest total power. The square must be entirely within the 300x300 grid. Identify this square using the `X,Y` coordinate of its **top-left fuel cell**. For example: + +For grid serial number `18`, the largest total 3x3 square has a top-left corner of **`33,45`** (with a total power of `29`); these fuel cells appear in the middle of this 5x5 region: + +``` +-2 -4 4 4 4 +-4 4 4 4 -5 + 4 3 3 4 -4 + 1 1 2 4 -3 +-1 0 2 -5 -2 +``` + +For grid serial number `42`, the largest 3x3 square's top-left is **`21,61`** (with a total power of `30`); they are in the middle of this region: + +``` +-3 4 2 2 2 +-4 4 3 3 4 +-5 3 3 4 -4 + 4 3 3 4 -3 + 3 3 3 -5 -1 +``` + +**What is the `X,Y` coordinate of the top-left fuel cell of the 3x3 square with the largest total power?** + +## Part 2 + +You discover a dial on the side of the device; it seems to let you select a square of **any size**, not just 3x3. Sizes from 1x1 to 300x300 are supported. + +Realizing this, you now must find the **square of any size with the largest total power**. Identify this square by including its size as a third parameter after the top-left coordinate: a 9x9 square with a top-left corner of `3,5` is identified as `3,5,9`. + +For example: + +- For grid serial number `18`, the largest total square (with a total power of `113`) is 16x16 and has a top-left corner of `90,269`, so its identifier is **`90,269,16`**. +- For grid serial number `42`, the largest total square (with a total power of `119`) is 12x12 and has a top-left corner of `232,251`, so its identifier is **`232,251,12`**. + +**What is the X,Y,size identifier of the square with the largest total power?** \ No newline at end of file diff --git a/2018/day11.py b/2018/11/code.py similarity index 91% rename from 2018/day11.py rename to 2018/11/code.py index 9402a1f..4ffcd8e 100644 --- a/2018/day11.py +++ b/2018/11/code.py @@ -1,11 +1,7 @@ """ https://adventofcode.com/2018/day/11 """ def readFile(): - import os.path as p - dName = p.dirname(__file__) - fName = p.basename(__file__).split(".")[0] - - with open(p.join(dName, "input", f"{fName}.txt"), "r") as f: + with open(f"{__file__.rstrip('code.py')}input.txt", "r") as f: return int(f.read()) def getPowerlevel(x, y, serial): @@ -61,7 +57,7 @@ def getBiggestFieldSAT(sat, size): def part1(value): grid = createGrid(value) - return getBiggestField(grid, 3) + return getBiggestField(grid, 3)[0] def part2(value): grid = createGrid(value) diff --git a/2018/input/day11.txt b/2018/11/input.txt similarity index 100% rename from 2018/input/day11.txt rename to 2018/11/input.txt diff --git a/2018/11/solution.txt b/2018/11/solution.txt new file mode 100644 index 0000000..ccf1e7e --- /dev/null +++ b/2018/11/solution.txt @@ -0,0 +1,2 @@ +Part 1: (243, 16) +Part 2: (231, 227, 14) \ No newline at end of file diff --git a/2018/12/README.md b/2018/12/README.md new file mode 100644 index 0000000..8bdf48e --- /dev/null +++ b/2018/12/README.md @@ -0,0 +1,82 @@ +# 2018 Day 12: Subterranean Sustainability +Copyright (c) Eric Wastl +#### [Direct Link](https://adventofcode.com/2018/day/12) + +## Part 1 + +The year 518 is significantly more underground than your history books implied. Either that, or you've arrived in a vast cavern network under the North Pole. + +After exploring a little, you discover a long tunnel that contains a row of small pots as far as you can see to your left and right. A few of them contain plants - someone is trying to grow things in these geothermally-heated caves. + +The pots are numbered, with `0` in front of you. To the left, the pots are numbered `-1`, `-2`, `-3`, and so on; to the right, `1`, `2`, `3`.... Your puzzle input contains a list of pots from 0 to the right and whether they do (`#`) or do not (`.`) currently contain a plant, the initial state. (No other pots currently contain plants.) For example, an **initial state** of `#..##....` indicates that pots `0`, `3`, and `4` currently contain plants. + +Your puzzle input also contains some notes you find on a nearby table: someone has been trying to figure out how these plants **spread** to nearby pots. Based on the notes, for each generation of plants, a given pot has or does not have a plant based on whether that pot (and the two pots on either side of it) had a plant in the last generation. These are written as `LLCRR => N`, where `L` are pots to the left, `C` is the current pot being considered, `R` are the pots to the right, and `N` is whether the current pot will have a plant in the next generation. For example: + +- A note like `..#.. => .` means that a pot that contains a plant but with no plants within two pots of it will not have a plant in it during the next generation. +- A note like `##.## => .` means that an empty pot with two plants on each side of it will remain empty in the next generation. +- A note like `.##.# => #` means that a pot has a plant in a given generation if, in the previous generation, there were plants in that pot, the one immediately to the left, and the one two pots to the right, but not in the ones immediately to the right and two to the left. + +It's not clear what these plants are for, but you're sure it's important, so you'd like to make sure the current configuration of plants is sustainable by determining what will happen after **`20` generations**. + +For example, given the following input: + +``` +initial state: #..#.#..##......###...### + +...## => # +..#.. => # +.#... => # +.#.#. => # +.#.## => # +.##.. => # +.#### => # +#.#.# => # +#.### => # +##.#. => # +##.## => # +###.. => # +###.# => # +####. => # +``` + +For brevity, in this example, only the combinations which do produce a plant are listed. (Your input includes all possible combinations.) Then, the next 20 generations will look like this: + +``` + 1 2 3 + 0 0 0 0 + 0: ...#..#.#..##......###...###........... + 1: ...#...#....#.....#..#..#..#........... + 2: ...##..##...##....#..#..#..##.......... + 3: ..#.#...#..#.#....#..#..#...#.......... + 4: ...#.#..#...#.#...#..#..##..##......... + 5: ....#...##...#.#..#..#...#...#......... + 6: ....##.#.#....#...#..##..##..##........ + 7: ...#..###.#...##..#...#...#...#........ + 8: ...#....##.#.#.#..##..##..##..##....... + 9: ...##..#..#####....#...#...#...#....... +10: ..#.#..#...#.##....##..##..##..##...... +11: ...#...##...#.#...#.#...#...#...#...... +12: ...##.#.#....#.#...#.#..##..##..##..... +13: ..#..###.#....#.#...#....#...#...#..... +14: ..#....##.#....#.#..##...##..##..##.... +15: ..##..#..#.#....#....#..#.#...#...#.... +16: .#.#..#...#.#...##...#...#.#..##..##... +17: ..#...##...#.#.#.#...##...#....#...#... +18: ..##.#.#....#####.#.#.#...##...##..##.. +19: .#..###.#..#.#.#######.#.#.#..#.#...#.. +20: .#....##....#####...#######....#.#..##. +``` + +The generation is shown along the left, where `0` is the initial state. The pot numbers are shown along the top, where `0` labels the center pot, negative-numbered pots extend to the left, and positive pots extend toward the right. Remember, the initial state begins at pot `0`, which is not the leftmost pot used in this example. + +After one generation, only seven plants remain. The one in pot `0` matched the rule looking for `..#..`, the one in pot 4 matched the rule looking for `.#.#.`, pot 9 matched `.##..`, and so on. + +In this example, after 20 generations, the pots shown as `#` contain plants, the furthest left of which is pot `-2`, and the furthest right of which is pot `34`. Adding up all the numbers of plant-containing pots after the 20th generation produces **`325`**. + +**After `20` generations, what is the sum of the numbers of all pots which contain a plant?** + +## Part 2 + +You realize that 20 generations aren't enough. After all, these plants will need to last another 1500 years to even reach your timeline, not to mention your future. + +**After fifty billion (`50000000000`) generations, what is the sum of the numbers of all pots which contain a plant?** diff --git a/2018/day12.py b/2018/12/code.py similarity index 95% rename from 2018/day12.py rename to 2018/12/code.py index 8d71fa9..9c1b4ad 100644 --- a/2018/day12.py +++ b/2018/12/code.py @@ -1,11 +1,7 @@ """ https://adventofcode.com/2018/day/12 """ def readFile(): - import os.path as p - dName = p.dirname(__file__) - fName = p.basename(__file__).split(".")[0] - - with open(p.join(dName, "input", f"{fName}.txt"), "r") as f: + with open(f"{__file__.rstrip('code.py')}input.txt", "r") as f: lines = [line[:-1] for line in f.readlines()] state = list(lines[0][15:]) rules = [Rule(line) for line in lines[2:] if line[9] == "#"] diff --git a/2018/input/day12.txt b/2018/12/input.txt similarity index 100% rename from 2018/input/day12.txt rename to 2018/12/input.txt diff --git a/2018/12/solution.txt b/2018/12/solution.txt new file mode 100644 index 0000000..9633767 --- /dev/null +++ b/2018/12/solution.txt @@ -0,0 +1,2 @@ +Part 1: 3221 +Part 2: 2600000001872 \ No newline at end of file diff --git a/2018/13/README.md b/2018/13/README.md new file mode 100644 index 0000000..b915562 --- /dev/null +++ b/2018/13/README.md @@ -0,0 +1,222 @@ +# 2018 Day 13: Mine Cart Madness +Copyright (c) Eric Wastl +#### [Direct Link](https://adventofcode.com/2018/day/13) + +## Part 1 + +A crop of this size requires significant logistics to transport produce, soil, fertilizer, and so on. The Elves are very busy pushing things around in **carts** on some kind of rudimentary system of tracks they've come up with. + +Seeing as how cart-and-track systems don't appear in recorded history for another 1000 years, the Elves seem to be making this up as they go along. They haven't even figured out how to avoid collisions yet. + +You map out the tracks (your puzzle input) and see where you can help. + +Tracks consist of straight paths (`|` and `-`), curves (`/` and `\`), and intersections (`+`). Curves connect exactly two perpendicular pieces of track; for example, this is a closed loop: + +``` +/----\ +| | +| | +\----/ +``` + +Intersections occur when two perpendicular paths cross. At an intersection, a cart is capable of turning left, turning right, or continuing straight. Here are two loops connected by two intersections: + +``` +/-----\ +| | +| /--+--\ +| | | | +\--+--/ | + | | + \-----/ +``` + +Several **carts** are also on the tracks. Carts always face either up (`^`), down (`v`), left (`<`), or right (`>`). (On your initial map, the track under each cart is a straight path matching the direction the cart is facing.) + +Each time a cart has the option to turn (by arriving at any intersection), it turns **left** the first time, goes **straight** the second time, turns **right** the third time, and then repeats those directions starting again with **left** the fourth time, **straight** the fifth time, and so on. This process is independent of the particular intersection at which the cart has arrived - that is, the cart has no per-intersection memory. + +Carts all move at the same speed; they take turns moving a single step at a time. They do this based on their **current location**: carts on the top row move first (acting from left to right), then carts on the second row move (again from left to right), then carts on the third row, and so on. Once each cart has moved one step, the process repeats; each of these loops is called a **tick**. + +For example, suppose there are two carts on a straight track: + +``` +| | | | | +v | | | | +| v v | | +| | | v X +| | ^ ^ | +^ ^ | | | +| | | | | +``` + +First, the top cart moves. It is facing down (`v`), so it moves down one square. Second, the bottom cart moves. It is facing up (`^`), so it moves up one square. Because all carts have moved, the first tick ends. Then, the process repeats, starting with the first cart. The first cart moves down, then the second cart moves up - right into the first cart, colliding with it! (The location of the crash is marked with an `X`.) This ends the second and last tick. + +Here is a longer example: + +``` +/->-\ +| | /----\ +| /-+--+-\ | +| | | | v | +\-+-/ \-+--/ + \------/ + +/-->\ +| | /----\ +| /-+--+-\ | +| | | | | | +\-+-/ \->--/ + \------/ + +/---v +| | /----\ +| /-+--+-\ | +| | | | | | +\-+-/ \-+>-/ + \------/ + +/---\ +| v /----\ +| /-+--+-\ | +| | | | | | +\-+-/ \-+->/ + \------/ + +/---\ +| | /----\ +| /->--+-\ | +| | | | | | +\-+-/ \-+--^ + \------/ + +/---\ +| | /----\ +| /-+>-+-\ | +| | | | | ^ +\-+-/ \-+--/ + \------/ + +/---\ +| | /----\ +| /-+->+-\ ^ +| | | | | | +\-+-/ \-+--/ + \------/ + +/---\ +| | /----< +| /-+-->-\ | +| | | | | | +\-+-/ \-+--/ + \------/ + +/---\ +| | /---<\ +| /-+--+>\ | +| | | | | | +\-+-/ \-+--/ + \------/ + +/---\ +| | /--<-\ +| /-+--+-v | +| | | | | | +\-+-/ \-+--/ + \------/ + +/---\ +| | /-<--\ +| /-+--+-\ | +| | | | v | +\-+-/ \-+--/ + \------/ + +/---\ +| | /<---\ +| /-+--+-\ | +| | | | | | +\-+-/ \-<--/ + \------/ + +/---\ +| | v----\ +| /-+--+-\ | +| | | | | | +\-+-/ \<+--/ + \------/ + +/---\ +| | /----\ +| /-+--v-\ | +| | | | | | +\-+-/ ^-+--/ + \------/ + +/---\ +| | /----\ +| /-+--+-\ | +| | | X | | +\-+-/ \-+--/ + \------/ +``` + +After following their respective paths for a while, the carts eventually crash. To help prevent crashes, you'd like to know **the location of the first crash**. Locations are given in `X,Y` coordinates, where the furthest left column is `X=0` and the furthest top row is `Y=0`: + +``` + 111 + 0123456789012 +0/---\ +1| | /----\ +2| /-+--+-\ | +3| | | X | | +4\-+-/ \-+--/ +5 \------/ +``` + +In this example, the location of the first crash is **`7,3`**. + +## Part 2 + +There isn't much you can do to prevent crashes in this ridiculous system. However, by predicting the crashes, the Elves know where to be in advance and **instantly remove the two crashing carts** the moment any crash occurs. + +They can proceed like this for a while, but eventually, they're going to run out of carts. It could be useful to figure out where the last cart that **hasn't** crashed will end up. + +For example: + +``` +/>-<\ +| | +| /<+-\ +| | | v +\>+/ + +/---\ +| | +| v-+-\ +| | | | +\-+-/ | + | | + ^---^ + +/---\ +| | +| /-+-\ +| v | | +\-+-/ | + ^ ^ + \---/ + +/---\ +| | +| /-+-\ +| | | | +\-+-/ ^ + | | + \---/ +``` + +After four very expensive crashes, a tick ends with only one cart remaining; its final location is **`6,4`**. + +**What is the location of the last cart** at the end of the first tick where it is the only cart left? \ No newline at end of file diff --git a/2018/day13.py b/2018/13/code.py similarity index 97% rename from 2018/day13.py rename to 2018/13/code.py index d344caa..d6ef2d2 100644 --- a/2018/day13.py +++ b/2018/13/code.py @@ -1,9 +1,6 @@ """ https://adventofcode.com/2018/day/13 """ def readFile(test1 = False, test2 = False): - import os.path as p - dName = p.dirname(__file__) - fName = p.basename(__file__).split(".")[0] if test1: lines = [ [ "/", "-", ">", "-", "\\", " ", " ", " ", " ", " ", " ", " ", " ",], @@ -24,7 +21,7 @@ def readFile(test1 = False, test2 = False): [ " ", " ", "\\", "<", "-", ">", "/"] ] else: - with open(p.join(dName, "input", f"{fName}.txt"), "r") as f: + with open(f"{__file__.rstrip('code.py')}input.txt", "r") as f: lines = [list(line[:-1]) for line in f.readlines()] carts = [] diff --git a/2018/input/day13.txt b/2018/13/input.txt similarity index 100% rename from 2018/input/day13.txt rename to 2018/13/input.txt diff --git a/2018/13/solution.txt b/2018/13/solution.txt new file mode 100644 index 0000000..df4c8df --- /dev/null +++ b/2018/13/solution.txt @@ -0,0 +1,2 @@ +Part 1: 40,90 +Part 2: 65,81 \ No newline at end of file diff --git a/2018/14/README.md b/2018/14/README.md new file mode 100644 index 0000000..3fe7898 --- /dev/null +++ b/2018/14/README.md @@ -0,0 +1,58 @@ +# 2018 Day 14: Chocolate Charts +Copyright (c) Eric Wastl +#### [Direct Link](https://adventofcode.com/2018/day/14) + +## Part 1 + +You finally have a chance to look at all of the produce moving around. Chocolate, cinnamon, mint, chili peppers, nutmeg, vanilla... the Elves must be growing these plants to make **hot chocolate**! As you realize this, you hear a conversation in the distance. When you go to investigate, you discover two Elves in what appears to be a makeshift underground kitchen/laboratory. + +The Elves are trying to come up with the ultimate hot chocolate recipe; they're even maintaining a scoreboard which tracks the quality **score** (`0`-`9`) of each recipe. + +Only two recipes are on the board: the first recipe got a score of `3`, the second, `7`. Each of the two Elves has a **current recipe**: the first Elf starts with the first recipe, and the second Elf starts with the second recipe. + +To create new recipes, the two Elves combine their current recipes. This creates new recipes from the **digits of the sum** of the current recipes' scores. With the current recipes' scores of `3` and `7`, their sum is `10`, and so two new recipes would be created: the first with score `1` and the second with score `0`. If the current recipes' scores were `2` and `3`, the sum, `5`, would only create one recipe (with a score of `5`) with its single digit. + +The new recipes are added to the end of the scoreboard in the order they are created. So, after the first round, the scoreboard is `3, 7, 1, 0`. + +After all new recipes are added to the scoreboard, each Elf picks a new current recipe. To do this, the Elf steps forward through the scoreboard a number of recipes equal to **1 plus the score of their current recipe**. So, after the first round, the first Elf moves forward `1 + 3 = 4` times, while the second Elf moves forward `1 + 7 = 8` times. If they run out of recipes, they loop back around to the beginning. After the first round, both Elves happen to loop around until they land on the same recipe that they had in the beginning; in general, they will move to different recipes. + +Drawing the first Elf as parentheses and the second Elf as square brackets, they continue this process: + +``` +(3)[7] +(3)[7] 1 0 + 3 7 1 [0](1) 0 + 3 7 1 0 [1] 0 (1) +(3) 7 1 0 1 0 [1] 2 + 3 7 1 0 (1) 0 1 2 [4] + 3 7 1 [0] 1 0 (1) 2 4 5 + 3 7 1 0 [1] 0 1 2 (4) 5 1 + 3 (7) 1 0 1 0 [1] 2 4 5 1 5 + 3 7 1 0 1 0 1 2 [4](5) 1 5 8 + 3 (7) 1 0 1 0 1 2 4 5 1 5 8 [9] + 3 7 1 0 1 0 1 [2] 4 (5) 1 5 8 9 1 6 + 3 7 1 0 1 0 1 2 4 5 [1] 5 8 9 1 (6) 7 + 3 7 1 0 (1) 0 1 2 4 5 1 5 [8] 9 1 6 7 7 + 3 7 [1] 0 1 0 (1) 2 4 5 1 5 8 9 1 6 7 7 9 + 3 7 1 0 [1] 0 1 2 (4) 5 1 5 8 9 1 6 7 7 9 2 +``` + +The Elves think their skill will improve after making a few recipes (your puzzle input). However, that could take ages; you can speed this up considerably by identifying **the scores of the ten recipes** after that. For example: + +- If the Elves think their skill will improve after making `9` recipes, the scores of the ten recipes **after** the first nine on the scoreboard would be `5158916779`(highlighted in the last line of the diagram). +- After `5` recipes, the scores of the next ten would be `0124515891`. +- After `18` recipes, the scores of the next ten would be `9251071085`. +- After `2018` recipes, the scores of the next ten would be `5941429882`. + +**What are the scores of the ten recipes immediately after the number of recipes in your puzzle input?** + +## Part 2 + +As it turns out, you got the Elves' plan backwards. They actually want to know how many recipes appear on the scoreboard to the left of the first recipes whose scores are the digits from your puzzle input. + +- `51589` first appears after `9` recipes. +- `01245` first appears after `5` recipes. +- `92510` first appears after `18` recipes. +- `59414` first appears after `2018` recipes. + +**How many recipes appear on the scoreboard to the left of the score sequence in your puzzle input?** diff --git a/2018/day14.py b/2018/14/code.py similarity index 88% rename from 2018/day14.py rename to 2018/14/code.py index c6873eb..e054e45 100644 --- a/2018/day14.py +++ b/2018/14/code.py @@ -1,11 +1,7 @@ """ https://adventofcode.com/2018/day/14 """ def readFile(): - import os.path as p - dName = p.dirname(__file__) - fName = p.basename(__file__).split(".")[0] - - with open(p.join(dName, "input", f"{fName}.txt"), "r") as f: + with open(f"{__file__.rstrip('code.py')}input.txt", "r") as f: return f.read() def part1(vals): diff --git a/2018/input/day14.txt b/2018/14/input.txt similarity index 100% rename from 2018/input/day14.txt rename to 2018/14/input.txt diff --git a/2018/14/solution.txt b/2018/14/solution.txt new file mode 100644 index 0000000..cf6d3b7 --- /dev/null +++ b/2018/14/solution.txt @@ -0,0 +1,2 @@ +Part 1: 8610321414 +Part 2: 20258123 \ No newline at end of file diff --git a/2018/README.md b/2018/README.md new file mode 100644 index 0000000..2f23f6f --- /dev/null +++ b/2018/README.md @@ -0,0 +1,13 @@ +# Advent of Code - 2018 + +#### [Direct Link](https://adventofcode.com/2018) + +## Intro + +"We've detected some temporal anomalies," one of Santa's Elves at the Temporal Anomaly Research and Detection Instrument Station tells you. She sounded pretty worried when she called you down here. "At 500-year intervals into the past, someone has been changing Santa's history!" + +"The good news is that the changes won't propagate to our time stream for another 25 days, and we have a device" - she attaches something to your wrist - "that will let you fix the changes with no such propagation delay. It's configured to send you 500 years further into the past every few days; that was the best we could do on such short notice." + +"The bad news is that we are detecting roughly **fifty** anomalies throughout time; the device will indicate fixed anomalies with **stars**. The other bad news is that we only have one device and you're the best person for the job! Good lu--" She taps a button on the device and you suddenly feel like you're falling. To save Christmas, you need to get all **fifty stars** by December 25th. + +Collect stars by solving puzzles. Two puzzles will be made available on each day in the Advent calendar; the second puzzle is unlocked when you complete the first. Each puzzle grants **one star**. Good luck! \ No newline at end of file diff --git a/2019/01/README.md b/2019/01/README.md index f676a47..f52f01a 100644 --- a/2019/01/README.md +++ b/2019/01/README.md @@ -1,5 +1,5 @@ # 2019 Day 1: The Tyranny of the Rocket Equation - +Copyright (c) Eric Wastl #### [Direct Link](https://adventofcode.com/2019/day/1) ## Part 1 diff --git a/2019/02/README.md b/2019/02/README.md index 78d9a49..2680932 100644 --- a/2019/02/README.md +++ b/2019/02/README.md @@ -1,5 +1,5 @@ # 2019 Day 2: 1202 Program Alarm - +Copyright (c) Eric Wastl #### [Direct Link](https://adventofcode.com/2019/day/2) ## Part 1 diff --git a/LICENSE b/LICENSE index 97376d7..af524b1 100644 --- a/LICENSE +++ b/LICENSE @@ -1,3 +1,5 @@ +Except stated below or otherwise stated, this code is licensed under: + MIT License Copyright (c) 2019 Akumatic @@ -19,3 +21,9 @@ AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + + + +Exceptions are especially all task descriptions and input files: + +Copyright (c) 2015 Eric Wastl \ No newline at end of file