diff --git a/.classpath b/.classpath index 5e8a55fe..b51d40f7 100644 --- a/.classpath +++ b/.classpath @@ -8,13 +8,14 @@ + - - + + @@ -23,5 +24,10 @@ + + + + + diff --git a/.gitignore b/.gitignore index 5f2dbe11..ab2cc913 100644 --- a/.gitignore +++ b/.gitignore @@ -10,3 +10,5 @@ buildNumber.properties # Avoid ignoring Maven wrapper jar file (.jar files are usually ignored) !/.mvn/wrapper/maven-wrapper.jar + +.classpath diff --git a/.settings/org.eclipse.core.resources.prefs b/.settings/org.eclipse.core.resources.prefs index f9fe3459..839d647e 100644 --- a/.settings/org.eclipse.core.resources.prefs +++ b/.settings/org.eclipse.core.resources.prefs @@ -1,4 +1,5 @@ eclipse.preferences.version=1 encoding//src/main/java=UTF-8 +encoding//src/main/resources=UTF-8 encoding//src/test/java=UTF-8 encoding/=UTF-8 diff --git a/.settings/org.eclipse.jdt.core.prefs b/.settings/org.eclipse.jdt.core.prefs index db24ee78..60af120b 100644 --- a/.settings/org.eclipse.jdt.core.prefs +++ b/.settings/org.eclipse.jdt.core.prefs @@ -1,15 +1,16 @@ eclipse.preferences.version=1 org.eclipse.jdt.core.compiler.codegen.inlineJsrBytecode=enabled -org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.8 +org.eclipse.jdt.core.compiler.codegen.methodParameters=do not generate +org.eclipse.jdt.core.compiler.codegen.targetPlatform=13 org.eclipse.jdt.core.compiler.codegen.unusedLocal=preserve -org.eclipse.jdt.core.compiler.compliance=1.8 +org.eclipse.jdt.core.compiler.compliance=13 org.eclipse.jdt.core.compiler.debug.lineNumber=generate org.eclipse.jdt.core.compiler.debug.localVariable=generate org.eclipse.jdt.core.compiler.debug.sourceFile=generate org.eclipse.jdt.core.compiler.problem.assertIdentifier=error -org.eclipse.jdt.core.compiler.problem.enablePreviewFeatures=disabled +org.eclipse.jdt.core.compiler.problem.enablePreviewFeatures=enabled org.eclipse.jdt.core.compiler.problem.enumIdentifier=error org.eclipse.jdt.core.compiler.problem.forbiddenReference=warning -org.eclipse.jdt.core.compiler.problem.reportPreviewFeatures=ignore -org.eclipse.jdt.core.compiler.release=disabled -org.eclipse.jdt.core.compiler.source=1.8 +org.eclipse.jdt.core.compiler.problem.reportPreviewFeatures=warning +org.eclipse.jdt.core.compiler.release=enabled +org.eclipse.jdt.core.compiler.source=13 diff --git a/README.md b/README.md index e8336bc7..1b4cf67c 100644 --- a/README.md +++ b/README.md @@ -1,2 +1,114 @@ # adventOfCode(2019) -Let's do this! Code first, refactor later(tm). +Let's do this! + +Days: +- [Day 1](https://github.com/SimonBaars/adventOfCode-2019/blob/master/src/main/java/com/sbaars/adventofcode2019/days/Day1.java) +- [Day 2](https://github.com/SimonBaars/adventOfCode-2019/blob/master/src/main/java/com/sbaars/adventofcode2019/days/Day2.java) +- [Day 3](https://github.com/SimonBaars/adventOfCode-2019/blob/master/src/main/java/com/sbaars/adventofcode2019/days/Day3.java) +- [Day 4](https://github.com/SimonBaars/adventOfCode-2019/blob/master/src/main/java/com/sbaars/adventofcode2019/days/Day4.java) +- [Day 5](https://github.com/SimonBaars/adventOfCode-2019/blob/master/src/main/java/com/sbaars/adventofcode2019/days/Day5.java) +- [Day 6](https://github.com/SimonBaars/adventOfCode-2019/blob/master/src/main/java/com/sbaars/adventofcode2019/days/Day6.java) +- [Day 7](https://github.com/SimonBaars/adventOfCode-2019/blob/master/src/main/java/com/sbaars/adventofcode2019/days/Day7.java) +- [Day 8](https://github.com/SimonBaars/adventOfCode-2019/blob/master/src/main/java/com/sbaars/adventofcode2019/days/Day8.java) +- [Day 9](https://github.com/SimonBaars/adventOfCode-2019/blob/master/src/main/java/com/sbaars/adventofcode2019/days/Day9.java) +- [Day 10](https://github.com/SimonBaars/adventOfCode-2019/blob/master/src/main/java/com/sbaars/adventofcode2019/days/Day10.java) +- [Day 11](https://github.com/SimonBaars/adventOfCode-2019/blob/master/src/main/java/com/sbaars/adventofcode2019/days/Day11.java) +- [Day 12](https://github.com/SimonBaars/adventOfCode-2019/blob/master/src/main/java/com/sbaars/adventofcode2019/days/Day12.java) +- [Day 13](https://github.com/SimonBaars/adventOfCode-2019/blob/master/src/main/java/com/sbaars/adventofcode2019/days/Day13.java) +- [Day 14](https://github.com/SimonBaars/adventOfCode-2019/blob/master/src/main/java/com/sbaars/adventofcode2019/days/Day14.java) +- [Day 15](https://github.com/SimonBaars/adventOfCode-2019/blob/master/src/main/java/com/sbaars/adventofcode2019/days/Day15.java) +- [Day 16](https://github.com/SimonBaars/adventOfCode-2019/blob/master/src/main/java/com/sbaars/adventofcode2019/days/Day16.java) +- [Day 17](https://github.com/SimonBaars/adventOfCode-2019/blob/master/src/main/java/com/sbaars/adventofcode2019/days/Day17.java) +- [Day 18](https://github.com/SimonBaars/adventOfCode-2019/blob/master/src/main/java/com/sbaars/adventofcode2019/days/Day18.java) +- [Day 19](https://github.com/SimonBaars/adventOfCode-2019/blob/master/src/main/java/com/sbaars/adventofcode2019/days/Day19.java) + +Output of running [Main.java](https://github.com/SimonBaars/adventOfCode-2019/blob/master/src/main/java/com/sbaars/adventofcode2019/Main.java): +``` +Day 1: +Part 1: 3514064 +Part 2: 5268207 + +Day 2: +Part 1: 8017076 +Part 2: 3146 + +Day 3: +Part 1: 303 +Part 2: 11222 + +Day 4: +Part 1: 481 +Part 2: 299 + +Day 5: +Part 1: 11049715 +Part 2: 2140710 + +Day 6: +Part 1: 186597 +Part 2: 412 + +Day 7: +Part 1: 116680 +Part 2: 89603079 + +Day 8: +Part 1: 1360 +Part 2: +████ ███ █ █ ██ ███ +█ █ █ █ █ █ █ █ █ +███ █ █ █ █ █ █ █ █ +█ ███ █ █ ████ ███ +█ █ █ █ █ █ █ █ +█ █ ██ █ █ █ █ + +Day 9: +Part 1: 2518058886 +Part 2: 44292 + +Day 10: +Part 1: 299 +Part 2: 1419 + +Day 11: +Part 1: 2172 +Part 2: + ██ ████ █ ████ ████ ██ █ █ ███ + █ █ █ █ █ █ █ █ █ █ █ + █ ███ █ ███ ███ █ ████ █ █ + █ █ █ █ █ █ ██ █ █ ███ +█ █ █ █ █ █ █ █ █ █ █ + ██ ████ ████ ████ █ ███ █ █ █ + +Day 12: +Part 1: 13399 +Part 2: 312992287193064 + +Day 13: +Part 1: 320 +Part 2: 15156 + +Day 14: +Part 1: 485720 +Part 2: 3848998 + +Day 15: +Part 1: 380 +Part 2: 410 + +Day 16: +Part 1: 12541048 +Part 2: 62858988 + +Day 17: +Part 1: 7404 +Part 2: 929045 + +Day 18: +Part 1: 5402 +Part 2: 2138 + +Day 19: +Part 1: 179 +Part 2: 9760485 +``` \ No newline at end of file diff --git a/pom.xml b/pom.xml index 07702b4e..9f19708b 100644 --- a/pom.xml +++ b/pom.xml @@ -1,25 +1,45 @@ - - 4.0.0 + + 4.0.0 - com.sbaars - adventofcode2019 - 0.0.1-SNAPSHOT - jar + com.sbaars + adventofcode2019 + 0.0.1-SNAPSHOT + jar - adventofcode2019 - http://maven.apache.org + adventofcode2019 + http://maven.apache.org - - UTF-8 - + + UTF-8 + 8 + 13 + 13 + - - - junit - junit - 3.8.1 - test - - + + + junit + junit + 3.8.2 + test + + + org.projectlombok + lombok + 1.18.8 + compile + + + + + + maven-compiler-plugin + + 13 + + + + diff --git a/src/main/java/com/sbaars/adventofcode2019/Main.java b/src/main/java/com/sbaars/adventofcode2019/Main.java new file mode 100644 index 00000000..745d7c0d --- /dev/null +++ b/src/main/java/com/sbaars/adventofcode2019/Main.java @@ -0,0 +1,17 @@ +package com.sbaars.adventofcode2019; + +import java.io.IOException; +import java.lang.reflect.InvocationTargetException; + +import com.sbaars.adventofcode2019.common.Day; + +public class Main { + public static void main(String[] args) throws InstantiationException, IllegalAccessException, ClassNotFoundException, IOException, InvocationTargetException, NoSuchMethodException { + for(int day = 1; day<=19; day++) { + System.out.println("Day "+day+":"); + Day instance = (Day)Class.forName("com.sbaars.adventofcode2019.days.Day"+day).getDeclaredConstructor().newInstance(); + instance.printParts(); + System.out.println(); + } + } +} diff --git a/src/main/java/com/sbaars/adventofcode2019/common/Day.java b/src/main/java/com/sbaars/adventofcode2019/common/Day.java index caf3ee9d..badd6819 100644 --- a/src/main/java/com/sbaars/adventofcode2019/common/Day.java +++ b/src/main/java/com/sbaars/adventofcode2019/common/Day.java @@ -2,12 +2,14 @@ import java.io.IOException; -public interface Day { - public int part1() throws IOException; - public int part2() throws IOException; +import com.sbaars.adventofcode2019.util.DoesFileOperations; + +public interface Day extends DoesFileOperations { + public Object part1() throws IOException; + public Object part2() throws IOException; public default void printParts() throws IOException { - System.out.println("Part 1 = "+part1()); - System.out.println("Part 2 = "+part2()); + System.out.println("Part 1: "+part1()); + System.out.println("Part 2: "+part2()); } } diff --git a/src/main/java/com/sbaars/adventofcode2019/common/Direction.java b/src/main/java/com/sbaars/adventofcode2019/common/Direction.java new file mode 100644 index 00000000..fafe9ff1 --- /dev/null +++ b/src/main/java/com/sbaars/adventofcode2019/common/Direction.java @@ -0,0 +1,65 @@ +package com.sbaars.adventofcode2019.common; + +import java.awt.Point; +import java.util.Arrays; + +public enum Direction { + NORTH(1, 'U'), EAST(4, 'R'), SOUTH(2, 'D'), WEST(3, 'L'); + + public final int num; + public final int code; + + private Direction(int num, char code) { + this.num = num; + this.code = code; + } + + public static Direction getByDirCode(char code) { + return Arrays.stream(values()).filter(e -> e.code == code).findAny().get(); + } + + public Direction turn(boolean right) { + int cur = ordinal() + (right ? 1 : -1); + if(cur == Direction.values().length) cur = 0; + else if(cur == -1) cur = 3; + return Direction.values()[cur]; + } + + public Point move(Point currentLocation, int amount) { + switch (this) { + case SOUTH: return new Point(currentLocation.x, currentLocation.y+amount); + case NORTH: return new Point(currentLocation.x, currentLocation.y-amount); + case EAST: return new Point(currentLocation.x+amount, currentLocation.y); + case WEST: return new Point(currentLocation.x-amount, currentLocation.y); + } + throw new IllegalStateException("Non-existent Direction: "+this); + } + + public Point move(Point currentLocation) { + return move(currentLocation, 1); + } + + public Direction opposite() { + switch (this) { + case NORTH: return SOUTH; + case SOUTH: return NORTH; + case EAST: return WEST; + case WEST: return EAST; + } + throw new IllegalStateException("Non-existent Direction: "+this); + } + + public static Direction getByMove(Point from, Point to) { + if(to.x > from.x) return EAST; + else if(to.x < from.x) return WEST; + else if(to.y > from.y) return SOUTH; + else if(to.y < from.y) return NORTH; + throw new IllegalStateException("From and to location are the same: "+from+", "+to); + } + + public boolean leftOf(Direction robotDir) { + int n = this.ordinal()-1; + if(n == -1) n = values().length-1; + return robotDir.ordinal() == n; + } +} \ No newline at end of file diff --git a/src/main/java/com/sbaars/adventofcode2019/common/ProcessesImages.java b/src/main/java/com/sbaars/adventofcode2019/common/ProcessesImages.java new file mode 100644 index 00000000..e4de03c2 --- /dev/null +++ b/src/main/java/com/sbaars/adventofcode2019/common/ProcessesImages.java @@ -0,0 +1,10 @@ +package com.sbaars.adventofcode2019.common; + +import java.util.Arrays; +import java.util.stream.Collectors; + +public interface ProcessesImages { + public default String printAsciiArray(int[][] pixels) { + return System.lineSeparator()+Arrays.stream(pixels).map(a -> Arrays.stream(a).boxed().map(x -> x == 0 ? " " : "█").collect(Collectors.joining())).collect(Collectors.joining(System.lineSeparator())); + } +} diff --git a/src/main/java/com/sbaars/adventofcode2019/days/Day1.java b/src/main/java/com/sbaars/adventofcode2019/days/Day1.java new file mode 100644 index 00000000..2aede117 --- /dev/null +++ b/src/main/java/com/sbaars/adventofcode2019/days/Day1.java @@ -0,0 +1,38 @@ +package com.sbaars.adventofcode2019.days; + +import java.io.IOException; +import java.util.Arrays; +import java.util.stream.IntStream; + +import com.sbaars.adventofcode2019.common.Day; + +public class Day1 implements Day +{ + public static void main(String[] args) throws IOException + { + new Day1().printParts(); + } + + @Override + public Object part1() throws IOException { + return createNumberStream().map(this::getFuel).sum(); + } + + @Override + public Object part2() throws IOException { + return createNumberStream().map(this::getRequiredFuel).sum(); + } + + private IntStream createNumberStream() throws IOException { + return Arrays.stream(readDay(1).split(System.lineSeparator())).mapToInt(Integer::parseInt); + } + + private int getRequiredFuel(int mass) { + int fuel = getFuel(mass); + return fuel>0 ? fuel+getRequiredFuel(fuel) : 0; + } + + private int getFuel(int mass) { + return (mass/3)-2; + } +} diff --git a/src/main/java/com/sbaars/adventofcode2019/days/Day10.java b/src/main/java/com/sbaars/adventofcode2019/days/Day10.java new file mode 100644 index 00000000..226b165c --- /dev/null +++ b/src/main/java/com/sbaars/adventofcode2019/days/Day10.java @@ -0,0 +1,78 @@ +package com.sbaars.adventofcode2019.days; + +import java.awt.Point; +import java.io.IOException; +import java.util.Arrays; +import java.util.List; +import java.util.OptionalDouble; +import java.util.stream.Collectors; +import java.util.stream.IntStream; + +import com.sbaars.adventofcode2019.common.Day; + +import lombok.EqualsAndHashCode; + +public class Day10 implements Day { + + private final List asteroids; + private Point baseLocation; + + public Day10() throws IOException { + String[] mapString = Arrays.stream(readDay(10).split(System.lineSeparator())).toArray(String[]::new); + this.asteroids = IntStream.range(0, mapString.length).boxed().flatMap(i -> IntStream.range(0, mapString[i].length()).mapToObj(j -> new Point(j, i))).filter(p -> mapString[p.y].charAt(p.x) == '#').collect(Collectors.toList()); + } + + public static void main(String[] args) throws IOException { + new Day10().printParts(); + } + + @Override + public Object part1() throws IOException { + long[] nVisible = new long[asteroids.size()]; + for(int i = 0; i nVisible[i] > nVisible[j] ? i : j).getAsInt()); + return Arrays.stream(nVisible).max().getAsLong(); + } + + @Override + public Object part2() throws IOException { + List asteroidList = asteroids.stream().map(e -> new Asteroid(baseLocation, e)).collect(Collectors.toList()); + Asteroid prevDestroyed = new Asteroid(); + for(int destroyed = 1; destroyed<200; destroyed++) { + Asteroid prev = prevDestroyed; + OptionalDouble nextRot = asteroidList.stream().mapToDouble(e -> e.rotation).filter(e -> e > prev.rotation).min(); + if(nextRot.isPresent()) { + double nextRotation = nextRot.getAsDouble(); + prevDestroyed = asteroidList.stream().filter(e -> e.rotation == nextRotation).reduce((a1, a2) -> a1.distance < a2.distance ? a1 : a2).get(); + asteroidList.remove(prevDestroyed); + } + } + return prevDestroyed.position.x*100+prevDestroyed.position.y; + } + + private long countNVisible(Point asteroid) { + return asteroids.stream().map(e -> new Asteroid(asteroid, e)).mapToDouble(e -> e.rotation).distinct().count(); + } + + @EqualsAndHashCode class Asteroid { + @EqualsAndHashCode.Exclude double rotation; + @EqualsAndHashCode.Exclude double distance; + Point position; + + public Asteroid(Point center, Point me) { + this.rotation = calcRotationAngleInDegrees(center, me); + this.distance = me.distance(center); + this.position = me; + } + + public Asteroid() { + this.rotation = Double.MIN_VALUE; + } + + private double calcRotationAngleInDegrees(Point centerPt, Point targetPt) { + double theta = Math.atan2(targetPt.y - centerPt.y, targetPt.x - centerPt.x) + Math.PI/2.0; + double angle = Math.toDegrees(theta); + return angle < 0 ? angle + 360 : angle; + } + } +} diff --git a/src/main/java/com/sbaars/adventofcode2019/days/Day11.java b/src/main/java/com/sbaars/adventofcode2019/days/Day11.java new file mode 100644 index 00000000..934b1201 --- /dev/null +++ b/src/main/java/com/sbaars/adventofcode2019/days/Day11.java @@ -0,0 +1,67 @@ +package com.sbaars.adventofcode2019.days; + +import java.awt.Point; +import java.io.IOException; +import java.util.HashSet; +import java.util.Set; + +import com.sbaars.adventofcode2019.common.Day; +import com.sbaars.adventofcode2019.common.Direction; +import com.sbaars.adventofcode2019.common.ProcessesImages; +import com.sbaars.adventofcode2019.intcode.IntcodeComputer; + +public class Day11 implements Day, ProcessesImages { + + public static void main(String[] args) throws IOException { + new Day11().printParts(); + } + + @Override + public Object part1() throws IOException { + return robotWalk(false); + } + + private Object robotWalk(boolean startWhite) throws IOException { + IntcodeComputer c = new IntcodeComputer(11); + Point currentLocation = new Point(0,0); + Direction dir = Direction.NORTH; + final Set paintedOnce = new HashSet<>(); + final Set whitePlaces = new HashSet<>(); + if(startWhite) + whitePlaces.add(currentLocation); + while(true) { + c.setInput(whitePlaces.contains(currentLocation) ? 1 : 0); + long paintColor = c.run(); + if(paintColor == IntcodeComputer.STOP_CODE) + break; + long turn = c.run(); + paintedOnce.add(currentLocation); + if(paintColor == 1L) { + whitePlaces.add(currentLocation); + } else if(paintColor == 0L) { + whitePlaces.remove(currentLocation); + } + + dir = dir.turn(turn == 1L); + currentLocation = dir.move(currentLocation); + } + return startWhite ? constructImage(whitePlaces) : paintedOnce.size(); + } + + private String constructImage(Set whitePlaces) { + int cornerX = whitePlaces.stream().mapToInt(e -> e.x).min().getAsInt(); + int cornerY = whitePlaces.stream().mapToInt(e -> e.y).min().getAsInt(); + whitePlaces.forEach(e -> e.move(e.x - cornerX, e.y - cornerY)); + int sizex = whitePlaces.stream().mapToInt(e -> e.x).max().getAsInt()+1; + int sizey = whitePlaces.stream().mapToInt(e -> e.y).max().getAsInt()+1; + int[][] places = new int[sizey][sizex]; + for(Point p : whitePlaces) + places[p.y][p.x] = 1; + return printAsciiArray(places); + } + + @Override + public Object part2() throws IOException { + return robotWalk(true); + } +} diff --git a/src/main/java/com/sbaars/adventofcode2019/days/Day12.java b/src/main/java/com/sbaars/adventofcode2019/days/Day12.java new file mode 100644 index 00000000..2d269051 --- /dev/null +++ b/src/main/java/com/sbaars/adventofcode2019/days/Day12.java @@ -0,0 +1,102 @@ +package com.sbaars.adventofcode2019.days; + +import java.io.IOException; +import java.util.Arrays; +import java.util.Collections; +import java.util.HashSet; + +import com.sbaars.adventofcode2019.common.Day; + +public class Day12 implements Day { + + int[][] moons = {{-5,6,-11},{-8,-4,-2},{1,16,4},{11,11,-4}}; + int[][] velocity = {{0,0,0},{0,0,0},{0,0,0},{0,0,0}}; + + public static void main(String[] args) throws IOException { + new Day12().printParts(); + } + + @Override + public Object part1() throws IOException { + for(int n = 0; n<1000; n++) { + determineVelocity(); + moveMoonsUsingVelocity(); + } + int[] res = new int[moons.length]; + for(int i = 0; i()); + long[] res = new long[sets.size()]; + for(long n = 0; true; n++) { + determineVelocity(); + moveMoonsUsingVelocity(); + + for(int i = 0; i x == 0)) { + return lcm(res); + } + } + } + } + } + + private void moveMoonsUsingVelocity() { + for(int i = 0; i moon2) { + velocity[i][dim]--; + velocity[j][dim]++; + } + } + } + } + } + + private static long gcd(long a, long b) { + while (b > 0) { + long temp = b; + b = a % b; // % is remainder + a = temp; + } + return a; + } + + private static long lcm(long a, long b) { + return a * (b / gcd(a, b)); + } + + private static long lcm(long[] input) { + long result = input[0]; + for(int i = 1; i < input.length; i++) result = lcm(result, input[i]); + return result; + } + + + short[][] copy(short[][] arr){ + short [][] myInt = new short[arr.length][]; + for(int i = 0; i < arr.length; i++) + myInt[i] = arr[i].clone(); + return myInt; + } +} diff --git a/src/main/java/com/sbaars/adventofcode2019/days/Day13.java b/src/main/java/com/sbaars/adventofcode2019/days/Day13.java new file mode 100644 index 00000000..dc288e2b --- /dev/null +++ b/src/main/java/com/sbaars/adventofcode2019/days/Day13.java @@ -0,0 +1,70 @@ +package com.sbaars.adventofcode2019.days; + +import java.awt.Point; +import java.io.IOException; +import java.util.HashSet; +import java.util.Set; +import java.util.concurrent.atomic.AtomicInteger; + +import com.sbaars.adventofcode2019.common.Day; +import com.sbaars.adventofcode2019.intcode.IntcodeComputer; + +public class Day13 implements Day { + + public static void main(String[] args) throws IOException { + new Day13().printParts(); + } + + @Override + public Object part1() throws IOException { + IntcodeComputer cp = new IntcodeComputer(13); + Set n = new HashSet(); + while(true) { + long x = cp.run(); + if(x == IntcodeComputer.STOP_CODE) return n.size(); + long y = cp.run(); + long tile = cp.run(); + if(tile == 2) + n.add(new Point(Math.toIntExact(x), Math.toIntExact(y))); + } + } + + @Override + public Object part2() throws IOException { + IntcodeComputer cp = new IntcodeComputer(13, 1); + cp.setElement(0, 2); + int[][] field = new int[21][38]; + int score = 0; + AtomicInteger paddlePos = new AtomicInteger(), ballPos = new AtomicInteger(); + while(true) { + long x = cp.run(); + if(x == IntcodeComputer.STOP_CODE) + return score; + long y = cp.run(); + long tile = cp.run(); + score = simulateField(cp, field, score, paddlePos, ballPos, Math.toIntExact(x), Math.toIntExact(y), Math.toIntExact(tile)); + } + } + + private int simulateField(IntcodeComputer cp, int[][] field, int score, AtomicInteger paddlePos, AtomicInteger ballPos, int x, int y, int tile) { + if(x == -1) + return tile; + else { + field[y][x] = tile; + if (tile == 3) { + paddlePos.set(x); + } else if (tile == 4) { + ballPos.set(x); + cp.setInput(provideInput(paddlePos, ballPos)); + } + } + return score; + } + + private int provideInput(AtomicInteger paddlePos, AtomicInteger ballPos) { + int ball = ballPos.get(), paddle = paddlePos.get(); + if(ball>paddle) return 1; + else if(ball()); + } + + private Trade getTrade(String key) { + return Arrays.stream(trades).filter(e -> e.output.item.equals(key)).findAny().get(); + } + + private long findCost(Item buyingItem, LongCountMap leftOver) { + if(buyingItem.item.equals("ORE")) + return buyingItem.amount; + else if(buyingItem.amount <= leftOver.get(buyingItem.item)) { + leftOver.increment(buyingItem.item, -buyingItem.amount); + return 0; + } + buyingItem.amount-=leftOver.get(buyingItem.item); + leftOver.put(buyingItem.item, 0L); + + return performTrade(buyingItem, leftOver); + } + + private long performTrade(Item buyingItem, LongCountMap leftOver) { + Trade fuelTrade = getTrade(buyingItem.item); + long timesApplied = (long)Math.ceil((double)buyingItem.amount/(double)fuelTrade.output.amount); + long totalCost = 0; + for(Item cost : fuelTrade.input) + totalCost+=findCost(new Item(cost.amount*timesApplied, cost.item), leftOver); + leftOver.increment(buyingItem.item, fuelTrade.output.amount * timesApplied - buyingItem.amount); + return totalCost; + } + + @Override + public Object part2() throws IOException { + long oreLeft = 1000000000000L; + long fuel = 1; + while(true) { + long cost = findCost(new Item(fuel + 1, "FUEL"), new LongCountMap<>()); + if (cost > oreLeft) { + return fuel; + } else { + fuel = Math.max(fuel + 1, (fuel + 1) * oreLeft / cost); + } + } + } + + class Trade { + private final Item[] input; + private final Item output; + + public Trade(String trade) { + String[] inputOutput = trade.split(" => "); + input = Arrays.stream(inputOutput[0].split(", ")).map(Item::new).toArray(Item[]::new); + output = new Item(inputOutput[1]); + } + } + + class Item { + private long amount; + private final String item; + + public Item(String item) { + String[] i = item.split(" "); + amount = Integer.parseInt(i[0]); + this.item = i[1]; + } + + public Item(long i, String string) { + amount = i; + item = string; + } + } +} diff --git a/src/main/java/com/sbaars/adventofcode2019/days/Day15.java b/src/main/java/com/sbaars/adventofcode2019/days/Day15.java new file mode 100644 index 00000000..4e3c10ed --- /dev/null +++ b/src/main/java/com/sbaars/adventofcode2019/days/Day15.java @@ -0,0 +1,99 @@ +package com.sbaars.adventofcode2019.days; + +import java.awt.Point; +import java.io.IOException; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.List; + +import com.sbaars.adventofcode2019.common.Day; +import com.sbaars.adventofcode2019.common.Direction; +import com.sbaars.adventofcode2019.intcode.IntcodeComputer; +import com.sbaars.adventofcode2019.pathfinding.Grid2d; + +public class Day15 implements Day { + + public static final int UNEXPLORED = 3; + public static final int WALL = 0; + private static final int PATH = 1; + private static final int FINISH = 2; + private static final int BOARD_SIZE = 41; + private static final Point START_POINT = new Point(BOARD_SIZE/2+1,BOARD_SIZE/2+1); + int[][] grid = new int[BOARD_SIZE][BOARD_SIZE]; + + public static void main(String[] args) throws IOException { + new Day15().printParts(); + } + + @Override + public Object part1() throws IOException { + IntcodeComputer ic = new IntcodeComputer(15); + Point pos = START_POINT; + for(int[] row : grid) Arrays.fill(row, UNEXPLORED); + grid[pos.y][pos.x] = 1; + while(true) { + explore(pos, ic); + pos = moveToUnexploredPlace(pos, ic); + if(pos == null) { + Grid2d map2d = new Grid2d(grid, false); + return map2d.findPath(START_POINT, findPos(FINISH).get(0)).size()-1; + } + } + } + + private Point moveToUnexploredPlace(Point pos, IntcodeComputer ic) { + List corridorSpaces = findPos(PATH); + for(Point p : corridorSpaces) { + if(hasAdjecent(p, UNEXPLORED)) { + Grid2d map2d = new Grid2d(grid, false); + List route = map2d.findPath(pos, p); + traverseRoute(ic, pos, route.subList(1, route.size())); + return p; + } + } + return null; + } + + private void traverseRoute(IntcodeComputer ic, Point pos, List route) { + for(Point p : route) { + if(ic.run(Direction.getByMove(pos, p).num)!=1L) + throw new IllegalStateException("Illegal state at "+pos+" execute to "+p); + pos = p; + } + } + + private boolean hasAdjecent(Point pos, int tile) { + return grid[pos.y+1][pos.x] == tile || grid[pos.y][pos.x+1] == tile || grid[pos.y-1][pos.x] == tile || grid[pos.y][pos.x-1] == tile; + } + + private List findPos(int tile) { + List positions = new ArrayList<>(); + for(int y = 0; y new Grid2d(grid, false).findPath(oxygenLeak, e).size()-1).max().getAsInt(); + } +} diff --git a/src/main/java/com/sbaars/adventofcode2019/days/Day16.java b/src/main/java/com/sbaars/adventofcode2019/days/Day16.java new file mode 100644 index 00000000..f2023f91 --- /dev/null +++ b/src/main/java/com/sbaars/adventofcode2019/days/Day16.java @@ -0,0 +1,68 @@ +package com.sbaars.adventofcode2019.days; + +import java.io.IOException; +import java.util.Arrays; +import java.util.stream.Collectors; +import java.util.stream.IntStream; + +import com.sbaars.adventofcode2019.common.Day; + +public class Day16 implements Day { + + private static final int TARGET_POS = 5977341; + private final int[] input; + + public Day16() throws IOException { + input = readDay(16).chars().map(e -> Character.getNumericValue(e)).toArray(); + } + + public static void main(String[] args) throws IOException { + new Day16().printParts(); + } + + @Override + public Object part1() throws IOException { + return calcRes(Arrays.copyOf(input, input.length), 0); + } + + @Override + public Object part2() throws IOException { + return calcRes(repeat(input, 10000), TARGET_POS); + } + + private Object calcRes(int[] nums, final int offset) { + int[] pattern = {0, 1, 0, -1}; + + int[] res = new int[nums.length]; + for(int phase = 0; phase<100; phase++) { + int[] newNums = new int[nums.length+1]; + for(int i=0;i= res.length) break; + loc=k; + } + res[i]=Math.abs(sum)%10; + } + + System.arraycopy(res, 0, nums, 0, res.length); + } + return IntStream.range(offset, offset+8).map(i -> res[i]).mapToObj(Integer::toString).collect(Collectors.joining()); + } + + public static int[] repeat(int[] arr, int newLength) { + newLength = newLength * arr.length; + int[] dup = Arrays.copyOf(arr, newLength); + for (int last = arr.length; last != 0 && last < newLength; last <<= 1) { + System.arraycopy(dup, 0, dup, last, Math.min(last << 1, newLength) - last); + } + return dup; + } + +} diff --git a/src/main/java/com/sbaars/adventofcode2019/days/Day17.java b/src/main/java/com/sbaars/adventofcode2019/days/Day17.java new file mode 100644 index 00000000..85431b73 --- /dev/null +++ b/src/main/java/com/sbaars/adventofcode2019/days/Day17.java @@ -0,0 +1,160 @@ +package com.sbaars.adventofcode2019.days; + +import java.awt.Point; +import java.io.IOException; +import java.util.ArrayList; +import java.util.List; +import java.util.stream.Collectors; +import java.util.stream.IntStream; + +import com.sbaars.adventofcode2019.common.Day; +import com.sbaars.adventofcode2019.common.Direction; +import com.sbaars.adventofcode2019.intcode.IntcodeComputer; + +import lombok.EqualsAndHashCode; + +public class Day17 implements Day { + + char[][] grid = new char[48][48]; + + public Day17() throws IOException { + IntcodeComputer ic = new IntcodeComputer(17, 1); + long res; + int x = 0, y =0; + while((res = ic.run()) != IntcodeComputer.STOP_CODE) { + if(res == 10) { + y++; + x= 0; + } else { + grid[y][x] = (char)res; + x++; + } + } + } + + public static void main(String[] args) throws IOException { + new Day17().printParts(); + } + + @Override + public Object part1() throws IOException { + int result = 0; + for(int y = 1; y instructions = new ArrayList<>(); + List traversed = new ArrayList<>(); + Direction dir; + Direction robotDir = Direction.NORTH; + while((dir = directionContainsSomethingAndUntraversed(grid, pos, traversed)) != null) { + int n; + for(n = 1; getGrid(grid, dir.move(pos, n)) == '#'; n++) traversed.add(dir.move(pos, n)); + pos = dir.move(pos, n-1); + instructions.add(new Instruction(n-1, dir.leftOf(robotDir) ? Dir.R : Dir.L)); + robotDir = dir; + } + String patterns = findPatterns(instructions) + "\nn\n"; + IntcodeComputer ic = new IntcodeComputer(17, 2); + ic.setInput(patterns); + while(true) { + long res = ic.run(); + if(res>255L) + return res; + } + } + + private String findPatterns(List instructions) { + List> patterns = new ArrayList<>(); + String patternString = ""; + int start = 0; + for(int i = 0; i pattern = existing(instructions, patterns, i); + if(pattern!=null && start == i) { + start += pattern.size(); + i+=pattern.size()-1; + patternString += ","+patterns.indexOf(pattern); + continue; + } else if(start!=i && (pattern != null || occurrences(instructions, instructions.subList(start, i+1))<3)) { + patternString += ","+patterns.size(); + patterns.add(instructions.subList(start, i)); + start = i; + i--; + } + } + return patternString.substring(1).replace("0", "A").replace("1", "B").replace("2", "C")+"\n"+patterns.stream().map(this::toString).collect(Collectors.joining("\n")); + } + + private List existing(List instructions, List> patterns, int i){ + for(List pattern : patterns) + if(i+pattern.size() <= instructions.size() && instructions.subList(i, i+pattern.size()).equals(pattern)) + return pattern; + return null; + } + + private int occurrences(List instructions, List subList) { + return Math.toIntExact(IntStream.range(0, instructions.size()-subList.size()).filter(i -> toString(instructions.subList(i, i+subList.size())).equals(toString(subList))).count()); + } + + public String toString(List i) { + return i.stream().map(Instruction::toString).collect(Collectors.joining(",")); + } + + private char getGrid(char[][] grid, Point p) { + if(p.x < 0 || p.y < 0 || p.x>=grid[0].length || p.y>=grid.length) return '.'; + return grid[p.y][p.x]; + } + + private Direction directionContainsSomethingAndUntraversed(char[][] grid, Point pos, List traversed) { + Direction dir = Direction.NORTH; + for(int i = 0; i<4; i++) { + Point p = dir.move(pos); + if(getGrid(grid, p) == '#' && !traversed.contains(p)) { + return dir; + } + dir = dir.turn(true); + } + return null; + } + + private List findPos(char[][] grid, char tile) { + List positions = new ArrayList<>(); + for(int y = 0; y cachedResult = new HashMap<>(); + private static final char[][] CHANGE_GRID = { + {'@', '#', '@'}, + {'#', '#', '#'}, + {'@', '#', '@'} + }; + private final Point middle; + + public Day18() throws IOException { + grid = Arrays.stream(readDay(18).split(System.lineSeparator())).map(e -> e.toCharArray()).toArray(char[][]::new); + charGrid = new CharGrid2d(grid, false); + middle = findPos('@').get(0); + } + + public static void main(String[] args) throws IOException { + new Day18().printParts(); + } + + @Data @AllArgsConstructor class Route { + Point start; + Point end; + } + + @Data @AllArgsConstructor class State{ + List me; + TreeSet keys; + } + + @Override + public Object part1() throws IOException { + List me = new ArrayList<>(); + me.add(middle); + return findRoutes(me); + } + + private Object findRoutes(List me) { + List keys = findPos('a', 'z'); + Map> routes = new HashMap<>(); + List requiredRoutes = new ArrayList<>(keys); + requiredRoutes.addAll(me); + for(int i = 0; i r = charGrid.findPath(requiredRoutes.get(i), requiredRoutes.get(j)); + if(!r.isEmpty()) + routes.put(new Route(requiredRoutes.get(i), requiredRoutes.get(j)), r); + } + } + return findSteps(me, new TreeSet<>(), keys, routes); + } + + public List getRoute(Map> routes, Point p1, Point p2){ + List p = routes.get(new Route(p1, p2)); + if(p != null) + return p; + else return routes.get(new Route(p2, p1)); + } + + public boolean canTakeRoute(List route, TreeSet keys) { + for(Point p : route) { + if(grid[p.y][p.x]>='A' && grid[p.y][p.x]<='Z' && !keys.contains(grid[p.y][p.x])) { + return false; + } + } + return true; + } + + public int findSteps(List me, TreeSet collectedKeys, List keys, Map> routes) { + Integer cachedRes = cachedResult.get(new State(me, collectedKeys)); + if(cachedRes!=null) return cachedRes; + val possibleMoves = me.stream().flatMap(m -> keys.stream().map(p -> getRoute(routes, m, p))).filter(Objects::nonNull).filter(e -> canTakeRoute(e, collectedKeys)).collect(Collectors.toList()); + List nSteps = new ArrayList<>(); + for(List takenMove : possibleMoves) { + val myKeys = new TreeSet<>(collectedKeys); + val keyLocs = new ArrayList<>(keys); + Point newLoc = me.contains(takenMove.get(0)) ? takenMove.get(takenMove.size()-1) : takenMove.get(0); + Point oldLoc = me.contains(takenMove.get(0)) ? takenMove.get(0) : takenMove.get(takenMove.size()-1); + char collected = grid[newLoc.y][newLoc.x]; + myKeys.add(Character.toUpperCase(collected)); + keyLocs.remove(newLoc); + val me2 = new ArrayList<>(me); + me2.set(me.indexOf(oldLoc), newLoc); + nSteps.add(findSteps(me2, myKeys, keyLocs, routes) + takenMove.size()-1); + } + int res = nSteps.stream().mapToInt(e -> e).min().orElse(0); + cachedResult.put(new State(me, collectedKeys), res); + return res; + } + + private List findPos(char tile) { + List positions = new ArrayList<>(); + for(int y = 0; y findPos(char tile, char tile2) { + List positions = new ArrayList<>(); + for(int y = 0; y= tile && grid[y][x] <= tile2) + positions.add(new Point(x, y)); + } + } + return positions; + } + + @Override + public Object part2() throws IOException { + for(int y = 0; y portals = new HashMap<>(); + private final Map portalLabel = new HashMap<>(); + private final ListMap routes = new ListMap<>(); + private final List portalsToTake = new ArrayList<>(); + private Portal entry; + private Portal exit; + + @Data @AllArgsConstructor class Portal { + Point pos; + boolean isOuter; + } + + @Data @AllArgsConstructor class Route { + Portal goal; + int distance; + } + + @EqualsAndHashCode(callSuper = true) @ToString(callSuper = true) @AllArgsConstructor class State extends Visited { + int totalSteps; + + public State(int totalSteps, Visited vis) { + super(vis.pos, vis.level); + this.totalSteps = totalSteps; + } + } + + @Data @AllArgsConstructor @NoArgsConstructor class Visited { + Portal pos; + int level; + } + + public Day20() throws IOException { + grid = Arrays.stream(readDay(20).split(System.lineSeparator())).map(e -> e.toCharArray()).toArray(char[][]::new); + charGrid = new CharGrid2d(grid, false); + + int[] rows = {2, 26, 80, 104}; + for(int row : rows) { + boolean addPortal = row == rows[0] || row == rows[rows.length-1]; + for(int i = 2; i queue = new ArrayDeque<>(); + final Set visited = new HashSet<>(); + queue.add(new State(-1, new Visited(entry, 0))); + while(true) { + State s = queue.poll(); + if(!routes.containsKey(s.pos)) determineRoutes(s.pos); + for(Route route : routes.get(s.pos)) { + int level = s.level; + if(level == 0 && route.goal.equals(exit)) return route.distance + s.totalSteps; + else if(route.goal.equals(exit)) continue; + if(b) level+=route.goal.isOuter ? 1 : -1; + if(s.level < 0) continue; + Visited vis = new Visited(route.goal, level); + if(!visited.contains(vis)) { + visited.add(vis); + queue.add(new State(s.totalSteps + route.distance, vis)); + } + } + } + } + + private void determineRoutes(Portal p) { + for(Portal portal : portalsToTake) { + if(!portal.pos.equals(p.pos)) { + List route = charGrid.findPath(p.pos, portal.pos); + if(!route.isEmpty()) routes.addTo(p, new Route(teleport(portal), route.size())); + } + } + } + + private Portal teleport(Portal portal) { + Portal[] thisPortal = portals.get(portalLabel.get(portal)); + if(portal.equals(exit)) return exit; + if(portal.equals(thisPortal[0])) return thisPortal[1]; + return thisPortal[0]; + } + + @Override + public Object part2() throws IOException { + return findRoutes(true); + } +} diff --git a/src/main/java/com/sbaars/adventofcode2019/days/Day21.java b/src/main/java/com/sbaars/adventofcode2019/days/Day21.java new file mode 100644 index 00000000..9b1a3a73 --- /dev/null +++ b/src/main/java/com/sbaars/adventofcode2019/days/Day21.java @@ -0,0 +1,49 @@ +package com.sbaars.adventofcode2019.days; + +import java.io.IOException; + +import com.sbaars.adventofcode2019.common.Day; +import com.sbaars.adventofcode2019.intcode.IntcodeComputer; + +public class Day21 implements Day { + + public static void main(String[] args) throws IOException { + new Day21().printParts(); + } + + @Override + public Object part1() throws IOException { + IntcodeComputer ic = new IntcodeComputer(21); + // !(A && B && C) || D + ic.setInput("OR A T\n" + + "AND B T\n" + + "AND C T\n" + + "NOT T T\n" + //flip T + "AND D T\n" + + "OR T J\n" + + "WALK\n"); + long res; + while((res = ic.run()) != IntcodeComputer.STOP_CODE) + if(res>255) return res; + return 0; + } + + @Override + public Object part2() throws IOException { + IntcodeComputer ic = new IntcodeComputer(21); + // (((!B && H) || !A) || (!C && H)) && D + ic.setInput("NOT A J\n" + + "NOT B T\n" + + "AND H T\n" + + "OR T J\n" + + "NOT C T\n" + + "AND H T\n" + + "OR T J\n" + + "AND D J\n" + + "RUN\n"); + long res; + while((res = ic.run()) != IntcodeComputer.STOP_CODE) + if(res>255) return res; + return 0; + } +} diff --git a/src/main/java/com/sbaars/adventofcode2019/days/Day22.java b/src/main/java/com/sbaars/adventofcode2019/days/Day22.java new file mode 100644 index 00000000..4c6ad1e2 --- /dev/null +++ b/src/main/java/com/sbaars/adventofcode2019/days/Day22.java @@ -0,0 +1,122 @@ +package com.sbaars.adventofcode2019.days; + +import java.io.IOException; +import java.math.BigInteger; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.Collections; +import java.util.List; +import java.util.stream.Collectors; +import java.util.stream.IntStream; + +import com.sbaars.adventofcode2019.common.Day; + +import lombok.AllArgsConstructor; +import lombok.Data; +import lombok.Value; + +public class Day22 implements Day { + + Move[] moves; + + public Day22() throws IOException { + this.moves = Arrays.stream(readDay(22).split(System.lineSeparator())).map(Move::new).toArray(Move[]::new); + } + + public static void main(String[] args) throws IOException { + new Day22().printParts(); + } + + @AllArgsConstructor enum Action { + DEAL_WITH_INCREMENT("deal with increment "), + DEAL_NEW_STACK("deal into new stack"), + CUT("cut "); + + String name; + + public static Action actionByText(String text) { + return Arrays.stream(values()).filter(a -> text.startsWith(a.name)).findAny().get(); + } + } + + @Value @Data class Move { + Action action; + int amount; + + public Move(String s) { + this.action = Action.actionByText(s); + s = s.replace(action.name, ""); + if(!s.isEmpty()) amount = Integer.parseInt(s); + else amount = 0; + } + + public List execute(List cards) { + switch(action) { + case DEAL_NEW_STACK: Collections.reverse(cards); break; + case CUT: { + int n = amount > 0 ? amount : cards.size()+amount; + List sub = new ArrayList<>(cards.subList(n, cards.size())); + sub.addAll(cards.subList(0, n)); + return sub; + } + case DEAL_WITH_INCREMENT: { + Integer[] deck = new Integer[cards.size()] ; + for(int i = 0, card = 0; i cards = IntStream.range(0, 10007).boxed().collect(Collectors.toList()); + for(Move move : moves) cards = move.execute(cards); + return cards.indexOf(2019); + } + + @Override + public Object part2() throws IOException { + var deckSize = num(119315717514047L); + var timesShuffled = num(101741582076661L); + var calc = new BigInteger[] {num(1), num(0)}; + for(Move move : reverseArray(moves)) { + calc = move.execute(calc, deckSize); + for(int i = 0; i T[] reverseArray(T[] arr) { + for(int i = 0; i < arr.length / 2; i++) { + T temp = arr[i]; + arr[i] = arr[arr.length - i - 1]; + arr[arr.length - i - 1] = temp; + } + return arr; + } +} diff --git a/src/main/java/com/sbaars/adventofcode2019/days/Day3.java b/src/main/java/com/sbaars/adventofcode2019/days/Day3.java new file mode 100644 index 00000000..27b93927 --- /dev/null +++ b/src/main/java/com/sbaars/adventofcode2019/days/Day3.java @@ -0,0 +1,106 @@ +package com.sbaars.adventofcode2019.days; + +import java.awt.Point; +import java.io.IOException; +import java.util.Arrays; +import java.util.HashSet; +import java.util.Set; + +import com.sbaars.adventofcode2019.common.Day; +import com.sbaars.adventofcode2019.common.Direction; + +import lombok.EqualsAndHashCode; + +public class Day3 implements Day +{ + private Set intersect; + + public Day3() throws IOException { + String[] strings = Arrays.stream(readDay(3).split(System.lineSeparator())).toArray(String[]::new); + Walk[] walks1 = mapToWalks(strings[0]), walks2 = mapToWalks(strings[1]); + Set walkedLocations = new HashSet<>(); + calculateDistance(walks1, walkedLocations, false); + this.intersect = calculateDistance(walks2, walkedLocations, true); + } + + public static void main(String[] args) throws IOException { + new Day3().printParts(); + } + + @Override + public Object part1() throws IOException { + return intersect.stream().mapToInt(e -> distance(e.point)).min().orElse(Integer.MAX_VALUE); + } + + @Override + public Object part2() throws IOException { + return intersect.stream().mapToInt(e -> e.steps).min().orElse(Integer.MAX_VALUE); + } + + private Set calculateDistance(Walk[] walks1, Set walkedLocations, boolean collect) { + Set intersectingLocations = new HashSet<>(); + int x = 0, y = 0, steps = 0; + for(Walk walk : walks1) { + for(;walk.distance>0;walk.distance--) { + switch(walk.dir) { + case NORTH: y++; break; + case SOUTH: y--; break; + case WEST: x--; break; + case EAST: x++; break; + } + performStep(walkedLocations, collect, intersectingLocations, x, y, steps); + steps++; + } + } + return intersectingLocations; + } + + private void performStep(Set walkedLocations, boolean collect, Set intersectingLocations, int x, int y, int steps) { + Step currentStep = new Step(new Point(x,y), steps); + if(collect) { + if(walkedLocations.contains(currentStep) && !intersectingLocations.contains(currentStep)) { + Step step = walkedLocations.stream().filter(e -> e.equals(currentStep)).findAny().get(); + intersectingLocations.add(step); + step.combine(currentStep); + } + } else { + walkedLocations.add(currentStep); + } + } + + public int distance(Point p) { + return Math.abs(p.x) + Math.abs(p.y); + } + + private Walk[] mapToWalks(String string) { + return Arrays.stream(string.split(",")).map(Walk::new).toArray(Walk[]::new); + } + + class Walk { + private final Direction dir; + private int distance; + + public Walk(String code) { + this.dir = Direction.getByDirCode(code.charAt(0)); + this.distance = Integer.parseInt(code.substring(1)); + } + } + + @EqualsAndHashCode class Step { + private final Point point; + @EqualsAndHashCode.Exclude private int steps; + @EqualsAndHashCode.Exclude private boolean isCombined = false; + + public Step(Point point, int steps) { + this.point = point; + this.steps = steps + 1; + } + + public void combine(Step step) { + if(!isCombined) { + steps+=step.steps; + isCombined = true; + } + } + } +} diff --git a/src/main/java/com/sbaars/adventofcode2019/days/Day4.java b/src/main/java/com/sbaars/adventofcode2019/days/Day4.java new file mode 100644 index 00000000..5031388b --- /dev/null +++ b/src/main/java/com/sbaars/adventofcode2019/days/Day4.java @@ -0,0 +1,57 @@ +package com.sbaars.adventofcode2019.days; + +import java.io.IOException; +import java.util.stream.IntStream; + +import com.sbaars.adventofcode2019.common.Day; + +public class Day4 implements Day { + + public Day4() {} + + public static void main(String[] args) throws IOException { + new Day4().printParts(); + } + + @Override + public Object part1() throws IOException { + return checkPasswords(false); + } + + @Override + public Object part2() throws IOException { + return checkPasswords(true); + } + + public long meetsCriteria(int lowerBound, int higherBound, boolean checkGroup) { + return IntStream.range(lowerBound, higherBound+1).filter(e -> meetsCriteria(e, checkGroup)).count(); + } + + public boolean meetsCriteria(int input, boolean checkGroup) + { + int lastSeen = 10, current, adjacentTheSame = -2, skip = 10; + + for (int i = 0; input > 0; i++) { + current = input % 10; + if(skip != current && current == lastSeen) { + if(checkGroup && adjacentTheSame+1 == i) { + adjacentTheSame = -2; + skip = current; + } else if(adjacentTheSame == -2) { + adjacentTheSame = i; + } + } + if (lastSeen < current) + return false; + lastSeen = current; + input /= 10; + } + + return adjacentTheSame!=-2; + } + + private int checkPasswords(boolean checkGroup) { + return Math.toIntExact(meetsCriteria(372037, 905157, checkGroup)); + } + +} diff --git a/src/main/java/com/sbaars/adventofcode2019/days/Day5.java b/src/main/java/com/sbaars/adventofcode2019/days/Day5.java new file mode 100644 index 00000000..0e5b4006 --- /dev/null +++ b/src/main/java/com/sbaars/adventofcode2019/days/Day5.java @@ -0,0 +1,26 @@ +package com.sbaars.adventofcode2019.days; + +import java.io.IOException; + +import com.sbaars.adventofcode2019.common.Day; +import com.sbaars.adventofcode2019.intcode.IntcodeComputer; + +public class Day5 implements Day { + + public static void main(String[] args) throws IOException { + new Day5().printParts(); + } + + @Override + public Object part1() throws IOException { + long res; + IntcodeComputer intcodeComputer = new IntcodeComputer(5, 1); + while((res = intcodeComputer.run()) == 0); + return res; + } + + @Override + public Object part2() throws IOException { + return new IntcodeComputer(5, 5).run(); + } +} diff --git a/src/main/java/com/sbaars/adventofcode2019/days/Day6.java b/src/main/java/com/sbaars/adventofcode2019/days/Day6.java new file mode 100644 index 00000000..9a31e4ba --- /dev/null +++ b/src/main/java/com/sbaars/adventofcode2019/days/Day6.java @@ -0,0 +1,80 @@ +package com.sbaars.adventofcode2019.days; + +import java.io.IOException; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.List; +import java.util.concurrent.atomic.AtomicInteger; +import java.util.stream.Collectors; + +import com.sbaars.adventofcode2019.common.Day; +import com.sbaars.adventofcode2019.util.ListMap; + +public class Day6 implements Day { + + ListMap orbits = new ListMap<>(); + + public static void main(String[] args) throws IOException + { + new Day6().printParts(); + } + + @Override + public Object part1() throws IOException { + String[] nums = createOrbitArray(); + for(String num : nums) { + String[] parts = num.split("\\)"); + orbits.addTo(parts[0], parts[1]); + } + AtomicInteger o = new AtomicInteger(); + for(var entry : orbits.entrySet()) + countOrbitsInList(orbits, o, entry.getValue()); + return o.get(); + } + + private void countOrbitsInList(ListMap orbits, AtomicInteger o, List entry) { + for(String str : entry) { + o.incrementAndGet(); + if(orbits.containsKey(str)) { + countOrbitsInList(orbits, o, orbits.get(str)); + } + } + } + + @Override + public Object part2() throws IOException { + return findRoute("YOU", "SAN"); + } + + private int findRoute(String from, String to) { + return findRoute(from, to, new ArrayList<>(), 0); + } + + private int findRoute(String from, String to, List visited, int depth) { + if(visited.contains(from)) + return 0; + visited.add(from); + List str = collectAll(from); + if(str.contains(to)) + return depth-1; + for(String s : str) { + int findRoute = findRoute(s, to, visited, depth + 1); + if(findRoute>0) return findRoute; + } + return -1; + } + + private List collectAll(String s1) { + List s = findOrbit(s1); + s.addAll(orbits.get(s1)); + return s; + } + + public List findOrbit(String orbitValue) { + return orbits.entrySet().stream().filter(e -> e.getValue().contains(orbitValue)).map(e -> e.getKey()).collect(Collectors.toList()); + } + + private String[] createOrbitArray() throws IOException { + return Arrays.stream(readDay(6).split(System.lineSeparator())).toArray(String[]::new); + } +} diff --git a/src/main/java/com/sbaars/adventofcode2019/days/Day7.java b/src/main/java/com/sbaars/adventofcode2019/days/Day7.java new file mode 100644 index 00000000..433af6b0 --- /dev/null +++ b/src/main/java/com/sbaars/adventofcode2019/days/Day7.java @@ -0,0 +1,73 @@ +package com.sbaars.adventofcode2019.days; + +import java.io.IOException; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.List; + +import com.sbaars.adventofcode2019.common.Day; +import com.sbaars.adventofcode2019.intcode.IntcodeComputer; + +public class Day7 implements Day { + + public static void main(String[] args) throws IOException { + new Day7().printParts(); + } + + @Override + public Object part1() throws IOException { + var permutations = generatePerm(new ArrayList<>(Arrays.asList(0,1,2,3,4))); + List results = new ArrayList<>(); + for(List perm : permutations) { + long lastVal = 0; + for(Integer i : perm) + lastVal = new IntcodeComputer(7, i, lastVal).run(); + results.add(lastVal); + + } + return results.stream().mapToLong(e -> e).max().getAsLong(); + } + + @Override + public Object part2() throws IOException { + var permutations = generatePerm(new ArrayList<>(Arrays.asList(5,6,7,8,9))); + List results = new ArrayList<>(); + perms: for(List shuffle : permutations) { + IntcodeComputer[] computers = new IntcodeComputer[5]; + for(int i = 0; i e).max().getAsLong(); + } + + public List> generatePerm(List original) { + if (original.isEmpty()) { + List> result = new ArrayList<>(); + result.add(new ArrayList()); + return result; + } + E firstElement = original.remove(0); + List> returnValue = new ArrayList<>(); + List> permutations = generatePerm(original); + for (List smallerPermutated : permutations) { + for (int index=0; index <= smallerPermutated.size(); index++) { + List temp = new ArrayList<>(smallerPermutated); + temp.add(index, firstElement); + returnValue.add(temp); + } + } + return returnValue; + } +} diff --git a/src/main/java/com/sbaars/adventofcode2019/days/Day8.java b/src/main/java/com/sbaars/adventofcode2019/days/Day8.java new file mode 100644 index 00000000..c53be49f --- /dev/null +++ b/src/main/java/com/sbaars/adventofcode2019/days/Day8.java @@ -0,0 +1,70 @@ +package com.sbaars.adventofcode2019.days; + +import java.io.IOException; +import java.util.ArrayList; +import java.util.List; +import java.util.stream.IntStream; + +import com.sbaars.adventofcode2019.common.Day; +import com.sbaars.adventofcode2019.common.ProcessesImages; +import com.sbaars.adventofcode2019.util.CountMap; + +public class Day8 implements Day, ProcessesImages { + + private static final int DIM_X = 6; + private static final int DIM_Y = 25; + private static final int SIZE = DIM_X*DIM_Y; + + public static void main(String[] args) throws IOException { + new Day8().printParts(); + } + + @Override + public Object part1() throws IOException { + int[] pixels = readPixels(); + var pixelCounts = countPixels(pixels); + var cm = pixelCounts.stream().reduce((e1, e2) -> e1.get(0) > e2.get(0) ? e2 : e1).get(); + return cm.get(1) * cm.get(2); + } + + private int[] readPixels() throws IOException { + char[] chars = readDay(8).toCharArray(); + return IntStream.range(0, chars.length).map(i -> Character.getNumericValue(chars[i])).toArray(); + } + + private List> countPixels(int[] pixels) { + List> pixelCounts = new ArrayList<>(); + for(int i = 0; i cm = new CountMap<>(); + for(int j = i; j input = new ArrayDeque<>(2); + private long lastInput; + private long relativeBase = 0; + private static final int[] DO_NOT_TRANSFORM_FINAL_ARGUMENT = {1, 2, 3, 7, 8}; + public static final long STOP_CODE = Long.MIN_VALUE+1; + private static final long CONTINUE_CODE = Long.MIN_VALUE; + + public IntcodeComputer(int day, long...input) throws IOException { + this.program = Arrays.stream(readDay(day).split(",")).mapToLong(Long::parseLong).toArray(); + this.program = Arrays.copyOf(this.program, 10000); // Quick hack to enlarge memory, should be refactored later(tm). + setInput(input); + if(day == 2) { + program[1] = input[0]; + program[2] = input[1]; + } else if(day == 17) { + program[0] = input[0]; + } + } + + public long run(long...input) { + setInput(input); + return run(); + } + + public long run() { + long result; + while((result = executeInstruction(Math.toIntExact(program[instructionCounter]))) == CONTINUE_CODE); + return result; + } + + private long executeInstruction(int instruction) { + if(instruction>99) + return parseComplexInstruction(instruction); + return execute(instruction); + } + + private long execute(int instruction) { + return execute(new int[3], instruction); + } + + private long execute(int[] method, int instruction) { + int nParams = nParams(instruction); + long[] args = IntStream.range(1, nParams+1).mapToLong(j -> program[instructionCounter+j]).toArray(); + transformParameters(method, args, instruction); + return executeInstruction(args, instruction); + } + + private void transformParameters(int[] method, long[] args, int instruction) { + IntStream.range(0, args.length).filter(i -> method[i] != 1).filter(i -> i+1 != args.length || !Arrays.stream(DO_NOT_TRANSFORM_FINAL_ARGUMENT).anyMatch(j -> j==instruction)) + .forEach(i -> args[i] = program[Math.toIntExact((method[i] == 2 ? relativeBase : 0) + args[i])]); + if(Arrays.stream(DO_NOT_TRANSFORM_FINAL_ARGUMENT).anyMatch(j -> j==instruction) && method[args.length-1] == 2) { + args[args.length-1] += relativeBase; + } + } + + private long readInput() { + if(input.isEmpty()) + return lastInput; + lastInput = input.poll(); + return lastInput; + } + + public boolean addInput(long num) { + return input.add(num); + } + + public long firstElement() { + return program[0]; + } + + public boolean setInput(long...input) { + this.input.clear(); + return this.input.addAll(Arrays.stream(input).boxed().collect(Collectors.toList())); + } + + private long executeInstruction(long[] args, int instruction) { + instructionCounter+=nParams(instruction) + 1; + switch(instruction) { + case 1: program[Math.toIntExact(args[2])] = args[0] + args[1]; break; + case 2: program[Math.toIntExact(args[2])] = args[0] * args[1]; break; + case 3: program[Math.toIntExact(args[0])] = readInput(); break; + case 4: return args[0]; + case 5: if(args[0] != 0) instructionCounter = Math.toIntExact(args[1]); break; + case 6: if(args[0] == 0) instructionCounter = Math.toIntExact(args[1]); break; + case 7: program[Math.toIntExact(args[2])] = args[0] < args[1] ? 1 : 0; break; + case 8: program[Math.toIntExact(args[2])] = args[0] == args[1] ? 1 : 0; break; + case 9: relativeBase += Math.toIntExact(args[0]); break; + case 99: return STOP_CODE; + default: throw new IllegalStateException("Something went wrong!"); + } + return CONTINUE_CODE; + } + + private long parseComplexInstruction(int instruction) { + int[] instructions = getInstructions(instruction); + int opcode = getOpCode(instructions); + return execute(new int[] {instructions[2], instructions[1], instructions[0]}, opcode); + } + + private int getOpCode(int instruction) { + return getOpCode(getInstructions(instruction)); + } + + private int getOpCode(int[] instructions) { + return (instructions[3] * 10) + instructions[4]; + } + + private int[] getInstructions(int instruction) { + int[] instructions = new int[5]; + for(int j = instructions.length-1; instruction>0; j--) { + instructions[j] = instruction % 10; + instruction /= 10; + } + return instructions; + } + + private int nParams(int instruction) { + switch(instruction) { + case 99: return -1; + case 3: + case 4: + case 9: return 1; + case 5: + case 6: return 2; + case 1: + case 2: + case 7: + case 8: return 3; + default: if(instruction>99) return nParams(getOpCode(instruction)); + else throw new IllegalStateException("Something went wrong! "+instruction); + } + } + + public void setElement(int i, long j) { + program[i] = j; + } + + public void setInput(String patterns) { + setInput(patterns.chars().mapToLong(e -> e).toArray()); + } +} diff --git a/src/main/java/com/sbaars/adventofcode2019/pathfinding/CharGrid2d.java b/src/main/java/com/sbaars/adventofcode2019/pathfinding/CharGrid2d.java new file mode 100644 index 00000000..842824b3 --- /dev/null +++ b/src/main/java/com/sbaars/adventofcode2019/pathfinding/CharGrid2d.java @@ -0,0 +1,133 @@ +package com.sbaars.adventofcode2019.pathfinding; + +import java.awt.Point; +import java.util.HashSet; +import java.util.List; +import java.util.Set; +import java.util.stream.Collectors; + +/** + * Creates nodes and neighbours from a 2d grid. Each point in the map has an + * integer value that specifies the cost of crossing that point. If this value + * is negative, the point is unreachable. + * + * If diagonal movement is allowed, the Chebyshev distance is used, else + * Manhattan distance is used. + * + * @author Ben Ruijl + * + */ +public class CharGrid2d { + private final char[][] map; + private final boolean allowDiagonal; + List collectedKeys; + + /** + * A node in a 2d map. This is simply the coordinates of the point. + * + * @author Ben Ruijl + * + */ + public class MapNode implements Node { + private final int x, y; + + public MapNode(int x, int y) { + this.x = x; + this.y = y; + } + + public double getHeuristic(MapNode goal) { + if (allowDiagonal) { + return Math.max(Math.abs(x - goal.x), Math.abs(y - goal.y)); + } else { + return Math.abs(x - goal.x) + Math.abs(y - goal.y); + } + } + + public double getTraversalCost(MapNode neighbour) { + return 1 + map[neighbour.y][neighbour.x]; + } + + public Set getNeighbours() { + Set neighbours = new HashSet(); + + for (int i = x - 1; i <= x + 1; i++) { + for (int j = y - 1; j <= y + 1; j++) { + if ((i == x && j == y) || i < 0 || j < 0 || j >= map.length + || i >= map[j].length) { + continue; + } + + if (!allowDiagonal && + ((i < x && j < y) || + (i < x && j > y) || + (i > x && j > y) || + (i > x && j < y))) { + continue; + } + + if (map[j][i] == '#') { + continue; + } + + // TODO: create cache instead of recreation + neighbours.add(new MapNode(i, j)); + } + } + + return neighbours; + } + + @Override + public String toString() { + return "(" + x + ", " + y + ")"; + } + + @Override + public int hashCode() { + final int prime = 31; + int result = 1; + result = prime * result + getOuterType().hashCode(); + result = prime * result + x; + result = prime * result + y; + return result; + } + + @Override + public boolean equals(Object obj) { + if (this == obj) + return true; + if (obj == null) + return false; + if (getClass() != obj.getClass()) + return false; + MapNode other = (MapNode) obj; + if (!getOuterType().equals(other.getOuterType())) + return false; + if (x != other.x) + return false; + if (y != other.y) + return false; + return true; + } + + public Point toPoint() { + return new Point(x, y); + } + + private CharGrid2d getOuterType() { + return CharGrid2d.this; + } + + } + + public CharGrid2d(char[][] map, boolean allowDiagonal) { + this.map = map; + this.allowDiagonal = allowDiagonal; + } + + public List findPath(Point start, Point end) { + return PathFinding.doAStar(new MapNode(start.x, start.y), new MapNode(end.x, end.y)).stream().map(MapNode::toPoint).collect(Collectors.toList()); + } + +} diff --git a/src/main/java/com/sbaars/adventofcode2019/pathfinding/Grid2d.java b/src/main/java/com/sbaars/adventofcode2019/pathfinding/Grid2d.java new file mode 100644 index 00000000..461e50f1 --- /dev/null +++ b/src/main/java/com/sbaars/adventofcode2019/pathfinding/Grid2d.java @@ -0,0 +1,134 @@ +package com.sbaars.adventofcode2019.pathfinding; + +import java.awt.Point; +import java.util.HashSet; +import java.util.List; +import java.util.Set; +import java.util.stream.Collectors; + +import com.sbaars.adventofcode2019.days.Day15; + +/** + * Creates nodes and neighbours from a 2d grid. Each point in the map has an + * integer value that specifies the cost of crossing that point. If this value + * is negative, the point is unreachable. + * + * If diagonal movement is allowed, the Chebyshev distance is used, else + * Manhattan distance is used. + * + * @author Ben Ruijl + * + */ +public class Grid2d { + private final int[][] map; + private final boolean allowDiagonal; + + /** + * A node in a 2d map. This is simply the coordinates of the point. + * + * @author Ben Ruijl + * + */ + public class MapNode implements Node { + private final int x, y; + + public MapNode(int x, int y) { + this.x = x; + this.y = y; + } + + public double getHeuristic(MapNode goal) { + if (allowDiagonal) { + return Math.max(Math.abs(x - goal.x), Math.abs(y - goal.y)); + } else { + return Math.abs(x - goal.x) + Math.abs(y - goal.y); + } + } + + public double getTraversalCost(MapNode neighbour) { + return 1 + map[neighbour.y][neighbour.x]; + } + + public Set getNeighbours() { + Set neighbours = new HashSet(); + + for (int i = x - 1; i <= x + 1; i++) { + for (int j = y - 1; j <= y + 1; j++) { + if ((i == x && j == y) || i < 0 || j < 0 || j >= map.length + || i >= map[j].length) { + continue; + } + + if (!allowDiagonal && + ((i < x && j < y) || + (i < x && j > y) || + (i > x && j > y) || + (i > x && j < y))) { + continue; + } + + if (map[j][i] == Day15.WALL || map[j][i] == Day15.UNEXPLORED) { + continue; + } + + // TODO: create cache instead of recreation + neighbours.add(new MapNode(i, j)); + } + } + + return neighbours; + } + + @Override + public String toString() { + return "(" + x + ", " + y + ")"; + } + + @Override + public int hashCode() { + final int prime = 31; + int result = 1; + result = prime * result + getOuterType().hashCode(); + result = prime * result + x; + result = prime * result + y; + return result; + } + + @Override + public boolean equals(Object obj) { + if (this == obj) + return true; + if (obj == null) + return false; + if (getClass() != obj.getClass()) + return false; + MapNode other = (MapNode) obj; + if (!getOuterType().equals(other.getOuterType())) + return false; + if (x != other.x) + return false; + if (y != other.y) + return false; + return true; + } + + public Point toPoint() { + return new Point(x, y); + } + + private Grid2d getOuterType() { + return Grid2d.this; + } + + } + + public Grid2d(int[][] map, boolean allowDiagonal) { + this.map = map; + this.allowDiagonal = allowDiagonal; + } + + public List findPath(Point start, Point end) { + return PathFinding.doAStar(new MapNode(start.x, start.y), new MapNode(end.x, end.y)).stream().map(MapNode::toPoint).collect(Collectors.toList()); + } + +} diff --git a/src/main/java/com/sbaars/adventofcode2019/pathfinding/Node.java b/src/main/java/com/sbaars/adventofcode2019/pathfinding/Node.java new file mode 100644 index 00000000..d99e59f6 --- /dev/null +++ b/src/main/java/com/sbaars/adventofcode2019/pathfinding/Node.java @@ -0,0 +1,40 @@ +package com.sbaars.adventofcode2019.pathfinding; +import java.util.Set; + +/** + * A node in a graph, useful for pathfinding. + * + * @author Ben Ruijl + * + * @param + * Actual type of the node + */ +public interface Node { + /** + * The heuristic cost to move from the current node to the goal. In most + * cases this is the Manhattan distance or Chebyshev distance. + * + * @param goal + * @return + */ + double getHeuristic(T goal); + + /** + * The cost of moving from the current node to the neighbour. In most cases + * this is just the distance between the nodes, but additional terrain cost + * can be added as well (for example climbing a mountain is more expensive + * than walking on a road). + * + * @param neighbour + * Neighbour of current node + * @return Traversal cost + */ + double getTraversalCost(T neighbour); + + /** + * Gets the set of neighbouring nodes. + * + * @return Neighbouring nodes + */ + Set getNeighbours(); +} diff --git a/src/main/java/com/sbaars/adventofcode2019/pathfinding/PathFinding.java b/src/main/java/com/sbaars/adventofcode2019/pathfinding/PathFinding.java new file mode 100644 index 00000000..7c13a084 --- /dev/null +++ b/src/main/java/com/sbaars/adventofcode2019/pathfinding/PathFinding.java @@ -0,0 +1,87 @@ +package com.sbaars.adventofcode2019.pathfinding; +import java.util.ArrayList; +import java.util.Comparator; +import java.util.HashMap; +import java.util.HashSet; +import java.util.LinkedList; +import java.util.List; +import java.util.Map; +import java.util.PriorityQueue; +import java.util.Set; + +/** + * Helper class containing pathfinding algorithms. + * + * @author Ben Ruijl + * + */ +public class PathFinding { + + /** + * A Star pathfinding. Note that the heuristic has to be monotonic: + * {@code h(x) <= + * d(x, y) + h(y)}. + * + * @param start + * Starting node + * @param goal + * Goal node + * @return Shortest path from start to goal, or null if none found + */ + public static > List doAStar(T start, T goal) { + Set closed = new HashSet(); + Map fromMap = new HashMap(); + List route = new LinkedList(); + Map gScore = new HashMap(); + final Map fScore = new HashMap(); + PriorityQueue open = new PriorityQueue(11, new Comparator() { + + public int compare(T nodeA, T nodeB) { + return Double.compare(fScore.get(nodeA), fScore.get(nodeB)); + } + }); + + gScore.put(start, 0.0); + fScore.put(start, start.getHeuristic(goal)); + open.offer(start); + + while (!open.isEmpty()) { + T current = open.poll(); + if (current.equals(goal)) { + while (current != null) { + route.add(0, current); + current = fromMap.get(current); + } + + return route; + } + + closed.add(current); + + for (T neighbour : current.getNeighbours()) { + if (closed.contains(neighbour)) { + continue; + } + + double tentG = gScore.get(current) + + current.getTraversalCost(neighbour); + + boolean contains = open.contains(neighbour); + if (!contains || tentG < gScore.get(neighbour)) { + gScore.put(neighbour, tentG); + fScore.put(neighbour, tentG + neighbour.getHeuristic(goal)); + + if (contains) { + open.remove(neighbour); + } + + open.offer(neighbour); + fromMap.put(neighbour, current); + } + } + } + + return new ArrayList<>(); + } + +} diff --git a/src/main/java/com/sbaars/adventofcode2019/util/CountMap.java b/src/main/java/com/sbaars/adventofcode2019/util/CountMap.java new file mode 100644 index 00000000..5eb6543b --- /dev/null +++ b/src/main/java/com/sbaars/adventofcode2019/util/CountMap.java @@ -0,0 +1,58 @@ +package com.sbaars.adventofcode2019.util; + +import java.util.HashMap; +import java.util.Map; +import java.util.stream.Collectors; + +public class CountMap extends HashMap { + /** + * + */ + private static final long serialVersionUID = 1L; + + public CountMap() { + } + + public CountMap(int initialCapacity, float loadFactor) { + super(initialCapacity, loadFactor); + } + + public CountMap(int initialCapacity) { + super(initialCapacity); + } + + public CountMap(Map m) { + super(m); + } + + public Integer increment(K key) { + return super.put(key, super.containsKey(key) ? super.get(key) + 1 : 1); + } + + public Integer increment(K key, int amount) { + return super.put(key, super.containsKey(key) ? super.get(key) + amount : amount); + } + + @SuppressWarnings("unchecked") + @Override + public Integer get(Object key){ + if(!super.containsKey(key)) + super.put((K) key, 0); + return super.get(key); + } + + @Override + public String toString() { + return keySet().stream().sorted().map(e -> e+"\t"+get(e)).collect(Collectors.joining(System.lineSeparator())); + } + + public void addAll(CountMap amountPerCloneClassSize) { + amountPerCloneClassSize.entrySet().stream().forEach(e -> this.increment(e.getKey(), e.getValue())); + } + + public void incrementAll(CountMap input) { + for(Entry i : input.entrySet()) { + increment(i.getKey(), i.getValue()); + } + } +} diff --git a/src/main/java/com/sbaars/adventofcode2019/util/DoesFileOperations.java b/src/main/java/com/sbaars/adventofcode2019/util/DoesFileOperations.java index 3a90b468..289ee81c 100644 --- a/src/main/java/com/sbaars/adventofcode2019/util/DoesFileOperations.java +++ b/src/main/java/com/sbaars/adventofcode2019/util/DoesFileOperations.java @@ -4,58 +4,18 @@ import java.io.IOException; import java.nio.charset.StandardCharsets; import java.nio.file.Files; -import java.nio.file.Path; -import java.nio.file.Paths; -import java.nio.file.StandardCopyOption; public interface DoesFileOperations { public default String getFileAsString(File file) throws IOException { - return new String(getFileBytes(file), StandardCharsets.UTF_8); - } - - public default byte[] getFileBytes(File file) throws IOException { - return Files.readAllBytes(file.toPath()); - } - - public default void writeStringToFile(File file, String content) throws IOException { - if (file.exists()) - Files.delete(file.toPath()); - else if (file.getParentFile() != null) - file.getParentFile().mkdirs(); - if (file.createNewFile()) - Files.write(Paths.get(file.getAbsolutePath()), content.getBytes(StandardCharsets.UTF_8)); + return new String(Files.readAllBytes(file.toPath()), StandardCharsets.UTF_8); } - public default void copyFolder(Path src, Path dest) { - try { - dest.toFile().mkdirs(); - Files.walk(src).forEach(source -> copy(source, dest.resolve(src.relativize(source)))); - } catch (IOException e) { - e.printStackTrace(); - } - } - - public default void copy(Path source, Path dest) { - try { - Files.copy(source, dest, StandardCopyOption.REPLACE_EXISTING); - } catch (IOException e) { - throw new RuntimeException(e.getMessage(), e); - } + public default String getResourceAsString(String resource) throws IOException { + return getFileAsString(new File(DoesFileOperations.class.getClassLoader().getResource(resource).getFile())); } - public default boolean delete(File dir) { - if (dir.isDirectory()) { - String[] children = dir.list(); - for (int i=0; i extends HashMap> { + /** + * + */ + private static final long serialVersionUID = 1L; + + public ListMap() { + } + + public ListMap(int initialCapacity, float loadFactor) { + super(initialCapacity, loadFactor); + } + + public ListMap(int initialCapacity) { + super(initialCapacity); + } + + public ListMap(Map> m) { + super(m); + } + + public List addTo(K key, V value) { + List l; + if(super.containsKey(key)) { + l = super.get(key); + } else l = new ArrayList<>(); + l.add(value); + return super.put(key, l); + } + + public List addTo(K key, V[] value) { + List l; + if(super.containsKey(key)) { + l = super.get(key); + } else l = new ArrayList<>(); + Collections.addAll(l, value); + return super.put(key, l); + } + + @SuppressWarnings("unchecked") + @Override + public List get(Object key){ + if(!super.containsKey(key)) + super.put((K) key, new ArrayList<>()); + return super.get(key); + } + + public Entry> getEntryForValue(V i) { + System.out.println(Arrays.toString(values().toArray())); + Optional>> findAny = entrySet().stream().filter(e -> e.getValue().contains(i)).findAny(); + if(!findAny.isPresent()) + throw new IllegalAccessError("Value "+i+" does not exist in this map!"); + return findAny.get(); + } +} diff --git a/src/main/java/com/sbaars/adventofcode2019/util/LongCountMap.java b/src/main/java/com/sbaars/adventofcode2019/util/LongCountMap.java new file mode 100644 index 00000000..1762fbf5 --- /dev/null +++ b/src/main/java/com/sbaars/adventofcode2019/util/LongCountMap.java @@ -0,0 +1,58 @@ +package com.sbaars.adventofcode2019.util; + +import java.util.HashMap; +import java.util.Map; +import java.util.stream.Collectors; + +public class LongCountMap extends HashMap { + /** + * + */ + private static final long serialVersionUID = 1L; + + public LongCountMap() { + } + + public LongCountMap(int initialCapacity, float loadFactor) { + super(initialCapacity, loadFactor); + } + + public LongCountMap(int initialCapacity) { + super(initialCapacity); + } + + public LongCountMap(Map m) { + super(m); + } + + public Long increment(K key) { + return super.put(key, super.containsKey(key) ? super.get(key) + 1 : 1); + } + + public Long increment(K key, long amount) { + return super.put(key, super.containsKey(key) ? super.get(key) + amount : amount); + } + + @SuppressWarnings("unchecked") + @Override + public Long get(Object key){ + if(!super.containsKey(key)) + super.put((K) key, 0L); + return super.get(key); + } + + @Override + public String toString() { + return keySet().stream().sorted().map(e -> e+"\t"+get(e)).collect(Collectors.joining(System.lineSeparator())); + } + + public void addAll(LongCountMap amountPerCloneClassSize) { + amountPerCloneClassSize.entrySet().stream().forEach(e -> this.increment(e.getKey(), e.getValue())); + } + + public void incrementAll(LongCountMap input) { + for(Entry i : input.entrySet()) { + increment(i.getKey(), i.getValue()); + } + } +} diff --git a/src/main/resources/day1.txt b/src/main/resources/day1.txt new file mode 100644 index 00000000..95bcbee3 --- /dev/null +++ b/src/main/resources/day1.txt @@ -0,0 +1,100 @@ +55131 +114008 +145297 +76135 +50317 +134036 +122136 +97704 +51245 +141732 +120427 +142020 +88166 +55313 +110391 +112436 +78195 +74294 +128984 +68240 +137098 +142016 +83577 +89257 +107744 +67357 +131342 +98247 +137501 +134577 +65696 +84925 +50159 +110319 +91921 +103303 +84505 +84683 +100811 +82626 +66774 +123216 +95151 +88237 +60705 +124319 +102926 +143160 +92780 +64283 +132434 +113935 +84907 +113698 +117240 +129327 +78837 +144841 +138054 +130990 +100191 +141768 +138941 +108165 +62138 +121690 +117305 +90147 +134422 +78031 +121331 +120947 +120235 +138880 +141076 +119480 +66844 +77660 +106364 +99187 +144244 +120483 +77715 +135703 +125521 +123253 +127556 +96458 +91965 +73924 +95176 +87540 +122083 +146013 +67761 +100413 +145994 +149450 +94330 +112824 \ No newline at end of file diff --git a/src/main/resources/day10.txt b/src/main/resources/day10.txt new file mode 100644 index 00000000..110bc35d --- /dev/null +++ b/src/main/resources/day10.txt @@ -0,0 +1,39 @@ +.............#..#.#......##........#..# +.#...##....#........##.#......#......#. +..#.#.#...#...#...##.#...#............. +.....##.................#.....##..#.#.# +......##...#.##......#..#.......#...... +......#.....#....#.#..#..##....#....... +...................##.#..#.....#.....#. +#.....#.##.....#...##....#####....#.#.. +..#.#..........#..##.......#.#...#....# +...#.#..#...#......#..........###.#.... +##..##...#.#.......##....#.#..#...##... +..........#.#....#.#.#......#.....#.... +....#.........#..#..##..#.##........#.. +........#......###..............#.#.... +...##.#...#.#.#......#........#........ +......##.#.....#.#.....#..#.....#.#.... +..#....#.###..#...##.#..##............# +...##..#...#.##.#.#....#.#.....#...#..# +......#............#.##..#..#....##.... +.#.#.......#..#...###...........#.#.##. +........##........#.#...#.#......##.... +.#.#........#......#..........#....#... +...............#...#........##..#.#.... +.#......#....#.......#..#......#....... +.....#...#.#...#...#..###......#.##.... +.#...#..##................##.#......... +..###...#.......#.##.#....#....#....#.# +...#..#.......###.............##.#..... +#..##....###.......##........#..#...#.# +.#......#...#...#.##......#..#......... +#...#.....#......#..##.............#... +...###.........###.###.#.....###.#.#... +#......#......#.#..#....#..#.....##.#.. +.##....#.....#...#.##..#.#..##.......#. +..#........#.......##.##....#......#... +##............#....#.#.....#........... +........###.............##...#........# +#.........#.....#..##.#.#.#..#....#.... +..............##.#.#.#...........#..... \ No newline at end of file diff --git a/src/main/resources/day11.txt b/src/main/resources/day11.txt new file mode 100644 index 00000000..7f841847 --- /dev/null +++ b/src/main/resources/day11.txt @@ -0,0 +1 @@ +3,8,1005,8,342,1106,0,11,0,0,0,104,1,104,0,3,8,102,-1,8,10,1001,10,1,10,4,10,1008,8,0,10,4,10,1002,8,1,29,2,1006,19,10,1,1005,19,10,2,1102,11,10,3,8,102,-1,8,10,101,1,10,10,4,10,108,1,8,10,4,10,1001,8,0,62,2,1009,15,10,3,8,102,-1,8,10,101,1,10,10,4,10,108,1,8,10,4,10,1002,8,1,88,2,1101,6,10,3,8,102,-1,8,10,1001,10,1,10,4,10,108,0,8,10,4,10,102,1,8,114,1,105,8,10,1,1102,18,10,2,6,5,10,1,2,15,10,3,8,1002,8,-1,10,101,1,10,10,4,10,1008,8,1,10,4,10,1001,8,0,153,1,105,15,10,3,8,1002,8,-1,10,1001,10,1,10,4,10,108,0,8,10,4,10,102,1,8,178,1,1006,15,10,1006,0,96,1006,0,35,1,104,7,10,3,8,1002,8,-1,10,1001,10,1,10,4,10,108,0,8,10,4,10,102,1,8,214,1006,0,44,2,1105,17,10,1,1107,19,10,1,4,16,10,3,8,1002,8,-1,10,1001,10,1,10,4,10,1008,8,0,10,4,10,102,1,8,252,1006,0,6,1,1001,20,10,1006,0,45,2,1109,5,10,3,8,1002,8,-1,10,101,1,10,10,4,10,108,1,8,10,4,10,102,1,8,287,2,101,20,10,2,1006,18,10,1,1009,9,10,3,8,102,-1,8,10,1001,10,1,10,4,10,108,1,8,10,4,10,1002,8,1,321,101,1,9,9,1007,9,1031,10,1005,10,15,99,109,664,104,0,104,1,21102,48210117528,1,1,21102,1,359,0,1105,1,463,21102,932700763028,1,1,21102,370,1,0,1105,1,463,3,10,104,0,104,1,3,10,104,0,104,0,3,10,104,0,104,1,3,10,104,0,104,1,3,10,104,0,104,0,3,10,104,0,104,1,21102,1,179557207079,1,21102,417,1,0,1105,1,463,21102,1,28994202816,1,21101,0,428,0,1105,1,463,3,10,104,0,104,0,3,10,104,0,104,0,21101,0,709580710756,1,21102,1,451,0,1106,0,463,21102,825016201984,1,1,21101,462,0,0,1106,0,463,99,109,2,21201,-1,0,1,21102,40,1,2,21101,0,494,3,21102,1,484,0,1105,1,527,109,-2,2106,0,0,0,1,0,0,1,109,2,3,10,204,-1,1001,489,490,505,4,0,1001,489,1,489,108,4,489,10,1006,10,521,1101,0,0,489,109,-2,2105,1,0,0,109,4,1201,-1,0,526,1207,-3,0,10,1006,10,544,21102,1,0,-3,21202,-3,1,1,22102,1,-2,2,21102,1,1,3,21102,563,1,0,1105,1,568,109,-4,2106,0,0,109,5,1207,-3,1,10,1006,10,591,2207,-4,-2,10,1006,10,591,21202,-4,1,-4,1105,1,659,22102,1,-4,1,21201,-3,-1,2,21202,-2,2,3,21102,610,1,0,1106,0,568,21201,1,0,-4,21102,1,1,-1,2207,-4,-2,10,1006,10,629,21102,1,0,-1,22202,-2,-1,-2,2107,0,-3,10,1006,10,651,21202,-1,1,1,21102,1,651,0,106,0,526,21202,-2,-1,-2,22201,-4,-2,-4,109,-5,2106,0,0 \ No newline at end of file diff --git a/src/main/resources/day12.txt b/src/main/resources/day12.txt new file mode 100644 index 00000000..e637be38 --- /dev/null +++ b/src/main/resources/day12.txt @@ -0,0 +1,4 @@ + + + + \ No newline at end of file diff --git a/src/main/resources/day13.txt b/src/main/resources/day13.txt new file mode 100644 index 00000000..a976d5d0 --- /dev/null +++ b/src/main/resources/day13.txt @@ -0,0 +1 @@ +1,380,379,385,1008,2235,768501,381,1005,381,12,99,109,2236,1102,0,1,383,1102,1,0,382,21002,382,1,1,20102,1,383,2,21102,1,37,0,1106,0,578,4,382,4,383,204,1,1001,382,1,382,1007,382,38,381,1005,381,22,1001,383,1,383,1007,383,21,381,1005,381,18,1006,385,69,99,104,-1,104,0,4,386,3,384,1007,384,0,381,1005,381,94,107,0,384,381,1005,381,108,1106,0,161,107,1,392,381,1006,381,161,1101,0,-1,384,1106,0,119,1007,392,36,381,1006,381,161,1101,0,1,384,20101,0,392,1,21102,1,19,2,21101,0,0,3,21102,138,1,0,1106,0,549,1,392,384,392,21002,392,1,1,21101,0,19,2,21101,3,0,3,21102,161,1,0,1106,0,549,1102,1,0,384,20001,388,390,1,21001,389,0,2,21101,180,0,0,1106,0,578,1206,1,213,1208,1,2,381,1006,381,205,20001,388,390,1,21001,389,0,2,21101,0,205,0,1106,0,393,1002,390,-1,390,1102,1,1,384,21002,388,1,1,20001,389,391,2,21101,0,228,0,1106,0,578,1206,1,261,1208,1,2,381,1006,381,253,21002,388,1,1,20001,389,391,2,21102,253,1,0,1106,0,393,1002,391,-1,391,1102,1,1,384,1005,384,161,20001,388,390,1,20001,389,391,2,21101,279,0,0,1105,1,578,1206,1,316,1208,1,2,381,1006,381,304,20001,388,390,1,20001,389,391,2,21101,0,304,0,1105,1,393,1002,390,-1,390,1002,391,-1,391,1102,1,1,384,1005,384,161,20102,1,388,1,20102,1,389,2,21101,0,0,3,21102,338,1,0,1105,1,549,1,388,390,388,1,389,391,389,21002,388,1,1,21002,389,1,2,21101,0,4,3,21101,0,365,0,1106,0,549,1007,389,20,381,1005,381,75,104,-1,104,0,104,0,99,0,1,0,0,0,0,0,0,320,17,16,1,1,19,109,3,21201,-2,0,1,22101,0,-1,2,21101,0,0,3,21102,414,1,0,1106,0,549,21202,-2,1,1,21201,-1,0,2,21102,1,429,0,1105,1,601,1201,1,0,435,1,386,0,386,104,-1,104,0,4,386,1001,387,-1,387,1005,387,451,99,109,-3,2106,0,0,109,8,22202,-7,-6,-3,22201,-3,-5,-3,21202,-4,64,-2,2207,-3,-2,381,1005,381,492,21202,-2,-1,-1,22201,-3,-1,-3,2207,-3,-2,381,1006,381,481,21202,-4,8,-2,2207,-3,-2,381,1005,381,518,21202,-2,-1,-1,22201,-3,-1,-3,2207,-3,-2,381,1006,381,507,2207,-3,-4,381,1005,381,540,21202,-4,-1,-1,22201,-3,-1,-3,2207,-3,-4,381,1006,381,529,22101,0,-3,-7,109,-8,2105,1,0,109,4,1202,-2,38,566,201,-3,566,566,101,639,566,566,1201,-1,0,0,204,-3,204,-2,204,-1,109,-4,2106,0,0,109,3,1202,-1,38,594,201,-2,594,594,101,639,594,594,20102,1,0,-2,109,-3,2106,0,0,109,3,22102,21,-2,1,22201,1,-1,1,21101,0,401,2,21102,1,733,3,21102,798,1,4,21102,1,630,0,1106,0,456,21201,1,1437,-2,109,-3,2105,1,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,0,2,2,2,2,2,2,2,2,2,2,2,0,2,0,2,2,2,0,2,2,2,2,2,2,0,2,2,0,2,2,2,2,2,2,0,1,1,0,2,2,0,2,0,2,2,2,2,0,2,2,2,2,2,0,2,0,2,2,0,2,2,2,2,0,0,2,2,2,0,2,0,2,0,1,1,0,0,2,2,2,0,0,2,0,2,2,0,2,2,2,2,0,0,2,0,2,2,2,2,2,2,2,0,2,0,2,2,2,0,2,0,1,1,0,2,2,2,2,2,2,2,2,2,2,2,0,2,2,2,0,0,2,0,2,0,2,2,0,2,2,0,2,2,2,2,2,0,2,0,1,1,0,2,0,2,2,0,2,2,2,2,2,2,2,2,2,2,0,0,0,2,2,2,0,2,0,2,2,0,0,2,2,0,2,2,2,0,1,1,0,2,2,2,2,0,2,0,0,2,2,2,0,2,2,2,0,2,0,2,0,0,2,2,2,0,2,2,2,0,0,2,0,2,2,0,1,1,0,0,2,2,0,2,2,2,2,2,2,2,2,2,2,2,2,2,2,0,2,2,2,2,0,2,0,2,2,2,0,2,2,2,0,0,1,1,0,2,2,0,2,0,0,2,2,2,0,0,0,2,0,2,2,2,0,2,2,0,2,2,2,2,2,2,2,0,0,0,2,0,0,0,1,1,0,0,2,2,0,0,2,2,2,2,0,2,2,2,0,0,2,0,2,2,0,2,2,2,2,2,2,2,2,2,0,0,0,2,2,0,1,1,0,2,0,0,2,2,2,2,2,2,2,0,2,0,2,0,2,2,2,2,2,2,2,2,2,2,2,2,2,2,0,2,0,0,2,0,1,1,0,2,2,0,2,2,2,0,2,2,0,2,0,2,0,0,0,0,2,2,2,2,2,2,2,2,2,2,0,0,2,2,0,2,2,0,1,1,0,2,2,0,2,2,2,2,2,0,2,0,2,2,2,2,2,0,0,2,2,2,2,0,2,2,0,2,2,2,2,0,2,0,2,0,1,1,0,2,2,0,2,0,2,2,2,2,2,2,0,2,2,2,2,2,2,0,2,2,0,2,2,2,0,2,2,2,2,2,2,2,2,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,4,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,3,25,47,80,47,44,8,60,70,40,60,9,9,88,82,66,91,81,11,3,95,72,53,39,7,33,48,69,45,31,75,6,61,77,72,25,57,70,2,92,78,46,43,88,74,45,27,94,73,90,43,68,90,22,64,2,5,3,40,98,62,25,95,74,1,35,2,1,54,76,68,88,75,30,77,35,40,43,49,85,55,53,12,77,94,89,9,55,8,50,82,7,89,21,85,37,48,4,33,1,28,97,62,95,41,14,22,52,24,72,2,25,51,32,55,36,73,84,22,66,69,36,1,57,97,50,21,98,41,36,59,56,6,80,46,2,86,14,67,77,59,77,5,13,97,98,83,83,42,10,62,64,86,97,17,90,37,27,54,40,39,61,38,11,67,40,65,13,6,85,71,9,93,69,9,28,48,7,93,67,95,90,15,29,90,88,8,75,64,36,42,29,92,24,28,19,4,19,60,16,1,97,43,50,13,10,82,30,19,86,32,93,46,32,66,94,91,44,39,57,51,48,41,92,17,97,16,92,41,92,58,31,94,82,68,25,10,32,98,24,77,17,5,82,30,16,40,82,67,14,16,33,3,96,72,90,83,97,4,55,69,8,30,29,2,47,8,47,52,41,2,14,67,7,57,14,4,94,44,47,9,81,54,91,50,85,41,84,45,65,33,66,28,35,98,89,92,57,81,49,89,89,39,11,8,97,77,12,30,33,77,12,46,64,37,2,84,34,11,54,23,33,57,40,27,95,47,3,17,8,43,15,13,13,41,80,62,93,68,45,82,86,17,44,49,51,29,9,92,67,14,81,16,97,5,65,6,85,46,35,19,50,88,51,23,90,35,44,74,33,36,13,20,44,42,71,51,32,60,22,29,13,26,1,64,26,75,86,43,78,4,43,41,52,67,16,20,63,37,60,2,1,53,37,75,55,3,40,66,36,1,69,18,55,33,81,38,1,81,24,80,31,25,79,30,84,83,71,72,11,94,62,6,35,15,9,63,29,27,76,33,62,77,47,12,61,84,13,38,73,11,32,49,87,6,25,57,87,4,35,91,67,19,30,72,59,79,46,64,66,14,21,15,85,25,22,45,87,96,90,28,83,72,29,71,58,14,50,71,48,19,50,78,63,65,3,41,64,82,50,64,74,77,93,21,52,55,24,34,19,61,19,13,44,80,38,53,36,41,96,17,77,9,84,87,79,51,77,35,5,55,82,23,63,20,66,68,23,92,81,10,2,57,97,4,24,44,28,25,56,4,22,61,11,35,60,75,63,96,60,94,3,65,93,63,28,54,21,10,20,12,46,15,84,93,43,83,71,90,52,48,33,47,32,75,22,22,38,8,62,42,30,95,66,15,75,14,73,17,10,94,64,70,29,51,70,14,68,56,60,57,9,84,16,77,37,17,44,37,22,88,60,85,59,61,52,3,21,15,19,23,90,33,47,36,48,44,30,33,16,22,37,93,78,16,43,18,65,18,61,67,71,51,13,33,7,48,40,70,9,66,12,59,49,67,34,23,51,75,48,23,30,47,23,81,21,42,6,66,34,4,67,45,21,90,34,48,47,43,11,3,54,9,10,35,60,78,19,17,68,1,9,26,92,7,86,66,13,12,31,12,71,55,43,78,39,54,70,62,38,93,25,89,83,37,37,2,60,87,84,48,98,43,1,78,86,97,67,41,85,66,17,23,32,9,35,91,4,18,89,71,4,88,66,50,32,92,9,44,10,23,31,17,53,36,46,94,33,93,68,44,85,73,72,14,34,69,66,77,43,93,23,24,14,17,79,27,63,7,44,95,66,55,83,8,90,58,43,768501 \ No newline at end of file diff --git a/src/main/resources/day14.txt b/src/main/resources/day14.txt new file mode 100644 index 00000000..46da9f07 --- /dev/null +++ b/src/main/resources/day14.txt @@ -0,0 +1,60 @@ +11 BNMWF, 1 MRVFT, 10 PBNSF => 7 XSFVQ +149 ORE => 4 SMSB +1 XHQDX, 1 SVSTJ, 2 LDHX => 7 JMWQG +12 MJCLX => 9 PBNSF +132 ORE => 7 XPTXL +15 TZMWG, 1 LDHX, 1 PDVR => 7 LBQB +1 HJTD, 8 VFXHC => 2 SVSTJ +5 LBHQ, 6 MTQCB => 4 MHBZ +1 PRXT, 1 FWZN => 2 PBMPL +1 XPTXL => 1 HMRGM +10 XHPHR => 6 NSVJL +3 QZQLZ, 3 MTQCB => 4 TZMWG +5 LBHQ, 2 VPSDV => 3 ZFCD +13 WPFP => 6 ZXMGK +10 MHJMX, 75 LDHX, 52 JMWQG, 4 QWRB, 1 SVNVJ, 17 BNMWF, 18 GHVN => 1 FUEL +4 PFQRG, 14 XVNL => 5 PDCV +11 JMWQG, 10 ZBNCP => 6 NTJZH +14 PBMPL, 12 PRXT, 9 MJQS => 9 XVNL +9 GDNG, 13 LBQB => 9 QWRB +1 CXNM => 6 PFQRG +9 NTJZH, 7 BNMWF, 11 JCHP, 1 MHBZ, 1 SVSTJ, 9 XRDN => 5 SVNVJ +1 XHPHR, 1 GSMP => 4 THRVR +26 FWZN => 4 WPFP +35 VJTFJ, 2 XSFVQ, 6 HJVN, 1 NSVJL, 1 JCHP, 3 MJCLX, 1 QZNCK => 6 GHVN +1 WPFP, 3 XHPHR => 2 HJVN +5 SMSB => 7 HNCDS +111 ORE => 4 GSMP +6 LBHQ => 8 GDNG +2 GDNG, 5 MHBZ => 1 RNMKC +15 THRVR, 4 NWNSH, 1 NSVJL => 7 FDVH +2 HMRGM => 9 FWZN +6 MJQS, 5 JRZXM => 5 NWNSH +14 ZXMGK, 1 JTXWX => 6 DLWT +1 MJQS, 3 FWZN, 2 PRXT => 1 JTXWX +1 GSMP, 4 CXNM => 3 JRZXM +151 ORE => 9 ZNPRL +2 NTJZH, 1 DLWT, 3 ZBNCP => 9 MRVFT +14 SWZCB, 1 VPSDV => 7 XRDN +14 LBHQ, 16 FDVH, 9 PFQRG => 4 PRXT +22 CXNM => 9 HJTD +1 VFXHC, 1 MTQCB => 6 QZQLZ +6 SWZCB, 2 PDCV, 17 RNMKC => 9 LTHFW +4 ZNPRL => 6 CXNM +2 CXNM => 3 LBHQ +8 MHBZ, 2 QZQLZ, 2 LBQB => 3 VJTFJ +3 ZFCD => 1 XHQDX +1 VJTFJ, 7 MHBZ => 8 ZBNCP +5 CXNM => 2 VPSDV +7 MJQS => 9 VFXHC +2 LTHFW, 11 HJVN, 4 XRDN, 8 MRVFT, 3 NSVJL, 3 SVSTJ, 5 XSFVQ, 13 RNMKC => 8 MHJMX +2 HMRGM => 3 XHPHR +1 GDNG, 19 PDVR => 3 SWZCB +18 HMRGM, 10 HNCDS => 2 MJQS +6 HNCDS, 2 HMRGM, 1 LBHQ => 3 MTQCB +16 VJTFJ, 1 WPFP, 6 JMWQG => 6 BNMWF +3 TZMWG, 1 FWZN => 7 PDVR +10 ZXMGK => 4 QZNCK +32 LBQB, 1 ZBNCP => 1 JCHP +27 PDVR, 7 QZQLZ, 7 PBMPL => 3 MJCLX +5 MHBZ, 12 ZFCD => 4 LDHX \ No newline at end of file diff --git a/src/main/resources/day15.txt b/src/main/resources/day15.txt new file mode 100644 index 00000000..0af98421 --- /dev/null +++ b/src/main/resources/day15.txt @@ -0,0 +1 @@ +3,1033,1008,1033,1,1032,1005,1032,31,1008,1033,2,1032,1005,1032,58,1008,1033,3,1032,1005,1032,81,1008,1033,4,1032,1005,1032,104,99,101,0,1034,1039,1001,1036,0,1041,1001,1035,-1,1040,1008,1038,0,1043,102,-1,1043,1032,1,1037,1032,1042,1105,1,124,101,0,1034,1039,101,0,1036,1041,1001,1035,1,1040,1008,1038,0,1043,1,1037,1038,1042,1106,0,124,1001,1034,-1,1039,1008,1036,0,1041,1001,1035,0,1040,1001,1038,0,1043,1002,1037,1,1042,1105,1,124,1001,1034,1,1039,1008,1036,0,1041,102,1,1035,1040,101,0,1038,1043,1002,1037,1,1042,1006,1039,217,1006,1040,217,1008,1039,40,1032,1005,1032,217,1008,1040,40,1032,1005,1032,217,1008,1039,1,1032,1006,1032,165,1008,1040,33,1032,1006,1032,165,1101,0,2,1044,1106,0,224,2,1041,1043,1032,1006,1032,179,1101,1,0,1044,1106,0,224,1,1041,1043,1032,1006,1032,217,1,1042,1043,1032,1001,1032,-1,1032,1002,1032,39,1032,1,1032,1039,1032,101,-1,1032,1032,101,252,1032,211,1007,0,43,1044,1105,1,224,1101,0,0,1044,1106,0,224,1006,1044,247,1002,1039,1,1034,1002,1040,1,1035,102,1,1041,1036,1001,1043,0,1038,101,0,1042,1037,4,1044,1105,1,0,13,30,60,64,5,28,36,24,67,12,1,67,32,39,14,78,29,17,38,88,79,9,62,25,15,18,88,25,7,81,38,41,10,69,86,32,11,33,1,10,22,84,14,92,48,79,10,3,62,33,61,13,93,78,20,63,68,17,80,34,12,8,23,61,90,51,17,84,37,46,64,25,3,73,19,45,99,41,62,21,77,8,17,89,9,13,84,75,85,14,53,60,6,29,76,63,14,23,63,61,93,72,17,41,28,94,5,3,19,47,57,55,14,34,38,79,85,40,13,22,99,67,72,15,62,15,6,63,3,90,2,87,20,84,15,50,70,27,18,78,21,70,48,52,2,99,92,55,3,46,41,93,99,88,13,39,4,45,71,3,96,1,91,59,31,53,23,25,82,32,50,16,60,38,78,34,59,30,15,51,92,3,22,26,62,60,37,42,74,28,21,76,7,24,70,18,40,11,81,41,9,73,62,12,66,81,9,3,74,62,11,6,56,16,34,20,78,79,1,97,17,39,87,15,12,77,94,28,22,66,45,59,39,2,6,52,6,72,49,17,92,15,86,18,92,79,67,20,22,72,10,72,3,52,26,77,78,41,97,36,59,88,24,57,12,38,90,53,14,38,67,2,36,44,93,99,10,41,49,3,16,7,63,32,11,15,81,12,91,39,62,19,83,6,91,28,19,80,38,23,63,31,71,14,58,8,21,71,21,21,81,38,26,32,29,82,52,28,72,54,97,41,65,96,75,1,48,28,80,66,25,47,49,29,87,51,12,50,70,36,60,81,29,77,76,55,25,40,45,83,91,26,72,99,12,47,11,20,27,52,9,98,17,99,27,37,62,25,3,15,73,66,22,5,85,5,20,98,20,38,62,78,21,16,59,28,98,38,31,2,40,46,87,14,48,33,80,48,36,27,56,21,1,50,83,3,61,92,20,52,16,50,10,86,9,98,39,56,25,50,42,39,91,81,56,25,70,44,24,15,99,4,20,55,12,98,27,65,20,77,97,76,36,42,87,6,11,79,65,16,65,44,13,90,13,48,79,13,95,60,19,55,24,66,4,53,11,23,68,14,97,53,45,14,16,93,18,29,83,5,6,77,19,70,97,34,20,70,52,11,74,14,72,10,36,44,33,45,19,38,36,77,5,37,51,1,55,17,2,48,23,18,2,34,90,97,24,30,51,66,33,70,51,37,31,51,37,65,55,18,8,66,4,65,62,26,93,29,88,3,75,73,24,23,67,1,13,68,7,36,87,62,48,1,31,45,28,62,86,24,98,1,59,49,37,26,62,36,44,66,18,17,97,92,40,36,65,80,84,5,84,6,79,87,36,31,96,15,71,96,2,72,11,81,95,94,41,54,31,58,25,74,24,51,81,38,32,73,22,96,40,62,22,59,74,39,25,86,2,55,20,61,40,37,88,69,1,60,42,18,31,54,13,27,19,93,34,41,99,33,89,20,16,52,84,32,94,31,6,61,25,1,61,1,38,78,87,39,31,39,26,68,42,36,2,94,66,2,67,30,80,2,95,65,40,54,50,33,11,23,97,89,1,31,56,9,35,49,92,55,23,84,48,91,20,7,72,25,55,3,85,3,16,40,90,22,99,44,38,86,98,11,76,26,76,13,82,80,24,93,4,15,64,95,58,15,85,25,57,29,66,3,66,19,98,57,24,44,59,35,76,48,31,92,33,94,68,56,41,45,15,46,5,68,15,65,34,73,49,68,17,78,28,80,24,59,26,74,21,52,1,94,5,61,41,88,37,56,1,49,0,0,21,21,1,10,1,0,0,0,0,0,0 \ No newline at end of file diff --git a/src/main/resources/day16.txt b/src/main/resources/day16.txt new file mode 100644 index 00000000..1101f127 --- /dev/null +++ b/src/main/resources/day16.txt @@ -0,0 +1 @@ +59773419794631560412886746550049210714854107066028081032096591759575145680294995770741204955183395640103527371801225795364363411455113236683168088750631442993123053909358252440339859092431844641600092736006758954422097244486920945182483159023820538645717611051770509314159895220529097322723261391627686997403783043710213655074108451646685558064317469095295303320622883691266307865809481566214524686422834824930414730886697237161697731339757655485312568793531202988525963494119232351266908405705634244498096660057021101738706453735025060225814133166491989584616948876879383198021336484629381888934600383957019607807995278899293254143523702000576897358 \ No newline at end of file diff --git a/src/main/resources/day17.txt b/src/main/resources/day17.txt new file mode 100644 index 00000000..4b95b77f --- /dev/null +++ b/src/main/resources/day17.txt @@ -0,0 +1 @@ +1,330,331,332,109,3564,1102,1182,1,15,1101,0,1449,24,1002,0,1,570,1006,570,36,101,0,571,0,1001,570,-1,570,1001,24,1,24,1106,0,18,1008,571,0,571,1001,15,1,15,1008,15,1449,570,1006,570,14,21102,58,1,0,1105,1,786,1006,332,62,99,21101,333,0,1,21102,1,73,0,1106,0,579,1101,0,0,572,1102,1,0,573,3,574,101,1,573,573,1007,574,65,570,1005,570,151,107,67,574,570,1005,570,151,1001,574,-64,574,1002,574,-1,574,1001,572,1,572,1007,572,11,570,1006,570,165,101,1182,572,127,1001,574,0,0,3,574,101,1,573,573,1008,574,10,570,1005,570,189,1008,574,44,570,1006,570,158,1105,1,81,21102,340,1,1,1106,0,177,21102,477,1,1,1105,1,177,21101,0,514,1,21101,176,0,0,1106,0,579,99,21102,1,184,0,1105,1,579,4,574,104,10,99,1007,573,22,570,1006,570,165,102,1,572,1182,21102,375,1,1,21102,1,211,0,1106,0,579,21101,1182,11,1,21102,222,1,0,1105,1,979,21101,388,0,1,21101,233,0,0,1105,1,579,21101,1182,22,1,21102,1,244,0,1105,1,979,21102,1,401,1,21102,255,1,0,1105,1,579,21101,1182,33,1,21102,1,266,0,1106,0,979,21102,1,414,1,21102,1,277,0,1105,1,579,3,575,1008,575,89,570,1008,575,121,575,1,575,570,575,3,574,1008,574,10,570,1006,570,291,104,10,21102,1,1182,1,21101,313,0,0,1105,1,622,1005,575,327,1102,1,1,575,21102,1,327,0,1105,1,786,4,438,99,0,1,1,6,77,97,105,110,58,10,33,10,69,120,112,101,99,116,101,100,32,102,117,110,99,116,105,111,110,32,110,97,109,101,32,98,117,116,32,103,111,116,58,32,0,12,70,117,110,99,116,105,111,110,32,65,58,10,12,70,117,110,99,116,105,111,110,32,66,58,10,12,70,117,110,99,116,105,111,110,32,67,58,10,23,67,111,110,116,105,110,117,111,117,115,32,118,105,100,101,111,32,102,101,101,100,63,10,0,37,10,69,120,112,101,99,116,101,100,32,82,44,32,76,44,32,111,114,32,100,105,115,116,97,110,99,101,32,98,117,116,32,103,111,116,58,32,36,10,69,120,112,101,99,116,101,100,32,99,111,109,109,97,32,111,114,32,110,101,119,108,105,110,101,32,98,117,116,32,103,111,116,58,32,43,10,68,101,102,105,110,105,116,105,111,110,115,32,109,97,121,32,98,101,32,97,116,32,109,111,115,116,32,50,48,32,99,104,97,114,97,99,116,101,114,115,33,10,94,62,118,60,0,1,0,-1,-1,0,1,0,0,0,0,0,0,1,36,16,0,109,4,1202,-3,1,586,21001,0,0,-1,22101,1,-3,-3,21102,0,1,-2,2208,-2,-1,570,1005,570,617,2201,-3,-2,609,4,0,21201,-2,1,-2,1105,1,597,109,-4,2105,1,0,109,5,2102,1,-4,629,21002,0,1,-2,22101,1,-4,-4,21101,0,0,-3,2208,-3,-2,570,1005,570,781,2201,-4,-3,652,21001,0,0,-1,1208,-1,-4,570,1005,570,709,1208,-1,-5,570,1005,570,734,1207,-1,0,570,1005,570,759,1206,-1,774,1001,578,562,684,1,0,576,576,1001,578,566,692,1,0,577,577,21102,1,702,0,1106,0,786,21201,-1,-1,-1,1106,0,676,1001,578,1,578,1008,578,4,570,1006,570,724,1001,578,-4,578,21102,731,1,0,1106,0,786,1106,0,774,1001,578,-1,578,1008,578,-1,570,1006,570,749,1001,578,4,578,21102,756,1,0,1106,0,786,1105,1,774,21202,-1,-11,1,22101,1182,1,1,21101,0,774,0,1105,1,622,21201,-3,1,-3,1106,0,640,109,-5,2106,0,0,109,7,1005,575,802,20102,1,576,-6,20102,1,577,-5,1105,1,814,21101,0,0,-1,21101,0,0,-5,21101,0,0,-6,20208,-6,576,-2,208,-5,577,570,22002,570,-2,-2,21202,-5,45,-3,22201,-6,-3,-3,22101,1449,-3,-3,1201,-3,0,843,1005,0,863,21202,-2,42,-4,22101,46,-4,-4,1206,-2,924,21102,1,1,-1,1106,0,924,1205,-2,873,21101,0,35,-4,1106,0,924,1201,-3,0,878,1008,0,1,570,1006,570,916,1001,374,1,374,2102,1,-3,895,1102,2,1,0,2102,1,-3,902,1001,438,0,438,2202,-6,-5,570,1,570,374,570,1,570,438,438,1001,578,558,921,21002,0,1,-4,1006,575,959,204,-4,22101,1,-6,-6,1208,-6,45,570,1006,570,814,104,10,22101,1,-5,-5,1208,-5,47,570,1006,570,810,104,10,1206,-1,974,99,1206,-1,974,1101,0,1,575,21101,0,973,0,1105,1,786,99,109,-7,2106,0,0,109,6,21102,1,0,-4,21101,0,0,-3,203,-2,22101,1,-3,-3,21208,-2,82,-1,1205,-1,1030,21208,-2,76,-1,1205,-1,1037,21207,-2,48,-1,1205,-1,1124,22107,57,-2,-1,1205,-1,1124,21201,-2,-48,-2,1106,0,1041,21101,0,-4,-2,1105,1,1041,21102,-5,1,-2,21201,-4,1,-4,21207,-4,11,-1,1206,-1,1138,2201,-5,-4,1059,1201,-2,0,0,203,-2,22101,1,-3,-3,21207,-2,48,-1,1205,-1,1107,22107,57,-2,-1,1205,-1,1107,21201,-2,-48,-2,2201,-5,-4,1090,20102,10,0,-1,22201,-2,-1,-2,2201,-5,-4,1103,2101,0,-2,0,1105,1,1060,21208,-2,10,-1,1205,-1,1162,21208,-2,44,-1,1206,-1,1131,1106,0,989,21102,1,439,1,1105,1,1150,21101,0,477,1,1105,1,1150,21102,1,514,1,21101,1149,0,0,1105,1,579,99,21102,1157,1,0,1106,0,579,204,-2,104,10,99,21207,-3,22,-1,1206,-1,1138,2101,0,-5,1176,1201,-4,0,0,109,-6,2105,1,0,36,9,36,1,7,1,36,1,7,1,36,1,7,1,24,7,5,1,7,1,24,1,5,1,5,1,7,1,24,1,5,1,1,13,24,1,5,1,1,1,3,1,32,1,5,1,1,1,3,7,26,1,5,1,1,1,9,1,26,1,5,1,1,1,9,1,26,1,5,1,1,1,9,1,26,9,9,1,32,1,11,1,32,1,11,1,32,1,11,1,32,7,5,1,44,1,44,1,44,1,36,9,36,1,22,9,13,1,22,1,7,1,13,1,20,13,9,7,16,1,1,1,7,1,1,1,9,1,1,1,3,1,10,5,1,1,1,1,7,1,1,1,9,1,1,1,3,1,10,1,3,1,1,1,1,1,7,1,1,1,9,1,1,1,3,1,6,13,7,1,1,1,3,5,1,1,1,5,6,1,3,1,3,1,1,1,9,1,1,1,3,1,3,1,1,1,12,1,3,7,9,13,12,1,7,1,13,1,3,1,3,1,14,1,7,1,13,9,14,1,7,1,17,1,18,9,17,7,44,1,44,1,44,1,42,9,38,1,5,1,38,1,5,1,38,1,5,1,38,1,5,1,38,1,5,1,38,1,5,1,38,1,5,1,38,7,6 \ No newline at end of file diff --git a/src/main/resources/day18.txt b/src/main/resources/day18.txt new file mode 100644 index 00000000..9200145e --- /dev/null +++ b/src/main/resources/day18.txt @@ -0,0 +1,81 @@ +################################################################################# +#.......#.A...........#.........#.......#.#.........#.............#...#..r......# +#.###.###.#####.#####.#.#######.#.#######.#.#.#####.#.#.#.#######.###.#.###.###.# +#...#.#...#.....#.#...#...#.....#.......#...#.#...#o#.#.#.#...#.#...#.#...#.#...# +#####.#.###.#####.#.###.#W###.#########.#####.#.#.###.#.#.#.#.#.###.#K###.#.##### +#.....#.#.#...#...#...#.#...#...........#...#...#.....#.#.#.#.#.#...#...#.#.....# +#M###.#.#.###.#.#####.#####.###########.#.#.###.#######.###.#.#.#.#####.#.#####.# +#.#...#...#...#.#...#.....#...#..z....#.#.#...#...#.....#...#.#.#.#...#.......#.# +#.###.###.#.###.#.#.#####.###.#.###.#.#.#.###.#####.#.###.###.#.#.#.#.#####.###.# +#...#...#.#.#....y#.....#.....#.#.#.#.#.#...#.#...#.#.#...#...#.#...#.#...#.#m..# +#.#.#####.#.###########.#######.#.#.#.#.###.#.#.#X#.#.#.###.###.#####.#.#.###.### +#.#.#...#.#s..#.......#.......#...#.#.#.#...#...#.#.#.#.#.#.#.......#...#...#...# +###.#.#.#.###.#.#####.###.###.#####.#.#.#.#######.#.###.#.#.#.#####.#######.###.# +#...#.#...#.#...#...#.#...#.......#.#.#.#.#.......#.....#.#.#.#.....#.....#.....# +#.###.#####.#####.#.#C#.###.#####.#.#.#.#.#####.###.#####.#.###.#####.#.#.#####.# +#.....#.....#.....#.#.#.#...#...#...#.#.#.#.F.#...#...#...#...#.#...#.#.#.....#.# +#.#######.#.###.###.#.#.#####.#.#######.#.#.#.###.###.###.###.#.#.#.#.#.#######.# +#.#.......#...#.#...#.#...#...#.#.......#...#.#.#...#.......#.#.#.#.#.#.........# +#.#.#########.#.#####.###N#.###.#.###########.#.###.#########.#.#.#.#.########### +#...#...#.......#.....#...#.#.#.#.......#...#.#...............#...#.#.#....q....# +#####.###.#######.#####.###.#.#.#######.#.#.#.#############.#####.#.#.#.#.#####.# +#g..#.....#.....#...#.#...#...#.......#.#.#.#..l..........#.#...#.#.#.#.#...#...# +###.#.#####.###.###.#T#.#.###.###.#####.###.#############.#####B#.#.#.#.###.##### +#...#.#...#...#.....#.#.#...#.#.#.#...#.#.......#.......#...#...#.#...#...#.....# +#.###.###.###.#####.#.###.###.#.#.#.#.#.#.#####.#.###.#####.#.###.#####.#######.# +#...#...#...#.#.#...#...#.I...#.#...#...#.....#.#...#.#...#...#.#...#.#.#.......# +###.###.#.###.#.#.#####.#####.#.#############.#####.#.#.#.#####.###.#.#.#.####### +#.....#.#...#.#.......#.#...#...........#.....#.....#...#.......#.#.#.#.#.......# +#.#####.###.#.#######.#.#.#.#####.#######.###.#.###########.###.#.#.#.#.#######.# +#...........#.#e....#.#...#...#...#.....#.#...#...#.........#.....#.#...#.......# +#.###########.#.###.#########.#####.###.#.#######.#.#####.#######.#.#####.#####.# +#.....#.#.....#.#.#.........#.......#...#.#.......#.#.....#.....#.#...#...#.#...# +#####.#.#.#####.#.#####.#.###########.###.#.#######.#####.#.###.#.###.#.###.#.### +#...#.#.#.......#.#.....#.#.........#.#.#...#.#.....#...#.#.#...#...#.#...#...#.# +#.###.#.#########.#.#####.#V#.#####.#.#.#.###.#.###.#.#.###.#.#######.###.#.###.# +#.#...#.....#.....#.#.....#.#...#...#.#.#.#...#.#.#.#.#.....#.........#...#.#...# +#.#.###.###.#.#####.#######.###.#.###.#.#.###.#.#.#.#.#################.###.#.#.# +#.#.....#.#.#.....#.......#.#.#.#...#.#.#.#...#.#...#.#.........#.......#.S.#.#.# +#.#######.#.#####.#######.#.#.#.#####.#.#.#.#.#.#####.#####.###.#.#######.###.#.# +#.......................#.....#.............#.#.............#.....#...........#.# +#######################################.@.####################################### +#...............#.....#.....#.............#.........................D.......#..u# +#.#############.#####.#.#.###.###.#####.#.#.#.#####.#######.###############.#.### +#.....#.....#...#...#...#.....#.#.#.....#...#....v#.#.....#.#.......#.....#.#.E.# +#####.#.#####.###.#.#.#########.#.#######.#######.###.###.###.#####.#.#####.#.#.# +#.....#.....#.....#.#.#...#.....#.......#.#.......#.....#.#...#...#.#....j#t#.#.# +#.#########.#######.#.#.#.#.###########.#.#.#######.#####.#.###.###.#####.#.#.#.# +#.......#...#...#...#...#...#.......#...#.#.#.....#.#.....#.#.....#.#...#.#.#.#.# +#######.#.#.###.#.#######.###.#####.#.#####.#.###.#.#.#####.#####.#.#.#.#.#.###.# +#.....#.#.#.....#...#.....#...#.....#...#...#.#.#...#.....#.......#...#.#.#.#...# +###.###.#.#####.###.#####.#.###.#####.#.#.#.#.#.#########.#######.#####.#.#.#.#.# +#...#...#...#...#.#.....#.#.#.#.#.....#.#.#d#.#.....#.......#.....#.....#.#...#.# +#.###.#####.#.###.#####.#.#.#.#.#######.#.###.###.#.#.#######.#####.#####.#####.# +#.....#...#.#.....#.....#.#.#.#...#.....#.....#...#.#.....#.....#...#...#.....#.# +#.#####.#.#.#.#####.#####.#.#.###.#.###.#######.#.#######.#.#####.#####.#.#.#.#.# +#.#.....#.#.#.#.....#.....#.#...#.#.#...#.......#.#.....#...#.#...#.....#.#.#.#.# +#.###.#.#.#.#.#.###########.###.#.#.#.###.#########.#.#######.#.#####.###.#.###.# +#.H.#.#.#.#.#.#.....#.....#.#...#...#...#.#.....#...#.........#.#.....#...#.....# +###.###.#.#.#.#####.#.###.#.#.#########.#.#.###.#.#######.#####.#.#.#.#.######### +#.#.#...#...#...#.#...#...#.#...#.......#...#.#...#.....#...#...#.#.#.#.........# +#.#.#.#.#######.#.#####.###.#.#.#.#######.###.#########.###.#.#####.#.#########.# +#...#.#.#...#.#.#...#...#...#.#.#...#...#...#...#.....#...#.#.#.....#.#.......#.# +#.###.###.#.#.#.###.#######.#.#.###.#.#.###.#.###.#.#.#.#.#.###.#####.###.###.#.# +#.#...#...#.#.#.#...........#.#...#.#.#.#.#.#.#...#.#...#.#.....#...#...#.#.#.#.# +#.###.#.###.#.#.#.###########.###.#.#.#.#.#.#.#.###.#####.#####.###.###.#.#.#.#.# +#...#...#.#.#.#...#...#.U...#.#.#...#.#.#...#.....#.#.....#...#...#...#...#...#.# +###.#.###.#.#.#####J#.#.#.###.#.#####.###.#######.#.#####.#.#####.#.#####.#####.# +#...#.Q.#.#.#.....#.#...#.....#.........#.......#.#f....#.L.#.....#h....#.#...#.# +#.#####.#.#.###.#.#.#################.#.#######.#.#####.###.#.#####.#.###.#.#.#.# +#.#...#...#...#.#.#.#...#.......#...#.#.#.#...G.#.....#.Z.#.#...#...#.....#.#...# +#.#.#####.###.###.#.#.#.#####.#.#.#.###.#.#.#############.#.###.#########.#.##### +#k#.#.....#.#...#.#..c#...#...#...#.#...#.#.#........n#...#...#.#.......#.#...#.# +#.#.#.#####.###.#.#######.#.#######.#.#.#.#.#.#######.#.###.###.#.#####.#####.#.# +#.#...#.....#...#.#.P...#.#.#.....#...#.#.#.#.#...#...#.#...#...#.....#.....#p..# +#.###.#.#.###.###.#.#.###.#.###.#.#####.#.#.#.#.###.###.###.#.#######.###.#####.# +#...#...#.#...#.#...#...#.#...#.#...#...#.O.#.#.....#.#...#b#.#.......#.#.#...#.# +###.#####.#.###.#.#####.#.###.#####.#.###.###.#.#####.#.#.###.#.#######.#.#.#.#.# +#.#.#.....#.#a..#.#...#.#.#...#.....#...#...#i#.#...#...#.Y.#.#.#....w..#.#.#...# +#.#R#######.#.#.#.###.#.#.#.###.#######.###.#.#.#.#.#######.#.#.#####.#.#.#.##### +#...........#.#.......#.....#...........#.....#x..#.........#.........#.#.......# +################################################################################# \ No newline at end of file diff --git a/src/main/resources/day19.txt b/src/main/resources/day19.txt new file mode 100644 index 00000000..4bdbeb34 --- /dev/null +++ b/src/main/resources/day19.txt @@ -0,0 +1 @@ +109,424,203,1,21102,11,1,0,1105,1,282,21101,0,18,0,1105,1,259,2101,0,1,221,203,1,21102,1,31,0,1105,1,282,21102,1,38,0,1105,1,259,20102,1,23,2,21201,1,0,3,21102,1,1,1,21102,57,1,0,1106,0,303,2102,1,1,222,21002,221,1,3,20101,0,221,2,21101,0,259,1,21101,0,80,0,1105,1,225,21101,44,0,2,21102,91,1,0,1105,1,303,1202,1,1,223,21002,222,1,4,21102,259,1,3,21102,1,225,2,21102,225,1,1,21101,118,0,0,1106,0,225,21002,222,1,3,21101,163,0,2,21101,0,133,0,1106,0,303,21202,1,-1,1,22001,223,1,1,21102,148,1,0,1106,0,259,1202,1,1,223,20101,0,221,4,21001,222,0,3,21102,1,24,2,1001,132,-2,224,1002,224,2,224,1001,224,3,224,1002,132,-1,132,1,224,132,224,21001,224,1,1,21101,195,0,0,105,1,108,20207,1,223,2,21002,23,1,1,21102,-1,1,3,21102,1,214,0,1106,0,303,22101,1,1,1,204,1,99,0,0,0,0,109,5,2101,0,-4,249,22102,1,-3,1,22101,0,-2,2,22101,0,-1,3,21102,250,1,0,1106,0,225,21202,1,1,-4,109,-5,2105,1,0,109,3,22107,0,-2,-1,21202,-1,2,-1,21201,-1,-1,-1,22202,-1,-2,-2,109,-3,2106,0,0,109,3,21207,-2,0,-1,1206,-1,294,104,0,99,22102,1,-2,-2,109,-3,2105,1,0,109,5,22207,-3,-4,-1,1206,-1,346,22201,-4,-3,-4,21202,-3,-1,-1,22201,-4,-1,2,21202,2,-1,-1,22201,-4,-1,1,21202,-2,1,3,21101,0,343,0,1106,0,303,1106,0,415,22207,-2,-3,-1,1206,-1,387,22201,-3,-2,-3,21202,-2,-1,-1,22201,-3,-1,3,21202,3,-1,-1,22201,-3,-1,2,21201,-4,0,1,21101,384,0,0,1105,1,303,1105,1,415,21202,-4,-1,-4,22201,-4,-3,-4,22202,-3,-2,-2,22202,-2,-4,-4,22202,-3,-2,-3,21202,-4,-1,-2,22201,-3,-2,1,21202,1,1,-4,109,-5,2105,1,0 \ No newline at end of file diff --git a/src/main/resources/day2.txt b/src/main/resources/day2.txt new file mode 100644 index 00000000..b61b8381 --- /dev/null +++ b/src/main/resources/day2.txt @@ -0,0 +1 @@ +1,0,0,3,1,1,2,3,1,3,4,3,1,5,0,3,2,10,1,19,1,6,19,23,2,23,6,27,1,5,27,31,1,31,9,35,2,10,35,39,1,5,39,43,2,43,10,47,1,47,6,51,2,51,6,55,2,55,13,59,2,6,59,63,1,63,5,67,1,6,67,71,2,71,9,75,1,6,75,79,2,13,79,83,1,9,83,87,1,87,13,91,2,91,10,95,1,6,95,99,1,99,13,103,1,13,103,107,2,107,10,111,1,9,111,115,1,115,10,119,1,5,119,123,1,6,123,127,1,10,127,131,1,2,131,135,1,135,10,0,99,2,14,0,0 \ No newline at end of file diff --git a/src/main/resources/day20.txt b/src/main/resources/day20.txt new file mode 100644 index 00000000..b93543d5 --- /dev/null +++ b/src/main/resources/day20.txt @@ -0,0 +1,107 @@ + L S F Z O X Q W + T S P Z J J X L + #############################.#######.#####.#.#####.#####.#####.#####.################################# + #.#.....#.....#.#.#.#.....#.....#.#.......#...#.....#.#...#.#.#.#.......#...#.#.#...#.#...#.#...#.#.#.# + #.###.#.###.###.#.#.###.#####.###.###.#.#####.###.###.#.###.#.#.#####.###.#.#.#.#.###.#.###.#.#.#.#.#.# + #.....#.#...#.#.....#.#...#.....#.#.#.#.#...#.#.....#.......#...#...#.....#.#.............#.#.#.....#.# + #######.###.#.#.#####.###.#.#####.#.###.#.#.#.#####.#.#.#.#.#.#.#.###.#####.#.#.#########.#.#.#######.# + #...#.....#.....#...#.........#.......#.#.#.....#...#.#.#.#.#.#.#...#.#.......#.........#.......#.....# + #.#######.#####.###.#########.###.###.#.#.#######.#.###.###.###.###.#.#.#####.#.#####.#.#.#.#######.### + #.#...#.....#.......#.#.#.#...#...#...#.#...#...#.#...#...#.#.....#...#.....#.#.....#.#.#.#.#.#.#.....# + #.#.#####.#.###.###.#.#.#.#.#####.###.#.#.###.#####.#.#.#######.#####.#####.###########.###.#.#.#.###.# + #...#...#.#.......#...........#.....#.#.#...#...#...#.#.....#...#.....#...#.#.....#...#.#.#.#.....#.#.# + ###.#.#######.#############.#######.#.#.###.#.#####.#.#.#.###.#.#######.#.#.#.###.###.###.#####.###.### + #.........#.#.#.....#...#.......#...#...#.......#...#.#.#.#.#.#.....#...#.......#.#.......#.....#...#.# + #.###.###.#.#.#####.###.###.#####.###.#.###.#.#######.#.###.###.#.#.#.#.#.###.###.###.#####.###.#.###.# + #.#...#.........#...............#.#...#.#...#...#.....#...#...#.#.#.#.#.#...#.#.......#.#.#...#...#...# + ###.#######.#.#####.###.###.#####.#######.###########.#.###.###.#####.#################.#.#.#####.###.# + #.#...#.....#.....#...#.#.....#.......#.#...#.........#.....#.#.....#...........#.#.#.#...#.#.#.#.#...# + #.#######.###.#.###########.#########.#.###.###.###.#######.#.###.###.#.###.#####.#.#.#.#.###.#.#.#.### + #.#...#.#.#...#...#.............#.......#.....#...#...#.......#...#...#.#...#.#...#.#...#...#.#.#...#.# + #.###.#.#####.#####.#######.###.###.#####.###########.###.#####.#####.#######.#.###.###.#####.#.#.###.# + #.#.........#.....#.#.....#.#.....#.....#...#.#.....#.#.......#...#.#...........#.#.#...#.#.#.#...#...# + #.#.#####.#.#.#.###.#####.###.#####.#.#####.#.###.#.#.###.#####.#.#.#.#####.#####.#.###.#.#.#.###.#.#.# + #.#.#.#...#.#.#.#.#.#.....#.......#.#.#.#.....#...#...#...#.....#.#.#.#.....#.#.#.#.#.....#...#...#.#.# + #.###.###.#######.#####.#.#####.#####.#.#.#####.###.#.#.#######.###.#.#####.#.#.#.#.###.#####.###.#.### + #.#.#...#.#.#.....#...#.#.......#.......#.....#...#.#.#.......#.....#.#...........#...#...#.#.#.......# + #.#.#.###.#.#####.###.#######.#########.#####.#.#############.#####.#####.#########.###.###.#.###.###.# + #.#.....#.#.#.#.#...#.#.# U D P I Q L M #.#...#...#.......#.#...# + #.#####.#.#.#.#.#.###.#.# E R V Q X T X #.###.###.###.#######.#.# + #.#.........#.#.....#.#.# #...#.#.#.#.......#.#.#.# + #.###.#######.###.###.#.# #.###.#.#.###.#####.###.# + #.#.#...#.....#.#.......# TI......#.........#.#.....# + #.#.#.#######.#.###.###.# #.#.#.#.###.#.###.###.#.# + #.....#.....#...#.#.#...# #.#.#...#...#.....#...#..IQ + #.###.###.#####.#.#.###.# #.#.#.#.#.#####.#.#.#.### +TI..#...#.....#...#.#...#..WL #.#.#.#.#.#.....#.#.#...# + #.#.###.#.#####.#.###.#.# #############.#####.#.### + #.#.....#.............#.# #...#...#.#.........#.#.# + #######.#.#.#.#.#######.# ###.###.#.#####.#.#####.# + #.....#.#.#.#.#.#.#.....# #.............#.#.#.#....UE + #.###.###########.###.### ###.#.#######.#####.###.# + #...#...#.....#...#...#.# #...#.....#...........#.# + ###.###.#.#.#####.###.#.# #.#####.#.###.###.###.#.# +OG..#...#...#...#.#.#.#.#..OB #.#.....#.#.#...#.#...#.# + #.###.#####.###.#.#.###.# ###.###.#.#.#########.#.# + #.......#...............# VU....#...#.#.#...#...#...# + #.###.#.#.#.#.###.#.##### #.#########.#.#####.##### + #...#.#.#.#.#...#.#.#....ZH #...#...#...#.....#.....# + #####.#.###.#.#######.### #######.#.#.#.###.#.###.# + #...#.#.#.#.#...#.......# #.....#...#.....#.....#.# + ###.#####.###.#########.# #.#.###.#####.###.#.###.# +PV....#.#.....#.#.#.#.#...# #.#.......#.....#.#.#...# + #.#.#.#.#.#####.#.#.#.### ###.#.#############.#.#.# + #.#.....#.............#.# DS....#.#.#.....#.#.#.#.#..DR + #######################.# #######.###.###.#.####### + #.................#.....# #.#.#.................#.# + #.###.###.#.#.#.#.#.###.# #.#.#.#####.###.#####.#.# + #.#...#.#.#.#.#.#.#.#...# SB....#...#.....#.#...#...# + #####.#.#########.#.#.### #.###.###.#.###.###.###.# + #...#.......#...#...#...# #.......#.#.#...#.#.#...# + #.#.#.###.###.#####.###.# #.#.#.#####.#####.#.#.### +GU..#...#...#...#.#.....#..SS #.#.#.#.#.#.#.#.#.#......QN + #############.#.#######.# #####.#.#.###.#.#.####### + #.#.#...............#.#.# OJ..#.#.#...#.......#.#....PO + #.#.#.#######.#.###.#.### #.#.###.#.#.#####.#.###.# +AA....#.....#.#.#.#.#.....# #...#...#.....#.#...#...# + #.###.#.#.#.#####.#####.# #.#.#.#.#.#####.#.#.#.#.# + #...#.#.#.....#.........# #.#...#.#.#...#...#.#.#.# + #.#.#.#####.#####.#.##### #.#.###.#.#.###.#.#.#.#.# +MX..#.....#.#...#.#.#......OQ QN..#.#...#.#.#.#.#.#...#..MH + ###.#####.#####.###.##### ###########.#.########### + #.#.#.#.#.....#...#.#....MH PO......#.#................YJ + #.###.#.#.#######.#####.# #.#.###.#.#.#.###.###.#.# + #...#.........#.........# #.#.#.....#.#.#.....#.#.# + #.#.#.#.###############.# ###.#.#########.#.#.#.#.# +OB..#.#.#...#.#.#.#.....#.# #...#.....#.#.#.#.#.#.#.# + #.#.#.#.###.#.#.#.#.#.#.# #.#######.#.#.###.#.##### + #.#...#...........#.#...# #...............#.#.....# + ###.###.#.#.#.#.#####.#.# X D H O G F Y #.#.#.###.###.#####.###.# + #.....#.#.#.#.#...#...#.# J C Y G U P J #.#.#.#.....#.....#.#.#.# + ###.###.###.#.#.###.#.###########.#.#######.#######.#########.#.#########.#########.###.#######.###.### + #.#...#...#.#.#...#.#.#.#.#.....#.#...#.........#...#.........#.....#.......#.....#.#.........#.#.#...# + #.#.###.#####.#.#.#####.#.#.###.#.###.#########.#.#####.#########.#####.#######.#####.###.#.#####.###.# + #...#.....#.#.#.#...#.#.......#...#.......#.....#.#...........#...#.#.#.............#.#...#...........# + ###.###.###.###.#####.#.#.###.#######.#.#####.###.#.#####.###.###.#.#.###.#.###.#.###.#.###.#.#######.# + #.#...#...#.........#...#...#.......#.#.#...#...#.#.#...#.#.....#.#.....#.#...#.#.#...#.#...#...#.....# + #.#.#.#.###.###.#.#######.#.#.###.#.###.#.#####.#.###.#####.#####.#.#.###.###########.#####.###.###.#.# + #...#.#.#.....#.#...#.#...#.#.#.#.#.#.......#...#...#.......#.....#.#...#.......#.#.#.#.......#.#.#.#.# + #.#.###.#.#.#.#####.#.#.#.#####.#.#.###.###.###.#.###.#.###.#####.#.#.###.#######.#.#.#####.###.#.###.# + #.#...#.#.#.#.#.#.#.#.#.#...#.....#.#.....#.#.#.#...#.#...#...#.....#.#.......#.#.#...#...#.#...#.....# + #######.#####.#.#.###.###.#####.#.#####.#####.#.#.#####.#######.#####.###.#####.#.#####.#.#####.#.###.# + #.#.#.#.....#.#.#.......#.#.#...#.....#.#.#.....#.....#.#.#.#...#.....#.................#...#...#...#.# + #.#.#.#.#.#####.#####.#####.#####.#####.#.###.###.#####.#.#.#######.###.#.#######.###.#.#######.#.###.# + #.......#.#.#.#...#.......#.........#.....#.#...#.#.#.....#.#.#.#.#...#.#.....#.#...#.#.......#.#.#...# + #.#.###.###.#.###.###.#########.###.###.###.###.#.#.#.###.#.#.#.#.###.#.###.#.#.#######.#########.###.# + #.#.#.#...#.......................#.#...#.#.....#...#.#.......#.......#...#.#.#.#...#.#.#.....#...#...# + #.###.#.###.###.###.#######.#########.#.#.#.###.###.###.#######.###.#####.#####.#.###.#####.#####.###.# + #...#...#.#.#.....#.#...#...#.....#...#.#.....#.#.#.#.#.#.#.#.....#...#.....#...........#.......#.#...# + #.###.###.#########.###.###.#.#.###.#.#####.#####.#.#.#.#.#.#######.#.#.#######.###.#####.###########.# + #.#.....#.#.#.......#.....#...#...#.#.#.....#.........#.#.#.#...#...#.#...........#...#.#...#.....#...# + ###.###.#.#.#######.###.#######.#####.###.#########.#.#.#.#.#.#######.###.#.###.###.###.#.###.######### + #...#.......#.......#.#...........#.....#.#.....#...#.#...#...#...#...#...#...#.#.....................# + #.###.#.###.#.#.#####.#####.###########.#.#.###.#.###.#.###.#.###.#.###.#.###########.###.###.######### + #.#...#.#...#.#.#...................#...#...#...#.#...#.....#.#.....#...#...........#...#...#.........# + #################################.###.#########.#####.#######.###.#####.############################### + H V Z D S D O + Y U H C B S Q \ No newline at end of file diff --git a/src/main/resources/day21.txt b/src/main/resources/day21.txt new file mode 100644 index 00000000..445de007 --- /dev/null +++ b/src/main/resources/day21.txt @@ -0,0 +1 @@ +109,2050,21101,966,0,1,21102,1,13,0,1105,1,1378,21102,20,1,0,1106,0,1337,21101,0,27,0,1106,0,1279,1208,1,65,748,1005,748,73,1208,1,79,748,1005,748,110,1208,1,78,748,1005,748,132,1208,1,87,748,1005,748,169,1208,1,82,748,1005,748,239,21102,1041,1,1,21102,73,1,0,1105,1,1421,21101,78,0,1,21101,1041,0,2,21102,88,1,0,1106,0,1301,21102,1,68,1,21101,1041,0,2,21102,1,103,0,1105,1,1301,1101,0,1,750,1106,0,298,21102,82,1,1,21101,1041,0,2,21101,125,0,0,1106,0,1301,1101,2,0,750,1106,0,298,21102,79,1,1,21101,0,1041,2,21101,147,0,0,1105,1,1301,21101,84,0,1,21102,1041,1,2,21102,162,1,0,1106,0,1301,1101,3,0,750,1106,0,298,21102,65,1,1,21102,1,1041,2,21102,184,1,0,1105,1,1301,21102,1,76,1,21102,1,1041,2,21101,0,199,0,1106,0,1301,21102,75,1,1,21101,1041,0,2,21102,1,214,0,1106,0,1301,21101,0,221,0,1106,0,1337,21101,0,10,1,21102,1,1041,2,21102,236,1,0,1105,1,1301,1106,0,553,21102,1,85,1,21101,1041,0,2,21101,0,254,0,1105,1,1301,21102,78,1,1,21101,0,1041,2,21102,1,269,0,1105,1,1301,21101,276,0,0,1106,0,1337,21101,0,10,1,21101,0,1041,2,21102,1,291,0,1105,1,1301,1101,0,1,755,1105,1,553,21101,0,32,1,21101,1041,0,2,21101,0,313,0,1105,1,1301,21102,1,320,0,1106,0,1337,21102,1,327,0,1106,0,1279,2102,1,1,749,21101,0,65,2,21102,1,73,3,21101,0,346,0,1105,1,1889,1206,1,367,1007,749,69,748,1005,748,360,1101,0,1,756,1001,749,-64,751,1106,0,406,1008,749,74,748,1006,748,381,1102,-1,1,751,1106,0,406,1008,749,84,748,1006,748,395,1101,-2,0,751,1105,1,406,21101,1100,0,1,21102,406,1,0,1105,1,1421,21101,0,32,1,21102,1100,1,2,21102,1,421,0,1105,1,1301,21102,1,428,0,1105,1,1337,21102,1,435,0,1105,1,1279,2101,0,1,749,1008,749,74,748,1006,748,453,1101,0,-1,752,1106,0,478,1008,749,84,748,1006,748,467,1101,-2,0,752,1106,0,478,21102,1168,1,1,21101,0,478,0,1105,1,1421,21101,485,0,0,1105,1,1337,21102,10,1,1,21101,1168,0,2,21101,0,500,0,1105,1,1301,1007,920,15,748,1005,748,518,21101,0,1209,1,21102,518,1,0,1106,0,1421,1002,920,3,529,1001,529,921,529,1002,750,1,0,1001,529,1,537,1001,751,0,0,1001,537,1,545,101,0,752,0,1001,920,1,920,1106,0,13,1005,755,577,1006,756,570,21101,1100,0,1,21102,1,570,0,1105,1,1421,21102,1,987,1,1106,0,581,21101,1001,0,1,21101,588,0,0,1105,1,1378,1102,1,758,594,101,0,0,753,1006,753,654,21001,753,0,1,21102,610,1,0,1106,0,667,21101,0,0,1,21101,621,0,0,1105,1,1463,1205,1,647,21102,1015,1,1,21101,635,0,0,1105,1,1378,21102,1,1,1,21102,1,646,0,1105,1,1463,99,1001,594,1,594,1106,0,592,1006,755,664,1101,0,0,755,1106,0,647,4,754,99,109,2,1101,726,0,757,21201,-1,0,1,21101,9,0,2,21101,697,0,3,21102,1,692,0,1106,0,1913,109,-2,2106,0,0,109,2,101,0,757,706,1201,-1,0,0,1001,757,1,757,109,-2,2106,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,255,63,223,127,159,191,95,0,183,170,218,117,217,86,155,244,187,178,56,109,253,154,38,184,213,110,189,233,212,87,50,141,169,125,236,207,171,175,230,114,137,197,99,49,249,136,239,93,242,57,231,100,228,172,219,102,140,69,84,206,92,174,77,179,166,76,163,139,203,120,173,43,62,202,124,216,103,138,71,39,54,143,227,79,157,158,167,250,126,198,235,58,121,251,156,199,35,68,246,215,53,47,185,221,182,46,168,115,51,123,142,229,85,111,201,248,107,204,70,98,34,42,188,222,60,254,196,162,220,153,78,61,55,119,252,186,181,243,238,101,118,106,214,234,226,113,108,94,152,116,200,232,59,190,247,122,245,205,237,241,177,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,20,73,110,112,117,116,32,105,110,115,116,114,117,99,116,105,111,110,115,58,10,13,10,87,97,108,107,105,110,103,46,46,46,10,10,13,10,82,117,110,110,105,110,103,46,46,46,10,10,25,10,68,105,100,110,39,116,32,109,97,107,101,32,105,116,32,97,99,114,111,115,115,58,10,10,58,73,110,118,97,108,105,100,32,111,112,101,114,97,116,105,111,110,59,32,101,120,112,101,99,116,101,100,32,115,111,109,101,116,104,105,110,103,32,108,105,107,101,32,65,78,68,44,32,79,82,44,32,111,114,32,78,79,84,67,73,110,118,97,108,105,100,32,102,105,114,115,116,32,97,114,103,117,109,101,110,116,59,32,101,120,112,101,99,116,101,100,32,115,111,109,101,116,104,105,110,103,32,108,105,107,101,32,65,44,32,66,44,32,67,44,32,68,44,32,74,44,32,111,114,32,84,40,73,110,118,97,108,105,100,32,115,101,99,111,110,100,32,97,114,103,117,109,101,110,116,59,32,101,120,112,101,99,116,101,100,32,74,32,111,114,32,84,52,79,117,116,32,111,102,32,109,101,109,111,114,121,59,32,97,116,32,109,111,115,116,32,49,53,32,105,110,115,116,114,117,99,116,105,111,110,115,32,99,97,110,32,98,101,32,115,116,111,114,101,100,0,109,1,1005,1262,1270,3,1262,21002,1262,1,0,109,-1,2105,1,0,109,1,21102,1,1288,0,1105,1,1263,21001,1262,0,0,1102,1,0,1262,109,-1,2105,1,0,109,5,21101,0,1310,0,1106,0,1279,22101,0,1,-2,22208,-2,-4,-1,1205,-1,1332,22102,1,-3,1,21102,1332,1,0,1105,1,1421,109,-5,2105,1,0,109,2,21101,1346,0,0,1105,1,1263,21208,1,32,-1,1205,-1,1363,21208,1,9,-1,1205,-1,1363,1106,0,1373,21101,0,1370,0,1105,1,1279,1106,0,1339,109,-2,2105,1,0,109,5,2102,1,-4,1385,21001,0,0,-2,22101,1,-4,-4,21101,0,0,-3,22208,-3,-2,-1,1205,-1,1416,2201,-4,-3,1408,4,0,21201,-3,1,-3,1106,0,1396,109,-5,2105,1,0,109,2,104,10,22102,1,-1,1,21102,1436,1,0,1106,0,1378,104,10,99,109,-2,2105,1,0,109,3,20002,594,753,-1,22202,-1,-2,-1,201,-1,754,754,109,-3,2106,0,0,109,10,21101,0,5,-5,21102,1,1,-4,21102,0,1,-3,1206,-9,1555,21101,3,0,-6,21102,1,5,-7,22208,-7,-5,-8,1206,-8,1507,22208,-6,-4,-8,1206,-8,1507,104,64,1106,0,1529,1205,-6,1527,1201,-7,716,1515,21002,0,-11,-8,21201,-8,46,-8,204,-8,1106,0,1529,104,46,21201,-7,1,-7,21207,-7,22,-8,1205,-8,1488,104,10,21201,-6,-1,-6,21207,-6,0,-8,1206,-8,1484,104,10,21207,-4,1,-8,1206,-8,1569,21101,0,0,-9,1105,1,1689,21208,-5,21,-8,1206,-8,1583,21102,1,1,-9,1105,1,1689,1201,-5,716,1589,20102,1,0,-2,21208,-4,1,-1,22202,-2,-1,-1,1205,-2,1613,21201,-5,0,1,21101,0,1613,0,1106,0,1444,1206,-1,1634,22101,0,-5,1,21101,1627,0,0,1105,1,1694,1206,1,1634,21101,0,2,-3,22107,1,-4,-8,22201,-1,-8,-8,1206,-8,1649,21201,-5,1,-5,1206,-3,1663,21201,-3,-1,-3,21201,-4,1,-4,1106,0,1667,21201,-4,-1,-4,21208,-4,0,-1,1201,-5,716,1676,22002,0,-1,-1,1206,-1,1686,21101,1,0,-4,1106,0,1477,109,-10,2106,0,0,109,11,21101,0,0,-6,21102,0,1,-8,21101,0,0,-7,20208,-6,920,-9,1205,-9,1880,21202,-6,3,-9,1201,-9,921,1725,20101,0,0,-5,1001,1725,1,1732,21002,0,1,-4,21202,-4,1,1,21102,1,1,2,21101,9,0,3,21102,1,1754,0,1105,1,1889,1206,1,1772,2201,-10,-4,1766,1001,1766,716,1766,21001,0,0,-3,1105,1,1790,21208,-4,-1,-9,1206,-9,1786,22102,1,-8,-3,1105,1,1790,21202,-7,1,-3,1001,1732,1,1795,21002,0,1,-2,21208,-2,-1,-9,1206,-9,1812,21201,-8,0,-1,1106,0,1816,21202,-7,1,-1,21208,-5,1,-9,1205,-9,1837,21208,-5,2,-9,1205,-9,1844,21208,-3,0,-1,1106,0,1855,22202,-3,-1,-1,1106,0,1855,22201,-3,-1,-1,22107,0,-1,-1,1106,0,1855,21208,-2,-1,-9,1206,-9,1869,22101,0,-1,-8,1106,0,1873,21201,-1,0,-7,21201,-6,1,-6,1106,0,1708,22101,0,-8,-10,109,-11,2106,0,0,109,7,22207,-6,-5,-3,22207,-4,-6,-2,22201,-3,-2,-1,21208,-1,0,-6,109,-7,2106,0,0,0,109,5,2101,0,-2,1912,21207,-4,0,-1,1206,-1,1930,21101,0,0,-4,21201,-4,0,1,21202,-3,1,2,21101,0,1,3,21102,1,1949,0,1106,0,1954,109,-5,2105,1,0,109,6,21207,-4,1,-1,1206,-1,1977,22207,-5,-3,-1,1206,-1,1977,22101,0,-5,-5,1105,1,2045,21201,-5,0,1,21201,-4,-1,2,21202,-3,2,3,21101,1996,0,0,1106,0,1954,22101,0,1,-5,21102,1,1,-2,22207,-5,-3,-1,1206,-1,2015,21102,1,0,-2,22202,-3,-2,-3,22107,0,-4,-1,1206,-1,2037,21201,-2,0,1,21102,2037,1,0,106,0,1912,21202,-3,-1,-3,22201,-5,-3,-5,109,-6,2105,1,0 \ No newline at end of file diff --git a/src/main/resources/day22.txt b/src/main/resources/day22.txt new file mode 100644 index 00000000..55ab7933 --- /dev/null +++ b/src/main/resources/day22.txt @@ -0,0 +1,100 @@ +deal with increment 31 +deal into new stack +cut -7558 +deal with increment 49 +cut 194 +deal with increment 23 +cut -4891 +deal with increment 53 +cut 5938 +deal with increment 61 +cut 7454 +deal into new stack +deal with increment 31 +cut 3138 +deal with increment 53 +cut 3553 +deal with increment 61 +cut -5824 +deal with increment 42 +cut -889 +deal with increment 34 +cut 7128 +deal with increment 42 +cut -9003 +deal with increment 75 +cut 13 +deal with increment 75 +cut -3065 +deal with increment 74 +cut -8156 +deal with increment 39 +cut 4242 +deal with increment 24 +cut -405 +deal with increment 27 +cut 6273 +deal with increment 19 +cut -9826 +deal with increment 58 +deal into new stack +cut -6927 +deal with increment 65 +cut -9906 +deal with increment 31 +deal into new stack +deal with increment 42 +deal into new stack +deal with increment 39 +cut -4271 +deal into new stack +deal with increment 32 +cut -8799 +deal with increment 69 +cut 2277 +deal with increment 55 +cut 2871 +deal with increment 54 +cut -2118 +deal with increment 15 +cut 1529 +deal with increment 57 +cut -4745 +deal with increment 23 +cut -5959 +deal with increment 58 +deal into new stack +deal with increment 48 +deal into new stack +cut 2501 +deal into new stack +deal with increment 42 +deal into new stack +cut 831 +deal with increment 74 +cut -3119 +deal with increment 33 +cut 967 +deal with increment 69 +cut 9191 +deal with increment 9 +cut 5489 +deal with increment 62 +cut -9107 +deal with increment 14 +cut -7717 +deal with increment 56 +cut 7900 +deal with increment 49 +cut 631 +deal with increment 14 +deal into new stack +deal with increment 58 +cut -9978 +deal with increment 48 +deal into new stack +deal with increment 66 +cut -1554 +deal into new stack +cut 897 +deal with increment 36 \ No newline at end of file diff --git a/src/main/resources/day3.txt b/src/main/resources/day3.txt new file mode 100644 index 00000000..e50c4981 --- /dev/null +++ b/src/main/resources/day3.txt @@ -0,0 +1,2 @@ +R991,U77,L916,D26,R424,D739,L558,D439,R636,U616,L364,D653,R546,U909,L66,D472,R341,U906,L37,D360,L369,D451,L649,D521,R2,U491,R409,U801,R23,U323,L209,U171,L849,D891,L854,U224,R476,D519,L937,U345,R722,D785,L312,D949,R124,U20,R677,D236,R820,D320,L549,D631,R42,U621,R760,U958,L925,U84,R914,U656,R598,D610,R397,D753,L109,U988,R435,U828,R219,U583,L317,D520,L940,D850,R594,D801,L422,U292,R883,U204,L76,U860,L753,U483,L183,U179,R441,U163,L859,U437,L485,D239,R454,D940,R689,D704,R110,D12,R370,D413,L192,D979,R990,D651,L308,U177,R787,D717,R245,U689,R11,D509,L680,U228,L347,D179,R508,D40,L502,U689,L643,U45,R884,D653,L23,D918,L825,D312,L691,U292,L285,D183,R997,U427,L89,U252,R475,U217,R16,U749,L578,D931,L273,U509,L741,U97,R407,U275,L605,U136,L558,U318,R478,U505,R446,U295,R562,D646,R988,D254,L68,U645,L953,U916,L442,D713,R978,U540,R447,U594,L804,U215,R95,D995,R818,D237,R212,U664,R455,D684,L338,U308,R463,D985,L988,D281,R758,U510,L232,U509,R289,D90,R65,D46,R886,D741,L327,U755,R236,U870,L764,U60,R391,U91,R367,U587,L651,D434,L47,U954,R707,D336,L242,D387,L410,D19,R203,D703,L228,U292,L19,U916,R411,U421,L726,U543,L240,U755,R157,U836,L397,U71,L125,D934,L723,D145,L317,D229,R863,U941,L926,D55,L2,D452,R895,D670,L216,U504,R66,U696,L581,U75,L235,U88,L609,U415,L850,U21,L109,U416,R408,D367,R823,D199,L718,U136,L860,U780,L308,D312,R230,D671,R477,D672,L94,U307,R301,D143,L300,D792,L593,D399,R840,D225,R680,D484,L646,D917,R132,D213,L779,D143,L176,U673,L772,D93,L10,D624,L244,D993,R346 +L997,U989,L596,U821,L419,U118,R258,D239,R902,D810,R553,D271,R213,D787,R723,D57,L874,D556,R53,U317,L196,D813,R500,U151,R180,D293,L415,U493,L99,U482,R517,U649,R102,U860,R905,D499,R133,D741,R394,U737,L903,U800,R755,D376,L11,U751,R539,U33,R539,U30,L534,D631,L714,U190,L446,U409,R977,D731,R282,U244,R29,D212,L523,D570,L89,D327,R178,U970,R435,U250,R213,D604,R64,D348,R315,D994,L508,D261,R62,D50,L347,U183,R410,D627,L128,U855,L803,D695,L879,U857,L629,D145,L341,D733,L566,D626,L302,U236,L55,U428,R183,U254,R226,D228,R616,U137,L593,U204,R620,U624,R605,D705,L263,D568,R931,D464,R989,U621,L277,U274,L137,U768,L261,D360,L45,D110,R35,U212,L271,D318,L444,D427,R225,D380,L907,D193,L118,U741,L101,D298,R604,D598,L98,U458,L733,U511,L82,D173,L644,U803,R926,D610,R24,D170,L198,U766,R656,D474,L393,D934,L789,U92,L889,U460,L232,U193,L877,D380,L455,D526,R899,D696,R452,U95,L828,D720,R370,U664,L792,D204,R84,D749,R808,U132,L152,D375,R19,U164,L615,D121,R644,D289,R381,U126,L304,U508,L112,D268,L572,D838,L998,U127,R500,D344,R694,U451,L846,D565,R158,U47,L430,U214,R571,D983,R690,D227,L107,U109,L286,D66,L544,U205,L453,U716,L36,U672,L517,U878,L487,U936,L628,U253,R424,D409,R422,U636,R412,U553,R59,D332,R7,U495,L305,D939,L428,D821,R749,D195,R531,D898,R337,D303,L398,D625,R57,D503,L699,D553,L478,U716,R897,D3,R420,U903,R994,U864,L745,U205,R229,U126,L227,D454,R670,U605,L356,U499,R510,U238,L542,D440,R156,D512,L237,D341,L439,U642,R873,D650,R871,D616,R322,U696,R248,D746,R990,U829,R812,U294,L462,U740,R780 \ No newline at end of file diff --git a/src/main/resources/day4.txt b/src/main/resources/day4.txt new file mode 100644 index 00000000..4ef936f1 --- /dev/null +++ b/src/main/resources/day4.txt @@ -0,0 +1 @@ +372037-905157 \ No newline at end of file diff --git a/src/main/resources/day5.txt b/src/main/resources/day5.txt new file mode 100644 index 00000000..e2f7f832 --- /dev/null +++ b/src/main/resources/day5.txt @@ -0,0 +1 @@ +3,225,1,225,6,6,1100,1,238,225,104,0,1,192,154,224,101,-161,224,224,4,224,102,8,223,223,101,5,224,224,1,223,224,223,1001,157,48,224,1001,224,-61,224,4,224,102,8,223,223,101,2,224,224,1,223,224,223,1102,15,28,225,1002,162,75,224,1001,224,-600,224,4,224,1002,223,8,223,1001,224,1,224,1,224,223,223,102,32,57,224,1001,224,-480,224,4,224,102,8,223,223,101,1,224,224,1,224,223,223,1101,6,23,225,1102,15,70,224,1001,224,-1050,224,4,224,1002,223,8,223,101,5,224,224,1,224,223,223,101,53,196,224,1001,224,-63,224,4,224,102,8,223,223,1001,224,3,224,1,224,223,223,1101,64,94,225,1102,13,23,225,1101,41,8,225,2,105,187,224,1001,224,-60,224,4,224,1002,223,8,223,101,6,224,224,1,224,223,223,1101,10,23,225,1101,16,67,225,1101,58,10,225,1101,25,34,224,1001,224,-59,224,4,224,1002,223,8,223,1001,224,3,224,1,223,224,223,4,223,99,0,0,0,677,0,0,0,0,0,0,0,0,0,0,0,1105,0,99999,1105,227,247,1105,1,99999,1005,227,99999,1005,0,256,1105,1,99999,1106,227,99999,1106,0,265,1105,1,99999,1006,0,99999,1006,227,274,1105,1,99999,1105,1,280,1105,1,99999,1,225,225,225,1101,294,0,0,105,1,0,1105,1,99999,1106,0,300,1105,1,99999,1,225,225,225,1101,314,0,0,106,0,0,1105,1,99999,1108,226,226,224,102,2,223,223,1005,224,329,101,1,223,223,107,226,226,224,1002,223,2,223,1005,224,344,1001,223,1,223,107,677,226,224,102,2,223,223,1005,224,359,101,1,223,223,7,677,226,224,102,2,223,223,1005,224,374,101,1,223,223,108,226,226,224,102,2,223,223,1006,224,389,101,1,223,223,1007,677,677,224,102,2,223,223,1005,224,404,101,1,223,223,7,226,677,224,102,2,223,223,1006,224,419,101,1,223,223,1107,226,677,224,1002,223,2,223,1005,224,434,1001,223,1,223,1108,226,677,224,102,2,223,223,1005,224,449,101,1,223,223,108,226,677,224,102,2,223,223,1005,224,464,1001,223,1,223,8,226,677,224,1002,223,2,223,1005,224,479,1001,223,1,223,1007,226,226,224,102,2,223,223,1006,224,494,101,1,223,223,1008,226,677,224,102,2,223,223,1006,224,509,101,1,223,223,1107,677,226,224,1002,223,2,223,1006,224,524,1001,223,1,223,108,677,677,224,1002,223,2,223,1005,224,539,1001,223,1,223,1107,226,226,224,1002,223,2,223,1006,224,554,1001,223,1,223,7,226,226,224,1002,223,2,223,1006,224,569,1001,223,1,223,8,677,226,224,102,2,223,223,1006,224,584,101,1,223,223,1008,677,677,224,102,2,223,223,1005,224,599,101,1,223,223,1007,226,677,224,1002,223,2,223,1006,224,614,1001,223,1,223,8,677,677,224,1002,223,2,223,1005,224,629,101,1,223,223,107,677,677,224,102,2,223,223,1005,224,644,101,1,223,223,1108,677,226,224,102,2,223,223,1005,224,659,101,1,223,223,1008,226,226,224,102,2,223,223,1006,224,674,1001,223,1,223,4,223,99,226 \ No newline at end of file diff --git a/src/main/resources/day6.txt b/src/main/resources/day6.txt new file mode 100644 index 00000000..28f6c892 --- /dev/null +++ b/src/main/resources/day6.txt @@ -0,0 +1,1294 @@ +MB5)V1S +VYJ)JRF +SLW)9YR +CPL)8KQ +Q5P)H7W +TJT)139 +PYD)XMX +4S5)K2V +RWW)JTL +HNC)81N +64N)V96 +RRM)FXW +Y8R)1C1 +VL8)M6N +G7L)RQJ +5C3)SC4 +JZL)DGX +C7B)KSS +2X5)5YY +W91)5R1 +KP8)QYY +NCL)5WX +HN9)4LZ +4Z6)15F +LHJ)B7D +S3S)J8Z +ZCW)KC1 +3TJ)2RP +J9F)SXH +SHX)WH9 +M4M)6NK +23F)Q7S +B7Y)ZM5 +M7H)D8G +N8F)K1F +5PV)SXD +HGX)5BM +LH8)C2L +XFM)ZHM +H1L)XYG +4VH)W46 +2Q8)6V5 +G41)LNT +GNY)Y8R +95L)MJC +FPR)X8M +MS4)YL4 +B8B)YL6 +6N4)SWY +B65)X7B +N15)C89 +LX4)TBZ +3W2)JRH +MVN)34C +XMX)DW8 +221)5CM +QPP)14R +SRB)7SK +3P9)MKR +DGX)6FT +GQG)T3J +JS4)XTJ +9MQ)FKR +B29)PWB +XHC)NX1 +55D)YCV +CV2)3FH +QN1)MFX +P2B)B51 +Z4D)Z2S +3MZ)GYC +LCQ)FF9 +VPZ)CV2 +Z4D)K9P +9F2)CV6 +NJS)HRR +W7Z)6CL +7NL)M9M +LJG)426 +6LP)24X +YQ7)CXX +4RB)BKC +KNW)2X5 +KCY)4D2 +2GC)GV9 +YWN)DWL +JML)131 +JHR)3G4 +KBM)BMX +GWB)S1P +LMW)2LL +DS7)8X3 +8KT)ZCW +MHT)9XZ +MV8)B7Y +VPB)KT8 +6RQ)87P +RP6)7QR +KQP)PXT +GBG)LCQ +CLY)RVF +64S)VP8 +FR9)K5X +K37)QJK +9ZB)MS1 +V6C)CXT +SC2)VJS +B45)9KK +ZH9)VWY +R17)XLS +N5Z)KWV +QWH)HY7 +2LL)79J +1DF)RT5 +MGH)XD4 +VZ3)9YW +413)17F +YL4)15X +ZJB)SHX +HGF)VN7 +4TW)TGX +3N4)SDF +KLJ)2FR +J5R)JZL +B59)WW6 +KRX)JGM +N75)78C +T4B)H2H +2VB)JG3 +7MG)4N2 +C7M)2BK +MKR)LBF +KFX)6KG +48T)844 +H1W)9XX +TGX)PN7 +GGK)22B +M8N)GNY +L6R)WVW +VRY)B15 +9YR)6RQ +QQ6)1KB +R22)STY +KC1)6RW +Q5Z)849 +XWK)VFW +GFD)C8Z +L5D)J2Y +74R)3TJ +D94)3P9 +JRH)HKV +3DZ)CFH +WKN)44S +JJC)9MQ +VKT)VBW +KT8)M7P +NH8)FDG +F7N)7MG +6RQ)RQM +V4T)ZN8 +25C)2L3 +WJW)DG9 +N5X)SRB +QZK)GLJ +WG4)K56 +844)J3V +HGX)KMR +87P)HKX +MK1)WTY +PC3)4TR +LG8)B29 +SDR)FWN +9ZM)SVT +3K3)XJ6 +WV1)G41 +NKV)36R +WFG)4M1 +WVW)1TQ +NQD)WF1 +B9Q)3YV +CTP)VZB +72S)NSM +755)X7S +MB2)JWB +GD8)HGX +3FH)Q1H +P8P)TD2 +8XK)KP8 +1B4)7LK +3WC)LXK +YZP)QZK +C72)1M6 +VZB)LZV +TC6)4RB +DH6)LJG +6XL)SKB +G52)3MZ +THK)F8F +S1P)NJK +QPG)5NF +9J8)W5V +6CJ)BY3 +F8F)L4S +L7X)4P2 +9NQ)RWW +V4V)BSC +YJW)G7F +3CK)GMH +VYR)LRM +XXP)JML +Z1S)3QH +3SH)YBF +WTY)QR4 +FZ2)BMB +JZ5)Z5Q +HDZ)2V9 +CTK)HRP +VWY)9HX +YNN)Z5F +N97)P1K +8NJ)JBK +VF7)JD2 +4GG)KC6 +8KS)YJ6 +DH2)HXL +HB3)1HK +K56)DFB +4H6)K6Y +M7P)3WC +DG9)88R +VRB)Y2X +NMZ)RRS +T3J)NQ6 +KYZ)KYX +TNN)48T +SG7)83G +JCK)QFN +5HH)1B4 +16R)C4S +CQJ)KCS +6PH)2W6 +89Q)7SB +NNK)L9J +77G)KTN +S2C)YOU +KFK)57L +LJ5)1BV +CCB)XQ8 +14R)T7Y +3W2)TYQ +KNC)KF6 +TW1)N5Z +ZCQ)8NJ +89G)5XD +Z15)SMZ +R5C)VMJ +CTJ)QWH +5NF)G52 +24X)SBP +Z4K)HN9 +6KG)BLM +66N)152 +CCX)TTM +P1X)3CM +Q7Q)KYZ +VFL)LX4 +SCT)KJ7 +5VK)R8D +MKH)RZ4 +H2H)WKN +6V5)9TW +W4G)QLS +LZV)D82 +RHL)CLG +QG8)LX2 +7S1)B7T +BY3)CMC +HBP)RD7 +9PR)FVP +72J)Y14 +PMM)8ZV +MZ8)MFN +3GD)8Y5 +ZJ3)WJW +5HZ)X2V +FYZ)G5R +WMR)WT8 +HNZ)6GW +9XX)33J +6QS)58X +11L)VWW +4LZ)MQT +MQT)PYS +BM6)YRP +658)LG8 +NGZ)1VD +HRK)ZVG +RZG)RPJ +83G)B7B +JG3)BLQ +2SG)MQ4 +B6C)4V6 +GLJ)ST5 +7MQ)P9X +3Y9)1ZB +K9P)D9Y +CJ8)LM6 +KCY)VYJ +GVY)18R +SZG)QCX +15F)S5F +35W)YST +9NQ)BYJ +VGX)8LH +WQM)2HT +QR4)ZLF +SWY)HWK +P9X)HY6 +LGH)ZJ4 +GYC)NGZ +81F)P4T +9BF)CTF +5Q1)1RC +6MR)3X6 +9HX)X83 +DBQ)C9D +1KP)9F2 +J8Z)JCK +Z5R)S2Z +B7B)KRX +ZM5)1YF +H2N)G5C +FSR)9ZM +3YV)74R +93T)MCN +5HK)MVS +V22)4Z6 +RSG)N15 +YDJ)F9N +K6Y)RSZ +3CM)169 +F2L)39W +CK4)842 +G6Q)S1W +D3H)55D +842)YCL +NXQ)L67 +KG8)NDS +LGD)2QJ +MFX)JLD +1KB)Z4D +RMW)CWB +LC2)QC1 +Q36)HTW +SG7)CJX +9BH)N34 +85F)YNF +LVD)9BH +7GL)KNC +SDF)C1Z +68R)WQC +BPW)N8F +3G4)71T +JFJ)CR2 +YFD)6CJ +Q8N)XMD +2CV)X3M +NPZ)89Q +SSK)9TP +QC1)VPZ +CML)9MV +4NC)GVY +T26)9NQ +8Y5)TDB +TTM)9PR +7ZY)3XT +MQL)PXS +LXK)2SG +FWP)LBD +CSY)C72 +FYQ)B2F +VYJ)SX8 +ZHV)6QS +KKB)1ZM +XRN)6XL +VN4)6XV +KWV)KW5 +SBP)971 +BMX)FXV +7K4)L65 +7XV)791 +DW8)RSK +9XZ)5CD +KG8)5C3 +LBD)WZ3 +7DC)T4B +1J7)XN9 +KF6)GJR +TPV)FR9 +B7T)89F +F94)KLB +3CV)49V +PN7)J89 +CLY)F2P +71Z)YZP +HRR)X9Z +1SF)QQ6 +MKR)5P3 +XLB)G3P +3XT)6FC +WSC)TR9 +1SF)8JZ +YMK)7T6 +YLW)Q9Y +LQC)FSX +971)9LV +PL3)MMV +78C)Q72 +NS8)W6M +RPW)5YW +91Q)QKC +B9B)7Q4 +Q3J)B2D +2ZP)YMK +MSS)RP6 +N6H)X4V +5P3)PHS +7LP)VXP +FJT)251 +N9G)N71 +21W)XRJ +FFT)Z22 +89F)VRY +45S)MZ8 +8J5)98X +4YF)HCN +3X6)WFG +R8D)THY +YNS)KT3 +2TZ)W6V +MFN)P6B +1HK)WSV +PXS)YQ7 +7LJ)PKH +QHG)4TW +G16)7QV +CXX)GL5 +KDN)NNT +TPS)JZ3 +X7B)RSG +6B1)JKD +CLG)ZGY +WQC)QTP +MYZ)3N4 +Y8R)KMW +YL6)45S +H25)459 +9TW)M3N +HDF)SLJ +LX2)5V6 +6SD)2ZC +KGQ)XWK +85H)7ZV +459)XGH +VWW)M4M +27C)CTP +RKV)FSR +Z5K)9L1 +2P1)6N1 +WZ3)D94 +TF1)CV3 +1YF)T3S +F87)N9D +H7Z)QPP +NDS)GP1 +GLN)R5Q +BHV)XRN +4T5)658 +QRF)HW8 +Q66)WWZ +2Q6)DWD +7T6)L9V +RVF)MXJ +RZ4)WQM +V9T)SR2 +M21)CTK +ZDW)QP4 +WF1)VRB +VXR)KFX +NHR)HDF +11P)TG5 +K2V)YGJ +NH3)V76 +VNQ)WY7 +G8P)8YY +W5C)RZG +W46)T73 +C89)N5X +2V9)5FQ +P5K)NCL +DNK)98T +FLX)MB5 +VXG)R17 +YQ7)Q36 +L67)K62 +74G)28S +X9H)L6R +JRH)CJ6 +LBJ)JHR +SX8)TF1 +RD7)3P3 +H4X)KPW +J33)BWF +R4G)VXR +XRJ)Y25 +Q7Q)GD8 +2SG)P1X +4CB)66N +VYW)FF1 +YB6)CL1 +4QG)TX6 +PKH)FYQ +JPG)LL9 +M8W)RGV +XF9)NNK +COM)Q1M +SMZ)DS7 +DNP)68R +1V4)4KY +GDN)NHR +8D1)HCL +KC6)HGF +CPS)VFL +33K)XQZ +Y14)RJ6 +H3F)77G +NMG)F7N +FWN)3GD +36R)MZ3 +MG8)VGX +6CL)352 +JM4)FRB +43X)RNH +TBW)F8R +JCZ)V22 +11Q)W7Z +N1L)RVD +Q6V)DNP +BWF)Y9G +H8D)D13 +F8R)4QR +J1X)8X4 +XFJ)N35 +QTP)869 +G3P)11Q +K9L)QYX +KN6)XHC +MWF)G6Q +KTN)SYM +XGH)8MN +QPP)W52 +G2Y)FBZ +WBX)ZQ4 +4F7)7XV +152)KGQ +CJX)L5D +JZ3)4ZT +CCB)N9G +HK7)K4Q +JGH)MGH +VN7)PH4 +M9Z)S9V +SK8)PYD +3V9)G45 +ZN8)4QG +2Q6)HLM +D13)LYH +ZQ4)D6G +SVT)SDR +PFK)QZ4 +CXT)X31 +44S)5GB +1RC)PKD +LWT)G7L +RX1)VRQ +P31)WYC +47S)NMG +C1Z)YY5 +HWK)GGK +JC5)1GW +HVX)395 +W6M)VF7 +JTL)4GD +G5C)7BN +PQL)GMS +NXQ)45D +S5S)HNZ +C12)K2D +7P9)282 +QF5)3W2 +WH4)9VJ +YNF)M8W +5V6)DX7 +XQZ)7D2 +XTJ)HM5 +HTR)9H5 +HYN)71Z +7Q4)TF3 +WH9)GF2 +1CG)Q5Z +5GB)S3S +WFF)DJT +N4C)5BJ +32D)XB5 +KLB)SC2 +15X)1C3 +GDT)W3X +1GW)CKZ +GGJ)4W8 +5BJ)H7Z +PPT)7S1 +FY4)SCM +395)3K3 +HFT)K98 +2RP)LZ4 +49V)4LH +F2T)GCL +DJR)VTW +QW3)M8N +LYH)VYW +6N1)4YF +N34)VKT +1KB)YFD +3YB)ZB6 +RSZ)F2T +2FR)1V4 +MDJ)Z4K +K62)TW1 +J3V)NHJ +JML)GT8 +6RW)8CP +8ZV)9BF +XXP)NMZ +K4Q)T36 +L4S)22G +953)XFM +ZGY)HTR +RJ6)4H6 +HRP)TQD +NNT)5YP +L65)1H8 +KXB)8YB +T5D)P5K +LJY)VTL +SCS)HJ7 +35S)2RZ +NX1)THK +HY7)36Z +FXV)369 +RSK)4Z2 +2Y8)F9B +NNW)KG7 +WSV)78N +MMV)5GL +JLD)WSC +PZH)N7G +LL9)4Y4 +1BV)BG2 +XMD)NT6 +H9D)XF9 +MNV)W8J +SX8)V3N +P8Y)CW1 +T73)3F9 +D82)32Z +XPH)PLM +352)NL6 +Z94)D43 +NK7)7QT +N35)KHR +NM1)MG8 +8JZ)TJT +923)G3N +MVS)7DH +YMK)HVQ +JM4)74G +HJ7)RPW +9CY)C7M +V76)4GG +LNT)Y2J +8WD)YNN +41X)GKF +TD2)FZ2 +T6H)4TQ +NHB)NKV +TV3)RRM +VRM)LVD +QNZ)FJT +3KZ)P8P +XJ6)3Y9 +4D5)YSS +WB3)TV3 +1Y6)Q3J +98T)6WH +SLT)KQL +951)5N8 +9ZB)Z6X +KKD)M4B +YGJ)4F1 +KBV)PQL +G45)M7H +8CP)J9F +BLQ)2P1 +XS6)NXQ +BZ9)XQK +YLN)D1R +55T)XQB +N7H)RFF +FTM)93T +LJ5)MZ9 +3YB)BFP +X9Z)7K7 +W8J)9BC +43X)NM1 +G5R)JGH +7SK)HRK +3BL)SWS +N38)QL4 +HKV)64S +SDF)W33 +D94)HB3 +GWW)8DQ +3QH)WFF +SLJ)2Y4 +3TJ)NQT +1C3)KLJ +954)VL8 +LW2)Z6D +2F1)RQ5 +C1Z)XM7 +3CV)5HH +QCK)QHS +XKD)2XP +24J)221 +8KS)MF3 +5YY)DJQ +KBH)1W7 +XYG)XHV +XMW)BTK +B2D)5T2 +2W6)DH6 +W2R)CK4 +FY4)9RH +WF1)L7G +6GW)LBJ +QCX)H25 +XHV)3DZ +5Z7)N9H +RYD)H27 +QVD)ZJ3 +CM1)NHB +W8J)8KH +C5D)WV1 +CV3)25C +953)741 +9MV)ZCQ +WYC)SLW +6WH)387 +FXW)1G1 +Z1S)212 +MS1)FYZ +W33)F78 +NQT)72G +2XP)1MG +J9J)KBS +C1R)RHL +L7G)R4G +HWK)CCX +TNP)1SF +5R1)SLT +B51)VDS +FBK)LH2 +387)XXP +4NX)RDL +FF9)XW7 +D3P)5R5 +M3N)YWW +2Q8)9FM +8YY)1J7 +Z6X)3CV +9HX)FV8 +8MN)S2C +XD4)5HK +ST7)B59 +LR2)PF2 +23Y)FTM +7D2)F2H +9JG)TG9 +2QJ)H4J +HM5)CSY +DH5)55T +GFL)WBX +HGF)SK8 +PXT)SCT +K2D)7J8 +78K)MDJ +2XT)MP2 +4QR)549 +DFB)DRV +6NK)Q7Q +5BM)2Y8 +9XZ)DT2 +M25)MV8 +2BK)3V9 +28S)W2R +RPJ)X37 +QLS)9XF +X83)XFJ +8X4)ZHV +KMR)KDN +2K2)4T5 +LRM)MWF +JGM)4D5 +4LH)PZH +L4X)H2N +HHH)C12 +R4G)GWB +ZVP)F22 +YBF)H37 +RSY)PD7 +K3W)VXG +K9G)HN8 +1C1)QCK +YTK)JZ5 +KQL)NLZ +PLM)H7X +PYS)GDT +TY2)VRM +FF9)SZY +SXH)SZG +2HT)P19 +JTQ)B5F +B9B)F2L +5CM)CPS +L5D)GQG +K1F)QNZ +7QT)LJY +9KK)1DF +XN9)KBV +9VJ)SG7 +M4B)ZDW +6XV)MQL +1VL)Z94 +KSS)H8D +STY)JFJ +PXR)K3W +X3M)35W +RNH)FWP +2RZ)LW4 +HVQ)QG8 +8VS)QZS +M8T)4YM +GJR)SBJ +N9D)WH3 +4TQ)VZ3 +GG6)6MY +4TR)M21 +XLS)6QC +MZ3)YWS +ZRG)HK7 +V1S)ZRG +CR2)V8R +81N)PJX +VXP)LMZ +849)LTC +DWD)LQC +1H8)3FT +D2T)KG8 +BYJ)5Q1 +3H6)5X1 +8KQ)CHK +T7Y)J1X +4GD)KQP +XM7)QF5 +9RH)JZR +GKF)DBQ +THY)JHZ +5XD)2GC +MV8)HBP +CW1)W91 +411)923 +RRS)8XK +C66)TNP +BMX)J5R +FKR)5Z7 +MRV)PFK +9BC)59G +GVY)GDN +HH8)DRK +V96)6B1 +SKB)KFK +DJQ)23Y +PF2)2HD +2Y4)D3F +K86)K1P +YRP)GBG +V8R)W4G +F9N)GP8 +XQB)BPW +CSY)C66 +NHJ)D2T +GGF)MK1 +4NX)V6C +JYC)YNS +GMS)KNG +XW7)MRV +RFS)Q2C +7NL)WH4 +TBZ)FLX +RQ5)ZJB +FPX)WL3 +BMB)K86 +N7G)WC7 +T3S)NQD +KG7)GLN +741)CPL +S1W)G8P +W5V)ZJJ +JRF)X8V +TX6)PK9 +89Q)DFS +W6V)9FW +D8G)NVJ +VBW)3SH +VTW)RYD +5CM)QVD +9TP)LC2 +NCD)4VH +HLM)11L +6MY)S68 +S2Z)V3R +BFP)954 +Z5R)YB6 +SBP)2Q8 +JWQ)TQK +F2T)VPB +SZY)PXR +ML1)ZH9 +LM6)LH8 +CV6)69H +77Y)G2Y +22B)JYC +4Z2)1G9 +5N8)755 +GCL)Q5P +4ZT)M8T +Z6H)RKV +ML1)M9B +4YM)LFL +9JG)LMW +3FT)2XT +RQM)B6C +DRV)1Y6 +B1P)3YB +PGR)YDJ +9L1)RWV +79J)41X +GF8)YTK +N15)4S7 +8MC)1VL +4F7)77Y +SYM)YHV +4P2)2PZ +426)2TZ +H7X)K37 +17F)71V +9G9)PKR +KC2)N38 +L4X)WB3 +1TQ)G6B +YSS)SCS +Q1M)WW8 +819)2CV +Q2C)B65 +169)7P9 +139)7DC +D43)LR2 +KJ7)HH8 +C4S)MHT +5G8)HDZ +QTK)J33 +F2H)YBQ +5YP)YWN +W52)1SL +32Z)CM1 +LZ4)2F1 +7SB)QPG +7K7)SSY +CW1)9DN +YCL)LW2 +CTF)N97 +FV8)8KS +KQP)R1M +6QC)P2B +LW4)64N +R17)FQN +71V)4CB +X31)8VS +5FQ)9ZB +7J8)D8T +WZ3)KKB +VDS)WLZ +WT8)J9J +BKC)PC3 +T4B)9G9 +NT6)ST7 +LH2)JCZ +QHS)RMW +9LV)PLL +16M)H1L +HCN)PMM +J69)8KT +35S)7JW +5C3)F6S +J89)LJ5 +FVP)LHJ +RT5)XS6 +LBF)QW3 +8YB)GGF +ZHM)5HZ +W3X)MGQ +KHR)G16 +HY6)DNW +CMC)VPJ +Q72)JMG +WW8)Z6H +Y25)72S +3MZ)53C +791)951 +KPW)S5S +NQ6)QRF +NCL)VYR +1VD)85F +QYX)413 +NJK)D3H +N74)MNV +MP2)F87 +4F1)FQH +JZR)WMR +DNW)TNN +YZP)NH3 +H27)FY4 +28S)6R8 +DRK)B9B +NTG)1FY +GL5)HVX +G3N)CML +CPS)PQN +R1M)TY2 +C8Z)MS4 +N71)ML1 +5NF)GF8 +SCM)CCB +BG2)9JG +ZVG)6SD +FBZ)BZ9 +L9V)7ZY +7DH)B8B +1JT)DNK +QL4)NS8 +7LK)35S +QKC)SAN +Q1H)DJR +4N2)C1R +SC4)R22 +413)WG4 +SXD)K9L +9CY)4S5 +58X)NCD +VTL)LGH +V96)P31 +KYH)CLY +LTC)MB2 +D9Y)JM4 +53C)F94 +PD7)7MQ +5GL)6XW +6FT)H4X +RQJ)TC6 +WH3)2VB +M6N)H66 +369)N74 +TF3)JC5 +FGL)NTG +P6B)1JT +MDJ)V9T +6CL)754 +V3N)2Q6 +5YW)KCY +VRY)24J +2HD)47S +WL3)3YH +1SL)CTJ +QZ4)697 +S68)KYH +KBS)FPR +DT2)H9D +CHK)Y3R +Y2X)L7X +9VJ)3CK +BLM)CQJ +PLL)81F +RFF)5VK +V3R)LWT +FQN)M25 +9H5)KHG +KTN)4NX +QZS)23F +H7W)MKH +PKD)33K +F2P)MVN +G6B)GZ6 +8LH)PGR +NLZ)78K +GFD)XPH +LFL)N7H +D8T)7Z1 +X4V)R2D +D1R)Q6V +JV2)DH5 +WLZ)411 +352)C7B +T36)QWS +5R5)Q66 +HKX)KC2 +QL9)32D +M5Q)T6H +88R)M5Q +MF3)B1P +9YW)BM6 +Y9G)VNQ +M9B)7GL +57L)YLN +HTW)PL3 +1ZM)JWQ +1W7)FFT +SR2)YJW +BTK)XKD +P19)RSY +BSC)7LJ +212)NR2 +LX4)K39 +HXL)Z5R +FSX)W3T +HN8)FGL +KFK)27C +WN2)M9Z +F9B)GFL +WY7)Z15 +GQL)21W +BZ9)KNW +MFS)9CY +GV9)NQN +V8T)91Q +D7X)GFD +4KY)Q8N +9NX)MFS +YB6)NK7 +Q9Y)1KP +KCS)B45 +M4B)GG6 +ZVP)2K2 +CWB)N3S +HVX)JTQ +59G)TTC +YMV)B9Q +16M)XLB +PJX)VN4 +69H)11P +LMK)X9H +F6S)J69 +R2D)5SJ +X37)17P +3CL)YMV +ST5)N4C +2L3)NH8 +3F9)HNC +C2L)HFT +7QP)ZRM +C12)KN6 +1V9)PPT +XB5)8J5 +DJT)3BL +HKV)16M +YJ6)KBM +TX6)R5C +B15)LMK +549)JPG +K2V)NJS +FRB)1CG +MJC)4NC +TTC)H1W +KT3)CJ8 +NR2)85H +131)3KZ +X8V)953 +21W)W5C +3YH)8MC +VFW)7K4 +D79)KXB +G7F)JJC +4M1)7NL +S9V)NPZ +VP8)K9G +KNG)HHH +D3F)T5D +SWS)3CL +TYQ)9NX +78N)N1L +RDL)819 +X2V)L4X +8Y2)GQL +VRQ)FBK +1M6)QN1 +MXJ)7LP +1MG)GTF +YY5)H3F +S5F)BHV +PHS)95L +6XW)72J +DFS)D7X +YWS)SSK +B1P)DH2 +K98)FPX +Z5F)6N4 +9DN)78H +W3T)JS4 +7Z1)5G8 +49V)9J8 +Z6D)GGJ +V9T)MYZ +SC4)YLW +NQN)WN2 +MFN)TBW +KRX)LGD +9FW)V8T +8X3)V4T +4S7)XMW +Y2J)5PV +QYY)T26 +GMH)JV2 +H98)Q2Y +MZ9)2ZP +ZRM)KBH +251)Z5K +KHG)HYN +5WX)P8Y +71T)N75 +H37)6PH +HCL)D3P +M25)16R +K39)QL9 +WWZ)8Y2 +PK9)N6H +LMZ)ZVP +Z5Q)H98 +JKD)WK2 +JHZ)43X +PQN)NNW +J2Y)3H6 +YWW)GWW +NL6)KKD +XQ8)TPS +RWV)8D1 +TDB)RX1 +2PZ)6MR +NSM)QTK +GP1)TPV +ZB6)1V9 +QHG)4F7 +18R)D79 +ZJJ)Z1S +45D)7QP +7QV)X42 +M9M)MSS +TQK)V4V +Q7S)23K +TG9)C5D +VMJ)89G +7QR)SPB +RGV)QHG +3P3)RFS +GT8)6LP +P1K)8WD \ No newline at end of file diff --git a/src/main/resources/day7.txt b/src/main/resources/day7.txt new file mode 100644 index 00000000..1ecb0de6 --- /dev/null +++ b/src/main/resources/day7.txt @@ -0,0 +1 @@ +3,8,1001,8,10,8,105,1,0,0,21,30,47,60,81,102,183,264,345,426,99999,3,9,1002,9,5,9,4,9,99,3,9,1002,9,5,9,1001,9,4,9,1002,9,4,9,4,9,99,3,9,101,2,9,9,1002,9,4,9,4,9,99,3,9,1001,9,3,9,1002,9,2,9,101,5,9,9,1002,9,2,9,4,9,99,3,9,102,4,9,9,101,4,9,9,1002,9,3,9,101,2,9,9,4,9,99,3,9,101,1,9,9,4,9,3,9,1002,9,2,9,4,9,3,9,1002,9,2,9,4,9,3,9,101,2,9,9,4,9,3,9,1002,9,2,9,4,9,3,9,101,1,9,9,4,9,3,9,1001,9,1,9,4,9,3,9,102,2,9,9,4,9,3,9,1002,9,2,9,4,9,3,9,1001,9,1,9,4,9,99,3,9,1001,9,2,9,4,9,3,9,1002,9,2,9,4,9,3,9,101,2,9,9,4,9,3,9,1002,9,2,9,4,9,3,9,1001,9,2,9,4,9,3,9,1002,9,2,9,4,9,3,9,1002,9,2,9,4,9,3,9,101,1,9,9,4,9,3,9,1002,9,2,9,4,9,3,9,1002,9,2,9,4,9,99,3,9,101,2,9,9,4,9,3,9,101,1,9,9,4,9,3,9,1001,9,2,9,4,9,3,9,1002,9,2,9,4,9,3,9,102,2,9,9,4,9,3,9,1001,9,2,9,4,9,3,9,102,2,9,9,4,9,3,9,1002,9,2,9,4,9,3,9,101,1,9,9,4,9,3,9,1001,9,2,9,4,9,99,3,9,102,2,9,9,4,9,3,9,1002,9,2,9,4,9,3,9,101,2,9,9,4,9,3,9,102,2,9,9,4,9,3,9,1001,9,1,9,4,9,3,9,1001,9,2,9,4,9,3,9,101,1,9,9,4,9,3,9,102,2,9,9,4,9,3,9,101,2,9,9,4,9,3,9,1002,9,2,9,4,9,99,3,9,1002,9,2,9,4,9,3,9,102,2,9,9,4,9,3,9,1001,9,1,9,4,9,3,9,102,2,9,9,4,9,3,9,102,2,9,9,4,9,3,9,1001,9,2,9,4,9,3,9,101,1,9,9,4,9,3,9,1001,9,2,9,4,9,3,9,1001,9,1,9,4,9,3,9,101,1,9,9,4,9,99 \ No newline at end of file diff --git a/src/main/resources/day8.txt b/src/main/resources/day8.txt new file mode 100644 index 00000000..1838f93f --- /dev/null +++ b/src/main/resources/day8.txt @@ -0,0 +1 @@ +222122222222222221222222020220220222201212222222121120222212202222222222222222202222222222222222210222202222222201222222122022222022022222222222222212222122222222222221222222022222220222211202222222020221222222222222222222222222222222222222222222210222222222222211222222122022222022022222222222222222222022222222222222222222021222221222222202222122121122222202222222222222222222202222222222222222220222212222222202222222222222222222222222222222222212212022222222222221222222222221220222200202222222120220222212222222222222222222212222222222222222200222202222222210222222022022222122122222222222222222222022222222222221222222022221222222220212222122021022222212222222222222222222212222222222222222202222202222222200222222022122222222022222222222222212212022222222222221222222022222221222212222222222220020222222102222222222222222202222222222222222220222212222222212222222122122222122022222222222222222212222222222222222222222120220222222220222222222221122222222022222222222222222222222222222222222212222222222222221222212222122222122222222222222222212212022222222222220222222121220222222202202222022220221222212202222222222222222212222222222222222202222222222222220220202222022222022122222222222222212222122122222222221222222121221222222201202222022121120222212222222222222222222222222220222222222221222212222222210222212022122222022222222222222222212222022122222222220222222022222220222202222222022122022222212112122222222222222202222221222222222220222222222222201221222022022222022222222222222222212211022222222222220222222022220221222222212222222122010222212102122222222222222212222220222222222211222222222222222222222222022222122222222222222222202210122022222222221222222120222222222211212222022121200222222022222222222222222222222220222212222202222212222222221221212122222222022022222222222222212202122122222222220222222020222220222202222222122222121222202112122222222222222222222220222202222222222202222222211221222222102222022122222222222222222202222022222222221222222222220222222202202222222021120222222112122222222222222212222221222202222202222212222222212222202122012222022122222222222222202222122022222212222222222221220220222221212222222020011222222122122222222222222222222220222212222211222202222222211222212021202222222122222222222222202202222022222212221222222021222221222220202222022120012222212012122222222222222202222221222202222222222202222222221222212120002222022222222222222222202222222022222202222222222020221221222212222222122022000222222102122222222222222222222222222202222210222222222222201220222021122222222122222222222222222210222022222212222222222122220222222220012222222122201222202002022222222222222202222222222222222201222202222222211220202120122222222222222222222222212202122022222212220222222220222221222212112222222022021222202202022202222222222012222222222222222210222212222222222222012020022222022122222222222222202222121222222222221222222022220220222210112222122221122222202222222202222222222212222221222222222210222212222222212220202120222222222222222222222222222210120022222202222222222022220222222220002222202022211222222012122202222222222002222221222202222221222212222222221221212122122222022022222222222222222221222222222212220022222121220222222221102222112121101222202202222212222222222112222020212222122220222202222222200220022022112222222022222222222222222222120122222202220222222021221220222202222222022122121222212122222212222212222102222220202202222211222222222222211222022020112222222222222222222222212201121022222202220022222222220220222210122222122122020222222112122212222202222202222220222222022200222202222222210220102121022222022222222222222222222212021222222202222222222022221222222222122222212220201222212202222212222222202012222221222222122200222202222222211222122122212222022022222202222222202202121222222202222021222120220221222201002222212120221222202122222212222212202112222221222222002212222212222222220222022220212222222022222222222222222211122122222202222222222121222220222221212222202221020222212112122202222222212112222122222202002211222212222222220221102121012222222122222202222222202222122122222212222222222122222220222211012222122022022222212102022202022202222202222122222222112210222222222222202222102122212222222022222212222222222212222022222220221021222120221220222221000222112121000222222202222222022222212102222222202222122212222222222222201220212221122222222122222222222222212201022022222220221122222221221220222221211222022222020222212222122212222222112202222120222202112211222202222222221222112020112222022022222202222222222211122022222221220220222221220220222222121222102222210222212002022212222222222212222121212212022222222202222222202221012020212222022222222212222222222212221022222212221220222221220221222222000222122020011222222202222222122212202002222221222222022102222212222222202220202021002222122122222212222222222220221122222202221220222221222222222222212222122121010222222102222212022222122022222120202202012110222222222222220221022122222222222122222202222222212200222222222202222020222221221222222202200222022121200222202112022212022212222222222021220202002111222222222222221220122121202222222222222202202222202212121122222222222120222221220200222220210222102121221222212212221222022212212222222221221202012112222222222222220220002021012222222022221222202222212202120122222200222221222221222221222210011222212021222222222212222202222222022022222021220202122022222202222222220220112221222222122122221222212222222222121022222200221221220020220201222222002222212122200222212122122202122022212112222221221202202212222212222222211222222220222222022122222002222222222201120222222220222220220120221200222211212222112221210222212212220212022012122022222220221212102001222202222222222220112020002222022222220102222222202212020022222201221020222122220222222211111022012220122222222012122202222202222222222122222212222002220202222222221221212021102222122022220002212222202210020122222202221120221121220202222221001022202220111222212112021212222222102112222022202202022020221222222222200220102220222222022022220122202222212222021022222210222120221021222210222222120222212120020222222212022202022112102122222020222212022222222202222222220220202222102202222022222002212222212211222122222200221220222220221221222222001022022021112222202102021212122122122222222220222212202201220202222222212220212021212212222020020022212222212201220222220212222221120010220202222201220222202122002222212112222202122112112212222121220222212002221002222222201222002221002222222220121022212222202211121222222212222221222001222202222210010222112021202222212102120202222222122002222120221222122020222122222222211222222222222210122221122022202222222212021122221202220120222000222221222212002022112022012222202222022222022212012002222122220212022122220112222222200220002022212202122220120022212222202221220222221201220021122121222220222211212122212222220222202022122222022102002222222121210222202022221112222222220221022020012210222221221222212222212220120022222211222221120022220212222210012222012122012222222202222222222202112222222021200212202200221202222222201222012222002211222221022112222222202202220222221220222021020021221211222221111222102020000222222202220202122002102022222221211122102120211002222222212222002120022222212222220022202222212202221222222210221120020201221212222221100222002022121222022202221222222002022002222121212212111211212122222222222222202122002200112220120202222222212211221222222021221222120210221222222220022222022022012222122112020212022022122012222221210102202021200202222222200221202121202210122222122012202222202201122222221120220022222112222221222201211122002121020222012222021202222020212112222122200122121102211002222222200220212220202220012221122012212222202202220122210000222220022010221211222212022022112022212222102002122222222111212202222220222022211202211112202222010221122222202222102122020102212222222221121222201021221221022210221221222201022022012021220222112022121202022222012202222120200002002110200222200222000221022101022222002021021222202222222200220222200101220122122020222201222210112022102021112222002202022202222022212122222122222222020220221102220222020222222212012201012020222222012220222101222122202100222120021120222202222221122022202122212222012002220212022120122002222220200122002201220002200222020220012011022220122120022012012221212121222122221000221021020221221220222211201122012020121222212122121212022000002122222220221102222012221122210222211212212122022210002221121122012221222022122122220012222120021002222201222200222022102022222222022022120212122121122022222020220202011001221222210222200201002122222200122122120102202220202212020222200010221021021120220222222222121222002122201222022002220202022210012002222022210212220020200022211222121221102120212212002221122022202210222110121122210101220020222002220200222212111122112221120222002122221202022120222002222122220212120101201202201222222221102200212212212121121022212210202002221022221022220120020100222201222201121122002121021222022012020222022201022122222122202102001022200022220222121222012021122212212221221222222212222010220122201012221022012002220212222222111222212122112222012202222212122010122022222121210022112010202202201222122210202112012200012120020201122220212020122022221012220222111020220221222201222022002121022222202102220222122212002202222020202112121222200122221222101211202022111210122122220020202210212021122222222012222120221201222220222211222122012220121222202012020212122202122202222120210212210202220122210222020220222101212200002220120220112211202000122022201100222022201111221202222202022122112122001222002202022222122221102102222021211102220220221002200222112221022220200200022222022212122212212111222022221121221021201202220221222202211122122122222222022212021212022021012202222021211012110221201212220222121211212022012220022021121011012202222211020122210122221122110120222200222212100022102021111022222112122212222021102022222022221222121101222212210202210221012220112201222122022121112202012210221222202221221020022100221210222220121222102020201122102212020222122121212122222120201122110121222212222202112222212220111221002120220101212220122012022120200021222120021010221212222220100122112121221222102202120212122012122102220222202202000120211222222202102220122002122222202020221011212222212010220220222122221022211010220220222220010122002020021122002112122212022112122012221122201002222022212012222212110212022201000211112222021121012222222210121020202200220121210100220221222220001122022020222222212212222212122021002102221222211122000202212112210222001201102001102210112120221102112201012102221121201202221021110012222210222222012022112221200022022022122202212000002012222121212012220010200022201212101211202222122201102122020211102220212010221020222102221020022200220201222210211022202022210122022002221222012010212122211221221102201022211102220212110222022110121200222122122002212210122211220220221222221222201220221120222210011222022121111222102022222222012000022002200220222102012110221012212202201211122220021200012121122202122211022221121021212100220120012002222120222202210022022220020122012222222202212100022222211020210102220202211222211202220221122001011211222122122211212221112202122120200011220120212201221110222220202022012021012222012002220212022220222002221120220202110000211012202212020221122211110221222220220100112212222221021222220011222021001120220211222200121022222120101022202202020222002212222102222022212122011220202022220202020211022022220212222220222111112201212010120221210212221122120212221101222202212122212222120222102122122222202101022112202220212202220000200122210222012211122022100200022220222001002220202122121220201021221000002101221122222200112122102122012022112212121222112210212012210022221212002102220212211222100200012001202201012122020020012211022200121122222102220000002210221211222221122222022020201122022102222222102200002022212222000012211121201122211212121222012100121212122222020122102211002022021222210012222221001020220111222222011222022022210122112202022202222201012022212120221202202222221012211202021210022221011221022122020201212201012220122022222112221102011211222102222210010222012122110122222212121212222221012122202222201222202120220022210222110221212002122220222220120221102201202111021222200122222212010012220210222212021022112022011022012202221202112021002122210121002202100101200122210212021202112122000220222221020202012201002201021221201111222101021011222222222210020022002020200122002112122222222202102002210220102122211121201102212212012212202222201222022020122020212211212210221021221011222100002221221012222210100022202121010022222112021202102011102012201220211022022000201122220222020222012022021202102020122010012222102001022022202011220012112201221201222220101022102021210022212122020212122000102102222220202222100200222122201202110220012001122222012020220102112220212100121121202102220221201122221010222210002022202221000122212012222202102201212022210010111002211211211202212202200202222200001212112121222002122221012002121022210222221222120020222212222212121022112222011022222202220222102020012122220020012022111112211102222212202220012020212201022222122002002222002222222122012102221021121121221221222210122222212220110022212222222222202220022212220122120112002121220212212222101200202112000220112001120020112220222211122020120210222120202210220222222210120022122120021022222012220202102200112212220002211002201102212212212222121220212122221212002021122101222202222022021220122222222210101000222202222201100022122222101222102222200202022212022012221201202112211212210022202222011220202221010200112001221222122212012122120120022021221222111222221211222221121222202122121122122012002222002222210112210102002202202011210202210222011222122212222200012211020200202220002111002121001020222022222121222020222222000022222021200122012112210212012001000122200000201022102010200112111222220211112120010201102020222221122212012121121022022120222200101102022210222200111022012120111022012022100222212012022002201221111102200102220212101202220221122111010201112212121020112201222201112020120201221001121120220220222212012222222120021022202102112012102012212222212022120202220000202120211222222222122202022211112201020100202222102020120222101120221101110100221221222210000122120121110222112122002122222101121222201000222122201122202202220222020202012222000220212100020021122201122022212222110022221211101210021021222220200022201022001112022122112222002202121122200111210122021221210210102212211221212222120212202200021212122211202202200121101001221021021221021022222202122022210122012212122212012202102022221222111020111112120221210210020222110200202112111202002020121210012210012102002020000221222200002210020220202221110122121020222102002102100022222121101222102120001112101222202001022222101221102021112200102200222022002220102210111121221220221202020011222102222210020222021022211002202002120112202120111222121002002022112112200200221212000201122110100200212020122012202201122122000212211222011122220200201100111000022010102201221120010110121011120100100011202001101011012210020022201001212022210200111020120211112200111000100 \ No newline at end of file diff --git a/src/main/resources/day9.txt b/src/main/resources/day9.txt new file mode 100644 index 00000000..e3d2a86a --- /dev/null +++ b/src/main/resources/day9.txt @@ -0,0 +1 @@ +1102,34463338,34463338,63,1007,63,34463338,63,1005,63,53,1101,3,0,1000,109,988,209,12,9,1000,209,6,209,3,203,0,1008,1000,1,63,1005,63,65,1008,1000,2,63,1005,63,904,1008,1000,0,63,1005,63,58,4,25,104,0,99,4,0,104,0,99,4,17,104,0,99,0,0,1102,1,550,1027,1101,0,0,1020,1101,30,0,1004,1101,0,22,1014,1102,1,36,1009,1101,37,0,1007,1102,25,1,1010,1102,1,33,1012,1102,282,1,1029,1102,1,488,1025,1101,0,31,1019,1101,0,21,1008,1101,0,35,1015,1101,664,0,1023,1102,26,1,1001,1101,28,0,1016,1102,29,1,1005,1102,1,24,1002,1101,20,0,1018,1101,27,0,1013,1101,38,0,1017,1102,1,1,1021,1102,1,557,1026,1102,1,39,1000,1101,23,0,1006,1101,493,0,1024,1102,1,291,1028,1101,671,0,1022,1101,0,34,1003,1101,0,32,1011,109,10,21108,40,40,8,1005,1018,199,4,187,1105,1,203,1001,64,1,64,1002,64,2,64,109,-14,2108,30,8,63,1005,63,225,4,209,1001,64,1,64,1105,1,225,1002,64,2,64,109,3,2102,1,4,63,1008,63,34,63,1005,63,251,4,231,1001,64,1,64,1106,0,251,1002,64,2,64,109,12,2107,22,-5,63,1005,63,269,4,257,1105,1,273,1001,64,1,64,1002,64,2,64,109,20,2106,0,-3,4,279,1001,64,1,64,1106,0,291,1002,64,2,64,109,-16,21108,41,40,-3,1005,1012,311,1001,64,1,64,1105,1,313,4,297,1002,64,2,64,109,-13,2101,0,2,63,1008,63,30,63,1005,63,335,4,319,1105,1,339,1001,64,1,64,1002,64,2,64,109,-3,2102,1,4,63,1008,63,35,63,1005,63,359,1106,0,365,4,345,1001,64,1,64,1002,64,2,64,109,15,1205,6,377,1105,1,383,4,371,1001,64,1,64,1002,64,2,64,109,5,21102,42,1,-2,1008,1017,39,63,1005,63,403,1106,0,409,4,389,1001,64,1,64,1002,64,2,64,109,-17,21107,43,44,10,1005,1012,431,4,415,1001,64,1,64,1106,0,431,1002,64,2,64,109,14,21107,44,43,-4,1005,1012,451,1001,64,1,64,1106,0,453,4,437,1002,64,2,64,109,1,21102,45,1,-3,1008,1014,45,63,1005,63,479,4,459,1001,64,1,64,1105,1,479,1002,64,2,64,109,7,2105,1,0,4,485,1106,0,497,1001,64,1,64,1002,64,2,64,109,5,1206,-8,513,1001,64,1,64,1106,0,515,4,503,1002,64,2,64,109,-33,2101,0,7,63,1008,63,32,63,1005,63,535,1106,0,541,4,521,1001,64,1,64,1002,64,2,64,109,23,2106,0,8,1001,64,1,64,1106,0,559,4,547,1002,64,2,64,109,-1,21101,46,0,-5,1008,1013,46,63,1005,63,585,4,565,1001,64,1,64,1105,1,585,1002,64,2,64,109,-4,21101,47,0,2,1008,1016,44,63,1005,63,605,1105,1,611,4,591,1001,64,1,64,1002,64,2,64,109,-18,1207,4,38,63,1005,63,627,1106,0,633,4,617,1001,64,1,64,1002,64,2,64,109,5,2107,22,7,63,1005,63,649,1106,0,655,4,639,1001,64,1,64,1002,64,2,64,109,12,2105,1,10,1001,64,1,64,1106,0,673,4,661,1002,64,2,64,109,-10,1208,6,33,63,1005,63,693,1001,64,1,64,1106,0,695,4,679,1002,64,2,64,109,-7,2108,35,7,63,1005,63,715,1001,64,1,64,1106,0,717,4,701,1002,64,2,64,109,6,1208,5,37,63,1005,63,735,4,723,1106,0,739,1001,64,1,64,1002,64,2,64,109,-4,1202,5,1,63,1008,63,34,63,1005,63,765,4,745,1001,64,1,64,1105,1,765,1002,64,2,64,109,29,1206,-7,783,4,771,1001,64,1,64,1105,1,783,1002,64,2,64,109,-28,1201,6,0,63,1008,63,29,63,1005,63,809,4,789,1001,64,1,64,1106,0,809,1002,64,2,64,109,5,1202,2,1,63,1008,63,20,63,1005,63,829,1106,0,835,4,815,1001,64,1,64,1002,64,2,64,109,-1,1201,6,0,63,1008,63,35,63,1005,63,859,1001,64,1,64,1105,1,861,4,841,1002,64,2,64,109,2,1207,-3,25,63,1005,63,879,4,867,1105,1,883,1001,64,1,64,1002,64,2,64,109,13,1205,3,901,4,889,1001,64,1,64,1106,0,901,4,64,99,21101,0,27,1,21101,915,0,0,1106,0,922,21201,1,22987,1,204,1,99,109,3,1207,-2,3,63,1005,63,964,21201,-2,-1,1,21101,0,942,0,1106,0,922,22101,0,1,-1,21201,-2,-3,1,21101,0,957,0,1106,0,922,22201,1,-1,-2,1105,1,968,21202,-2,1,-2,109,-3,2105,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 \ No newline at end of file diff --git a/src/test/java/com/sbaars/adventofcode2019/IntcodeTest.java b/src/test/java/com/sbaars/adventofcode2019/IntcodeTest.java new file mode 100644 index 00000000..760ce827 --- /dev/null +++ b/src/test/java/com/sbaars/adventofcode2019/IntcodeTest.java @@ -0,0 +1,45 @@ +package com.sbaars.adventofcode2019; + +import java.io.IOException; + +import com.sbaars.adventofcode2019.days.Day11; +import com.sbaars.adventofcode2019.days.Day13; +import com.sbaars.adventofcode2019.days.Day2; +import com.sbaars.adventofcode2019.days.Day5; +import com.sbaars.adventofcode2019.days.Day7; +import com.sbaars.adventofcode2019.days.Day9; + +import junit.framework.Assert; +import junit.framework.TestCase; + +public class IntcodeTest extends TestCase { + public void testDay2() throws IOException { + Assert.assertEquals(8017076L, new Day2().part1()); + Assert.assertEquals(3146, new Day2().part2()); + } + + public void testDay5() throws IOException { + Assert.assertEquals(11049715L, new Day5().part1()); + Assert.assertEquals(2140710L, new Day5().part2()); + } + + public void testDay7() throws IOException { + Assert.assertEquals(116680L, new Day7().part1()); + Assert.assertEquals(89603079L, new Day7().part2()); + } + + public void testDay9() throws IOException { + Assert.assertEquals(2518058886L, new Day9().part1()); + Assert.assertEquals(44292L, new Day9().part2()); + } + + public void testDay11() throws IOException { + Assert.assertEquals(2172, new Day11().part1()); + Assert.assertEquals("JELEFGHP", new Day11().part2().toString()); + } + + public void testDay13() throws IOException { + Assert.assertEquals(320, new Day13().part1()); + Assert.assertEquals(15156, new Day13().part2()); + } +} pFad - Phonifier reborn

Pfad - The Proxy pFad of © 2024 Garber Painting. All rights reserved.

Note: This service is not intended for secure transactions such as banking, social media, email, or purchasing. Use at your own risk. We assume no liability whatsoever for broken pages.

Alternative Proxies:

Alternative Proxy

pFad Proxy

pFad v3 Proxy

pFad v4 Proxy