optimize solutions

Author: SimonBaars

src/main/java/com/sbaars/adventofcode/year16/days/Day11.java

@@ -5,6 +5,8 @@
 import java.util.regex.Matcher;
 import java.util.regex.Pattern;
 import java.util.stream.Collectors;
+import java.util.stream.IntStream;
+import java.util.stream.Stream;
 
 public class Day11 extends Day2016 {
  private static final Pattern ITEM_PATTERN = Pattern.compile("(\\w+)(?:-compatible)? (microchip|generator)");
@@ -17,76 +19,82 @@ public static void main(String[] args) {
  new Day11().printParts();
  }
 
- private record State(int elevator, List<Set<String>> floors) {
+ private record ElementPosition(int generatorFloor, int microchipFloor) implements Comparable<ElementPosition> {
+ @Override
+ public int compareTo(ElementPosition o) {
+ int cmp = Integer.compare(generatorFloor, o.generatorFloor);
+ if (cmp != 0) return cmp;
+ return Integer.compare(microchipFloor, o.microchipFloor);
+ }
+ }
+
+ private record State(int elevatorFloor, List<ElementPosition> elements) {
+ public State {
+ elements = new ArrayList<>(elements);
+ Collections.sort(elements);
+ }
+
  public boolean isValid() {
- for (Set<String> floor : floors) {
- Set<String> generators = floor.stream()
- .filter(s -> s.endsWith("G"))
- .collect(Collectors.toSet());
- Set<String> microchips = floor.stream()
- .filter(s -> s.endsWith("M"))
- .collect(Collectors.toSet());
-
- if (!generators.isEmpty()) {
- for (String chip : microchips) {
- String gen = chip.substring(0, chip.length() - 1) + "G";
- if (!generators.contains(gen)) {
- return false;
- }
+ for (ElementPosition elem : elements) {
+ if (elem.microchipFloor != elem.generatorFloor) {
+ final int floor = elem.microchipFloor;
+ boolean hasGenerator = elements.stream()
+ .anyMatch(e -> e.generatorFloor == floor);
+ if (hasGenerator) {
+ return false;
  }
  }
  }
  return true;
  }
 
  public boolean isComplete() {
- return floors.get(0).isEmpty() && 
- floors.get(1).isEmpty() && 
- floors.get(2).isEmpty();
+ return elements.stream()
+ .allMatch(e -> e.generatorFloor == 3 && e.microchipFloor == 3);
  }
 
  public List<State> nextStates() {
  List<State> states = new ArrayList<>();
- Set<String> currentFloor = floors.get(elevator);
-
- // Try moving one or two items
- List<List<String>> itemCombos = new ArrayList<>();
- currentFloor.forEach(item -> itemCombos.add(List.of(item)));
- for (String item1 : currentFloor) {
- for (String item2 : currentFloor) {
- if (item1.compareTo(item2) < 0) {
- itemCombos.add(List.of(item1, item2));
- }
+ List<MoveItem> movable = new ArrayList<>();
+
+ for (int i = 0; i < elements.size(); i++) {
+ ElementPosition elem = elements.get(i);
+ if (elem.generatorFloor == elevatorFloor) {
+ movable.add(new MoveItem(i, true));
+ }
+ if (elem.microchipFloor == elevatorFloor) {
+ movable.add(new MoveItem(i, false));
  }
  }
 
- // Try moving up or down
- for (int newElevator : List.of(elevator - 1, elevator + 1)) {
- if (newElevator >= 0 && newElevator < floors.size()) {
- for (List<String> items : itemCombos) {
- List<Set<String>> newFloors = new ArrayList<>();
- for (int i = 0; i < floors.size(); i++) {
- newFloors.add(new HashSet<>(floors.get(i)));
+ for (int dir : new int[]{-1, 1}) {
+ int newFloor = elevatorFloor + dir;
+ if (newFloor < 0 || newFloor >= 4) continue;
+
+ for (int count = 1; count <= Math.min(2, movable.size()); count++) {
+ Combinations.combinations(movable, count).forEach(combo -> {
+ List<ElementPosition> newElements = new ArrayList<>(elements);
+ for (MoveItem item : combo) {
+ ElementPosition e = newElements.get(item.elementIndex);
+ if (item.isGenerator) {
+ newElements.set(item.elementIndex, new ElementPosition(newFloor, e.microchipFloor));
+ } else {
+ newElements.set(item.elementIndex, new ElementPosition(e.generatorFloor, newFloor));
+ }
  }
-
- // Move items
- items.forEach(item -> {
- newFloors.get(elevator).remove(item);
- newFloors.get(newElevator).add(item);
- });
-
- State newState = new State(newElevator, newFloors);
+ State newState = new State(newFloor, newElements);
  if (newState.isValid()) {
  states.add(newState);
  }
- }
+ });
  }
  }
-
  return states;
  }
  }
 
+ private record MoveItem(int elementIndex, boolean isGenerator) {}
+
  private int findMinSteps(State initial) {
  Queue<State> queue = new ArrayDeque<>();
  Map<State, Integer> visited = new HashMap<>();
@@ -103,38 +111,52 @@ private int findMinSteps(State initial) {
 
  for (State next : current.nextStates()) {
  if (!visited.containsKey(next)) {
- queue.add(next);
  visited.put(next, steps + 1);
+ queue.add(next);
  }
  }
  }
-
  return -1;
  }
 
- private State parseInput(boolean includePart2Items) {
- List<Set<String>> floors = new ArrayList<>();
- for (int i = 0; i < 4; i++) {
- floors.add(new HashSet<>());
- }
-
+ private State parseInput(boolean includePart2) {
+ Map<String, Integer> generatorFloors = new HashMap<>();
+ Map<String, Integer> microchipFloors = new HashMap<>();
+ 
  int floor = 0;
  for (String line : dayStream().toList()) {
- Matcher matcher = ITEM_PATTERN.matcher(line);
- while (matcher.find()) {
- String element = matcher.group(1);
- String type = matcher.group(2);
- floors.get(floor).add(element.substring(0, 2).toUpperCase() + 
- (type.equals("generator") ? "G" : "M"));
+ Matcher m = ITEM_PATTERN.matcher(line);
+ while (m.find()) {
+ String element = m.group(1).substring(0, 2).toUpperCase();
+ String type = m.group(2);
+ if (type.equals("generator")) {
+ generatorFloors.put(element, floor);
+ } else {
+ microchipFloors.put(element, floor);
+ }
  }
  floor++;
  }
 
- if (includePart2Items) {
- floors.get(0).addAll(Set.of("ELG", "ELM", "DIG", "DIM"));
+ if (includePart2) {
+ generatorFloors.put("EL", 0);
+ microchipFloors.put("EL", 0);
+ generatorFloors.put("DI", 0);
+ microchipFloors.put("DI", 0);
  }
 
- return new State(0, floors);
+ Set<String> allElements = new HashSet<>();
+ allElements.addAll(generatorFloors.keySet());
+ allElements.addAll(microchipFloors.keySet());
+ 
+ List<ElementPosition> elements = allElements.stream()
+ .map(e -> new ElementPosition(
+ generatorFloors.getOrDefault(e, -1),
+ microchipFloors.getOrDefault(e, -1)
+ ))
+ .toList();
+
+ return new State(0, elements);
  }
 
  @Override
@@ -147,3 +169,22 @@ public Object part2() {
  return findMinSteps(parseInput(true));
  }
 }
+
+class Combinations {
+ static <T> Stream<List<T>> combinations(List<T> items, int k) {
+ if (k == 0) {
+ return Stream.of(Collections.emptyList());
+ } else {
+ return IntStream.range(0, items.size()).boxed()
+ .flatMap(i -> combinations(items.subList(i+1, items.size()), k-1)
+ .map(t -> prepend(items.get(i), t)));
+ }
+ }
+
+ private static <T> List<T> prepend(T head, List<T> tail) {
+ List<T> result = new ArrayList<>();
+ result.add(head);
+ result.addAll(tail);
+ return result;
+ }
+}

src/main/java/com/sbaars/adventofcode/year16/days/Day5.java

@@ -22,14 +22,18 @@ public Object part1() {
  String doorId = day().trim();
  StringBuilder password = new StringBuilder();
  int index = 0;
+
  try {
  MessageDigest md = MessageDigest.getInstance("MD5");
  while (password.length() < 8) {
- String input = doorId + index;
- byte[] digest = md.digest(input.getBytes(StandardCharsets.UTF_8));
- String hash = bytesToHex(digest);
- if (hash.startsWith("00000")) {
- password.append(hash.charAt(5));
+ byte[] digest = md.digest((doorId + index).getBytes(StandardCharsets.UTF_8));
+
+ // Check if first 20 bits (5 hex zeroes) are zero
+ // digest[0] == 0 && digest[1] == 0 && (digest[2] & 0xF0) == 0
+ if (digest[0] == 0 && digest[1] == 0 && (digest[2] & 0xF0) == 0) {
+ // The 6th hex character is the low nibble of digest[2]
+ int nib5 = digest[2] & 0x0F;
+ password.append(toHexChar(nib5));
  }
  index++;
  }
@@ -46,21 +50,20 @@ public Object part2() {
  Arrays.fill(password, '_');
  int filled = 0;
  int index = 0;
+
  try {
  MessageDigest md = MessageDigest.getInstance("MD5");
  while (filled < 8) {
- String input = doorId + index;
- byte[] digest = md.digest(input.getBytes(StandardCharsets.UTF_8));
- String hash = bytesToHex(digest);
- if (hash.startsWith("00000") && hash.length() >= 7) {
- char posChar = hash.charAt(5);
- if (posChar >= '0' && posChar <= '7') {
- int pos = posChar - '0';
- if (password[pos] == '_') {
- char c = hash.charAt(6);
- password[pos] = c;
- filled++;
- }
+ byte[] digest = md.digest((doorId + index).getBytes(StandardCharsets.UTF_8));
+ // Same check as above
+ if (digest[0] == 0 && digest[1] == 0 && (digest[2] & 0xF0) == 0) {
+ // 6th hex character is nib5 (low nibble of digest[2]), 7th is nib6 (high nibble of digest[3])
+ int nib5 = digest[2] & 0x0F; // position
+ int nib6 = (digest[3] & 0xF0) >>> 4; // actual character
+
+ if (nib5 < 8 && password[nib5] == '_') {
+ password[nib5] = toHexChar(nib6);
+ filled++;
  }
  }
  index++;
@@ -71,11 +74,7 @@ public Object part2() {
  return new String(password);
  }
 
- private static String bytesToHex(byte[] bytes) {
- StringBuilder sb = new StringBuilder();
- for (byte b : bytes) {
- sb.append(String.format("%02x", b));
- }
- return sb.toString();
+ private static char toHexChar(int nibble) {
+ return (char) (nibble < 10 ? ('0' + nibble) : ('a' + (nibble - 10)));
  }
 }