Day 24 part 1 - I have regrets

Author: robabrazado

README.md

@@ -181,3 +181,15 @@ I thought I could dash off part 1 real quick over lunch...but it turned out I mi
 [Later] I rewrote part 1, now understanding what was being asked. Seems to work well! Sadly, it doesn't seem like what I wrote is going to help me with part 2, despite me trying to make it more general use than what they were asking! I'll need a new approach to tackle part 2.
 
 [Later still] Yeah...my logic for part 2 is totally different from part 1, but both seem to work well, so I'm taking the W!
+
+## Day 24: Crossed Wires
+
+I had a pretty good time implementing part 1, due in no small part to thinking I was doing something "clever." Now having done part 1 and seen the ask for part 2, I think it's likely I'll have to throw away everything I did for part 1. I'm not going to try it out now, though; it's late and I have to sleep. I'll think on it, though...I'll try to use this extra mulling time to see if I an approach part 2 with the architecture I set up for part 1...or if I'll just have to start the whole thing over.
+
+**Day 24 part 1 spoilers**
+
+For whatever reason, it seemed to make sense to me to have the signal information work backwards...that it would get "pulled" from the output wires instead of "pushed" by the initial wire values. Since the gates have to "wait" for their signals to come in, it felt like it made sense for me to pull on the dependency chain from the output side. Like...it seemed like it would make it easier to detect errors?
+
+[Later] Now that I've completed part 1 and seen part 2, I think I've really hosed myself. By "easier to detect errors" before, I meant easier to detect if I wasn't wiring the board internals correctly based on what the puzzle input was saying. Now that I've seen part 2, "easier to detect errors" is laughably wrong; I can't detect shit with this implementation, I'm pretty sure. I thought I was so funny not keeping any gate references. Who's laughing now?! Not me.
+
+**End spoilers**

src/com/robabrazado/aoc2024/day24/Board.java

@@ -0,0 +1,94 @@
+package com.robabrazado.aoc2024.day24;
+
+import java.io.PrintWriter;
+import java.io.StringWriter;
+import java.math.BigInteger;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.Map;
+import java.util.Set;
+import java.util.TreeSet;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+import java.util.stream.Stream;
+
+/*
+ * A Board is an assemblage of Wires and Gates. The state of the board is activated by
+ * setting the value to input wires (wires whose inputs are not connected to any gate
+ * outputs), and values can be read from any wire. A wire without a value generally
+ * signals that the necessary input wires have not been assigned values or that the
+ * Board is misconfigured. 
+ */
+public class Board {
+	private static final Pattern STATE_PATTERN = Pattern.compile("(\\w+): ([01])");
+	private static final Pattern GATE_PATTERN = Pattern.compile("(\\w+) (\\w+) (\\w+) -> (\\w+)");
+	
+	private final Map<String, Wire> wireMap = new HashMap<String, Wire>();
+	
+	// Instantiates and initializes board to starting state
+	public Board(Stream<String> puzzleInput) {
+		Iterator<String> it = puzzleInput.iterator();
+		String line = null;
+		
+		// Input until first blank line is initial state
+		while (it.hasNext()) {
+			line = it.next();
+			if (line.isEmpty()) {
+				break;
+			}
+			
+			Matcher m = STATE_PATTERN.matcher(line);
+			if (m.find()) {
+				Wire w = this.getOrCreateWire(m.group(1));
+				w.setValue(m.group(2).equals("1"));
+			} else {
+				throw new RuntimeException("Unrecognized initial state input: " + line);
+			}
+		}
+		
+		// Rest of input is board configuration
+		while (it.hasNext()) {
+			line = it.next();
+			Matcher m = GATE_PATTERN.matcher(line);
+			if (m.find()) {
+				Gate.connectGate(Gate.GateType.valueOf(m.group(2)),
+						this.getOrCreateWire(m.group(1)),
+						this.getOrCreateWire(m.group(3)),
+						this.getOrCreateWire(m.group(4)));
+			} else {
+				throw new RuntimeException("Unrecognized gate input: " + line);
+			}
+		}
+		
+		
+	}
+	
+	public BigInteger getZOutputValue() {
+		StringBuilder strb = new StringBuilder();
+		Set<String> wireIds = new TreeSet<String>(this.wireMap.keySet());
+		for (String s : wireIds) {
+			if (s.startsWith("z")) {
+				strb.insert(0, this.wireMap.get(s).getValue() ? '1' : '0');
+			}
+		}
+		return new BigInteger(strb.toString(), 2);
+	}
+	
+	@Override
+	public String toString() {
+		StringWriter sw = new StringWriter();
+		PrintWriter pw = new PrintWriter(sw, true);
+		Set<String> wires = new TreeSet<String>(this.wireMap.keySet());
+		for (String wire : wires) {
+			pw.println(this.wireMap.get(wire));
+		}
+		return sw.toString();
+	}
+	
+	private Wire getOrCreateWire(String id) {
+		if (!this.wireMap.containsKey(id)) {
+			this.wireMap.put(id, new Wire(id));
+		}
+		return this.wireMap.get(id);
+	}
+}

src/com/robabrazado/aoc2024/day24/Day24Solver.java

@@ -0,0 +1,25 @@
+package com.robabrazado.aoc2024.day24;
+
+import java.math.BigInteger;
+import java.util.stream.Stream;
+
+import com.robabrazado.aoc2024.Solver;
+
+// --- Day 24: Crossed Wires ---
+public class Day24Solver extends Solver {
+	
+	public Day24Solver() {
+		super(24);
+		return;
+	}
+	
+	@Override
+	public String solve(Stream<String> puzzleInput, boolean partOne, boolean isTest) {
+		Board board = new Board(puzzleInput);
+		System.out.println(board);
+		BigInteger result = board.getZOutputValue();
+		System.out.println(result.toString(2));
+		return result.toString();
+	}
+	
+}

src/com/robabrazado/aoc2024/day24/Gate.java

@@ -0,0 +1,69 @@
+package com.robabrazado.aoc2024.day24;
+
+class Gate {
+	private final GateType type;
+	private final Wire input1;
+	private final Wire input2;
+	private final Wire output;
+	
+	private Gate(GateType gateType, Wire input1, Wire input2, Wire output) {
+		if (input1 == null || input2 == null || output == null) {
+			throw new IllegalArgumentException("Gates must have all inputs and outputs connected");
+		}
+		this.input1 = input1;
+		this.input2 = input2;
+		this.output = output;
+		this.type = gateType;
+		return;
+	}
+	
+	Wire getInputWire1() {
+		return this.input1;
+	}
+	
+	Wire getInputWire2() {
+		return this.input2;
+	}
+	
+	Wire getOutputWire() {
+		return this.output;
+	}
+	
+	// Throws exception if input signals not available
+	boolean getOutput() {
+		switch (this.type) {
+		case AND:
+			return this.input1.getValue() && this.input2.getValue();
+		case OR:
+			return this.input1.getValue() || this.input2.getValue();
+		case XOR:
+			return this.input1.getValue() ^ this.input2.getValue();
+		default: // Uh oh
+			throw new RuntimeException("Unsupported gate type");
+		}
+	}
+	
+	@Override
+	public String toString() {
+		return String.format("%s %s %s -> %s",
+				this.input1.getId(),
+				this.type.name(),
+				this.input2.getId(),
+				this.output.getId());
+	}
+	
+	static Gate connectGate(GateType gateType, Wire toInput1, Wire toInput2, Wire fromOutput) {
+		Gate gate = new Gate(gateType, toInput1, toInput2, fromOutput);
+		toInput1.connectToGateInput(gate);
+		toInput2.connectToGateInput(gate);
+		fromOutput.connectToGateOutput(gate);
+		return gate;
+	}
+	
+	enum GateType {
+		AND		(),
+		OR		(),
+		XOR		();
+		
+	}
+}

src/com/robabrazado/aoc2024/day24/Wire.java

@@ -0,0 +1,96 @@
+package com.robabrazado.aoc2024.day24;
+
+import java.util.HashSet;
+import java.util.Set;
+
+class Wire {
+	private final String id;
+	private Gate inputGate = null; // Zero or one input
+	private Set<Gate> outputGates = new HashSet<Gate>(); // Zero or more outputs
+	private Boolean value = null;
+	
+	Wire(String id) {
+		if (id == null || id.isEmpty()) {
+			throw new IllegalArgumentException("Wire must have a valid ID");
+		}
+		this.id = id;
+		return;
+	}
+	
+	String getId() {
+		return this.id;
+	}
+	
+	Gate getInput() {
+		return this.inputGate;
+	}
+	
+	// This is the wire's "input"; there can be at most one
+	void connectToGateOutput(Gate fromGate) {
+		if (this.inputGate == null) {
+			this.inputGate = fromGate;
+		} else {
+			throw new IllegalStateException("A wire can only be connected to one gate output");
+		}
+	}
+	
+	Set<Gate> getOutputs() {
+		return new HashSet<Gate>(this.outputGates);
+	}
+	
+	// This is the wire's "output"
+	void connectToGateInput(Gate toGate) {
+		this.outputGates.add(toGate);
+		return;
+	}
+	
+	// Throws error if value unavailable
+	// Once called, value will remain in wire until cleared
+	boolean getValue() {
+		if (this.inputGate != null) {
+			this.value = this.inputGate.getOutput();
+		}
+		if (this.value != null) {
+			return this.value.booleanValue();
+		} else {
+			String message = this.inputGate == null ?
+					"Input wire " + this.id + " has no value assigned" :
+					"Wire " + this.id + " unable to read value from input gate";
+			throw new RuntimeException(message);
+		}
+	}
+	
+	void setValue(boolean b) {
+		if (this.isInputWire()) {
+			this.value = Boolean.valueOf(b);
+			return;
+		} else {
+			throw new IllegalStateException("Value cannot be manually set; " + this.id + " is not an input wire");
+		}
+	}
+	
+	void clearValue() {
+		this.value = null;
+	}
+	
+	boolean isInputWire() {
+		return this.inputGate == null;
+	}
+	
+	@Override
+	public String toString() {
+		StringBuilder strb = new StringBuilder();
+		strb.append(this.id).append(" (");
+		if (this.value == null) {
+			strb.append('X');
+		} else {
+			strb.append(this.value ? '1' : '0');
+		}
+		strb.append("); ");
+		
+		strb.append(this.inputGate == null ? '0' : '1').append(" input; ");
+		strb.append(this.outputGates.size()).append(" output(s)");
+		
+		return strb.toString();
+	}
+}