java: add solutions for year 2016, day 14

java/src/benchmark/java/com/github/saser/adventofcode/year2016/day14/BUILD.bazel

@@ -0,0 +1,19 @@
+java_library(
+    name = "benchmark_library",
+    srcs = glob(["*.java"]),
+    deps = [
+        "@maven//:org_openjdk_jmh_jmh_core",
+        "//java/src/main/java/com/github/saser/adventofcode/year2016/day14:day14",
+    ],
+    plugins = ["//java/src/benchmark:annotation_processor"],
+    data = ["//inputs:2016/14"],
+)
+
+java_binary(
+    name = "benchmark",
+    main_class = "org.openjdk.jmh.Main",
+    runtime_deps = [
+        "@maven//:org_openjdk_jmh_jmh_core",
+        ":benchmark_library",
+    ],
+)

java/src/benchmark/java/com/github/saser/adventofcode/year2016/day14/Day14Benchmark.java

@@ -0,0 +1,49 @@
+package com.github.saser.adventofcode.year2016.day14;
+
+import java.io.IOException;
+import java.io.Reader;
+import java.io.StringReader;
+import java.nio.file.Files;
+import java.nio.file.FileSystems;
+import java.util.concurrent.TimeUnit;
+
+import org.openjdk.jmh.annotations.Benchmark;
+import org.openjdk.jmh.annotations.BenchmarkMode;
+import org.openjdk.jmh.annotations.Fork;
+import org.openjdk.jmh.annotations.Measurement;
+import org.openjdk.jmh.annotations.Mode;
+import org.openjdk.jmh.annotations.OutputTimeUnit;
+import org.openjdk.jmh.annotations.Scope;
+import org.openjdk.jmh.annotations.Setup;
+import org.openjdk.jmh.annotations.State;
+import org.openjdk.jmh.annotations.TearDown;
+import org.openjdk.jmh.annotations.Warmup;
+
+@BenchmarkMode(Mode.AverageTime)
+@Fork(1)
+@Measurement(iterations = 1, time = 1)
+@OutputTimeUnit(TimeUnit.MILLISECONDS)
+@State(Scope.Benchmark)
+@Warmup(iterations = 5, time = 1)
+public class Day14Benchmark {
+    private Reader input;
+
+    @Setup
+    public void setup() throws IOException {
+        var path = FileSystems.getDefault().getPath("inputs", "2016", "14");
+        var contents = Files.readString(path);
+        this.input = new StringReader(contents);
+    }
+
+    @Benchmark
+    public void part1() throws IOException {
+        Day14.part1(this.input);
+        this.input.reset();
+    }
+
+    @Benchmark
+    public void part2() throws IOException {
+        Day14.part2(this.input);
+        this.input.reset();
+    }
+}

java/src/main/java/com/github/saser/adventofcode/year2016/day14/BUILD.bazel

@@ -0,0 +1,7 @@
+package(default_visibility = ["//visibility:public"])
+
+java_library(
+    name = "day14",
+    srcs = glob(["*.java"]),
+    deps = ["//java/src/main/java/com/github/saser/adventofcode:adventofcode"],
+)

java/src/main/java/com/github/saser/adventofcode/year2016/day14/Day14.java

@@ -0,0 +1,174 @@
+package com.github.saser.adventofcode.year2016.day14;
+
+import java.io.BufferedReader;
+import java.io.Reader;
+import java.security.MessageDigest;
+import java.util.ArrayList;
+import java.util.HashSet;
+import java.util.List;
+import java.util.NavigableMap;
+import java.util.Optional;
+import java.util.Set;
+import java.util.TreeMap;
+import java.util.stream.IntStream;
+
+import com.github.saser.adventofcode.Result;
+
+public final class Day14 {
+    public static Result part1(Reader r) {
+        return solve(r, 1);
+    }
+
+    public static Result part2(Reader r) {
+        return solve(r, 2);
+    }
+
+    private static Result solve(Reader r, int part) {
+        try {
+            var salt = new BufferedReader(r).readLine();
+            var hasher = new Hasher(salt, part == 1 ? 0 : 2016);
+            var key64 = hasher.keyStream()
+                    .skip(63)
+                    .findFirst()
+                    .getAsInt();
+            return Result.ok(Integer.toString(key64));
+        } catch (Exception e) {
+            e.printStackTrace();
+            return Result.err(e.getMessage());
+        }
+    }
+
+    private static class Hasher {
+        public final String salt;
+        public final int extra;
+        private final MessageDigest md;
+        private final NavigableMap<Integer, Character> triples;
+        private final NavigableMap<Integer, Set<Character>> fivetuples;
+        private int nextHash;
+
+        public Hasher(String salt, int extra) throws Exception {
+            this.salt = salt;
+            this.extra = extra;
+            this.md = MessageDigest.getInstance("MD5");
+            this.triples = new TreeMap<>();
+            this.fivetuples = new TreeMap<>();
+            this.nextHash = 0;
+        }
+
+        private String hashString(String s) {
+            return Day14.hexString(md.digest(s.getBytes()));
+        }
+
+        private void hash(int index) {
+            var hash = this.hashString(this.salt + index);
+            for (var i = 0; i < this.extra; i++) {
+                hash = this.hashString(hash);
+            }
+            var groups = Day14.groups(hash);
+            for (var group : groups) {
+                var c = group.charAt(0);
+                if (group.length() >= 3 && !this.triples.containsKey(index)) {
+                    this.triples.put(index, c);
+                }
+                if (group.length() >= 5) {
+                    if (!this.fivetuples.containsKey(index)) {
+                        this.fivetuples.put(index, new HashSet<>());
+                    }
+                    this.fivetuples.get(index).add(c);
+                }
+            }
+        }
+
+        private void hashNext() {
+            this.hash(this.nextHash);
+            this.nextHash++;
+        }
+
+        private int nextIndex(int start, NavigableMap<Integer, ?> map) {
+            Optional<Integer> index;
+            do {
+                index = this.nextIndex(start, this.nextHash + 1, map);
+            } while (index.isEmpty());
+            return index.get();
+        }
+
+        private Optional<Integer> nextIndex(int start, int limit, NavigableMap<Integer, ?> map) {
+            while (this.nextHash < limit) {
+                this.hashNext();
+                if (map.ceilingKey(start) != null) {
+                    break;
+                }
+            }
+            return Optional.ofNullable(map.ceilingKey(start));
+        }
+
+        private int nextTriple(int start) {
+            return this.nextIndex(start, this.triples);
+        }
+
+        private Optional<Integer> nextFivetuple(int start, int limit) {
+            return this.nextIndex(start, limit, this.fivetuples);
+        }
+
+        private boolean hasFivetuple(int triple) {
+            var c = this.triples.get(triple);
+            var start = triple + 1;
+            var limit = start + 1000;
+            while (start < limit) {
+                var optFivetuple = this.nextFivetuple(start, limit);
+                if (optFivetuple.isEmpty()) {
+                    break;
+                }
+                var fivetuple = optFivetuple.get();
+                if (this.fivetuples.get(fivetuple).contains(c)) {
+                    return true;
+                }
+                start = fivetuple + 1;
+            }
+            return false;
+        }
+
+        private int nextKey(int start) {
+            var triple = this.nextTriple(start);
+            while (true) {
+                if (this.hasFivetuple(triple)) {
+                    return triple;
+                }
+                triple = this.nextTriple(triple + 1);
+            }
+        }
+
+        public IntStream keyStream() {
+            return IntStream.iterate(this.nextKey(0), key -> this.nextKey(key + 1));
+        }
+    }
+
+    private static String hexString(byte[] bytes) {
+        final var HEX_CHARS = "0123456789abcdef".toCharArray();
+        var chars = new char[2 * bytes.length];
+        for (var i = 0; i < bytes.length; i++) {
+            var b = bytes[i] & 0xFF;
+            chars[2 * i] = HEX_CHARS[b >>> 4]; // upper nibble
+            chars[2 * i + 1] = HEX_CHARS[b & 0x0F]; // lower nibble;
+        }
+        return new String(chars);
+    }
+
+    private static List<String> groups(String s) {
+        var chars = s.toCharArray();
+        var groups = new ArrayList<String>(s.length());
+        var start = 0;
+        var c = chars[start];
+        var end = 1;
+        while (end < chars.length) {
+            if (chars[end] != c) {
+                groups.add(s.substring(start, end));
+                c = chars[end];
+                start = end;
+            }
+            end++;
+        }
+        groups.add(s.substring(start, end));
+        return groups;
+    }
+}

java/src/test/java/com/github/saser/adventofcode/year2016/day14/BUILD.bazel

@@ -0,0 +1,11 @@
+java_test(
+    name = "test",
+    srcs = glob(["*.java"]),
+    test_class = "com.github.saser.adventofcode.year2016.day14.Day14Test",
+    deps = [
+        "@maven//:junit_junit",
+        "//java/src/main/java/com/github/saser/adventofcode:adventofcode",
+        "//java/src/main/java/com/github/saser/adventofcode/year2016/day14:day14",
+    ],
+    data = ["//inputs:2016/14"],
+)

java/src/test/java/com/github/saser/adventofcode/year2016/day14/Day14Test.java

@@ -0,0 +1,48 @@
+package com.github.saser.adventofcode.year2016.day14;
+
+import java.io.FileReader;
+import java.io.IOException;
+import java.io.StringReader;
+
+import org.junit.Test;
+import org.junit.Assert;
+
+public class Day14Test {
+    @Test
+    public void part1Example() {
+        var input = new StringReader("abc");
+        var output = "22728";
+        var result = Day14.part1(input);
+        Assert.assertEquals("no error", "", result.error);
+        Assert.assertEquals("correct output", output, result.answer);
+    }
+
+    @Test
+    public void part1Actual() throws IOException {
+        try (var input = new FileReader("inputs/2016/14")) {
+            var output = "16106";
+            var result = Day14.part1(input);
+            Assert.assertEquals("no error", "", result.error);
+            Assert.assertEquals("correct output", output, result.answer);
+        }
+    }
+
+     @Test
+     public void part2Example() {
+         var input = new StringReader("abc");
+         var output = "22551";
+         var result = Day14.part2(input);
+         Assert.assertEquals("no error", "", result.error);
+         Assert.assertEquals("correct output", output, result.answer);
+     }
+
+     @Test
+     public void part2Actual() throws IOException {
+         try (var input = new FileReader("inputs/2016/14")) {
+             var output = "22423";
+             var result = Day14.part2(input);
+             Assert.assertEquals("no error", "", result.error);
+             Assert.assertEquals("correct output", output, result.answer);
+         }
+     }
+}