I returned to day 21 and finished part 2. My initial naive attempt tried to generate the full strings of

keypad presses, which, unsurprisingly, caused out of memory errors. Then I had the idea to represent the

press sequences in a way that used less memory. After adding a shortcut after each robot's loop

iteration, it finishes in about 2 minutes on my laptop.

I suspect this is one of those puzzles where there's a pattern in the growth of the sequences, and you can

calculate the minimum size at n iterations without actually having to loop through them. I'm not that clever,

sadly.

I'm still proud of my solution. It was tricky to model properly, and there were lots of hairy one-to-many

transformations. I think it's pretty readable and easy to understand what's happening.

I'm running out of steam, so when I get around to it, I'm going to cheat for days 17 and 24 and see how someone

else solved them. Implementation is still work and learning!

package com.codefork.aoc2024.day21;

public record Button(String symbol, Position pos) {

public boolean isAdjacent(Button other) {

var xDiff = Math.abs(pos().x() - other.pos().x());

var yDiff = Math.abs(pos().y() - other.pos().y());

return xDiff + yDiff == 1;

}

/**

public String getAction(Button target) {

var xDiff = pos().x() - target.pos().x();

var yDiff = pos().y() - target.pos().y();

if (xDiff > 0) {

return "<";

} else if (xDiff < 0) {

return ">";

}

if (yDiff > 0) {

return "^";

} else if (yDiff < 0) {

return "v";

}

throw new RuntimeException("buttons aren't adjacent in getAction=" + this + "," + target);

}

public String toString() {

return symbol + "(" + pos.x() + "," + pos.y() + ")";

}

@SuppressWarnings("unused")

public char asChar() {

return symbol.charAt(0);

}

}

package com.codefork.aoc2024.day21;

import static com.codefork.aoc2024.day21.Keypad.dirKeypad;

public class DirectionalKeypadNavigator extends KeypadNavigator {

public DirectionalKeypadNavigator() {

super(dirKeypad);

}

}

package com.codefork.aoc2024.day21;

import java.util.List;

public class DoorKeypadNavigator extends KeypadNavigator {

private static final List<Button> doorButtons = List.of(

new Button("7", new Position(0, 0)),

new Button("8", new Position(1, 0)),

new Button("9", new Position(2, 0)),

new Button("4", new Position(0, 1)),

new Button("5", new Position(1, 1)),

new Button("6", new Position(2, 1)),

new Button("1", new Position(0, 2)),

new Button("2", new Position(1, 2)),

new Button("3", new Position(2, 2)),

new Button("0", new Position(1, 3)),

new Button("A", new Position(2, 3))

);

private static final Keypad doorKeypad = new Keypad(doorButtons);

public DoorKeypadNavigator() {

super(doorKeypad);

}

}

package com.codefork.aoc2024.day21;

import java.util.ArrayList;

import java.util.HashMap;

import java.util.List;

import java.util.Map;

import java.util.stream.Collectors;

public class Keypad {

// directional keypad buttons

private static final List<Button> dirKeypadButtons = List.of(

new Button("^", new Position(1, 0)),

new Button("A", new Position(2, 0)),

new Button("<", new Position(0, 1)),

new Button("v", new Position(1, 1)),

new Button(">", new Position(2, 1))

);

// directional keypad: this is used by both navigator

public static final Keypad dirKeypad = new Keypad(dirKeypadButtons);

private final List<Button> buttons;

private final Map<String, Button> buttonsMap;

// map of moves to every possible path for making that move

private final Map<Move, List<String>> movesToPaths;

public Keypad(List<Button> buttons) {

this.buttons = buttons;

this.buttonsMap = buttons.stream()

.collect(Collectors.toMap(

Button::symbol,

b -> b));

this.movesToPaths = createShortestPaths();

}

private Map<Move, List<String>> createShortestPaths() {

Map<Move, List<String>> result = new HashMap<>();

// generate graph of adjacent buttons

var graph = new HashMap<Button, List<Button>>();

for (var i = 0; i < buttons.size(); i++) {

var button1 = buttons.get(i);

for (var j = i; j < buttons.size(); j++) {

var button2 = buttons.get(j);

if (button1.isAdjacent(button2)) {

if (!graph.containsKey(button1)) {

graph.put(button1, new ArrayList<>());

}

graph.get(button1).add(button2);

if (!graph.containsKey(button2)) {

graph.put(button2, new ArrayList<>());

}

graph.get(button2).add(button1);

}

}

}

// generate shortest paths for every button to every other button

for (var i = 0; i < buttons.size(); i++) {

var button1 = buttons.get(i);

var shortestPaths = ShortestPaths.create(buttons, graph, button1);

var otherButtons = buttons.stream().filter(b -> !b.equals(button1)).toList();

for (var button2 : otherButtons) {

var presses = shortestPaths.getPossiblePressSequences(button2);

//System.out.println("move " + button1 + "->" + button2 + " adding presses=" + presses);

result.put(new Move(button1, button2), presses);

}

}

// path from a button to itself it just "A"

for (Button button : buttons) {

result.put(new Move(button, button), List.of("A"));

}

return result;

}

public Map<String, Button> getButtonsMap() {

return buttonsMap;

}

public Button getButton(String symbol) {

return buttonsMap.get(symbol);

}

public Button getButton(char symbol) {

return buttonsMap.get(String.valueOf(symbol));

}

public Map<Move, List<String>> getMovesToPaths() {

return movesToPaths;

}

}

package com.codefork.aoc2024.day21;

import java.util.ArrayList;

import java.util.HashSet;

import java.util.List;

import java.util.Set;

public class KeypadNavigator {

private final Keypad keypad;

public KeypadNavigator(Keypad keypad) {

this.keypad = keypad;

}

public Keypad getKeypad() {

return keypad;

}

/**

public Set<PressSequence> getPossiblePressSequences(PressSequence seq) {

List<PressSequence> results = new ArrayList<>();

results.add(PressSequence.create());

//System.out.println("getting possible sequences for seq=" + seq);

// examine each move and append the possibilities to results

for (var entry : seq.moves().entrySet()) {

var newResults = new ArrayList<PressSequence>();

var move = entry.getKey();

var moveCount = entry.getValue();

//System.out.println("handling " + move + " (count=" + moveCount + ")");

for (var result : results) {

var possibilities = addMove(result, move, moveCount);

newResults.addAll(possibilities);

}

results = newResults;

}

return new HashSet<>(results);

}

/**

public List<PressSequence> addMove(PressSequence seq, Move move, long multiplier) {

var results = new ArrayList<PressSequence>();

var paths = getKeypad().getMovesToPaths().get(move);

//System.out.println("from=" + _from + " to=" + _to + " paths=" + paths);

for (var path : paths) {

var copy = seq.copy();

char first = path.charAt(0);

// note that we use dirKeypad here, since movements match up with the directional keypad

// add a transitional move from the last implicit "A"

if (path.length() > 1 && first != 'A') {

var transition = new Move(Keypad.dirKeypad.getButton("A"), Keypad.dirKeypad.getButton(first));

copy.moves().merge(transition, multiplier, Long::sum);

}

var from = first;

for (var i = 1; i < path.length(); i++) {

var to = path.charAt(i);

var moveInPath = new Move(Keypad.dirKeypad.getButton(from), Keypad.dirKeypad.getButton(to));

copy.moves().merge(moveInPath, multiplier, Long::sum);

from = to;

}

// this happens when a button repeats (i.e. moves from a button to itself)

if (path.length() == 1) {

var aButton = Keypad.dirKeypad.getButton("A");

var moveInPath = new Move(aButton, aButton);

copy.moves().merge(moveInPath, multiplier, Long::sum);

}

results.add(copy);

}

//System.out.println("addMove returning=" + results);

return results;

}

}

package com.codefork.aoc2024.day21;

public record Move(Button from, Button to) {

}

import java.util.ArrayList;

import java.util.HashSet;

import java.util.Set;

import static com.codefork.aoc2024.day21.ShipLock.getNumericPortion;

System.out.println("TODO: This takes ~2 minutes to run, needs to be optimized");

return String.valueOf(ShipLock.calculateSumOfComplexities(data, 25));

package com.codefork.aoc2024.day21;

public record Position(int x, int y) {

}