Day 24. Solution earlier than working algorithm that does not require manual steps.
This commit is contained in:
parent
e00e002cd6
commit
e7d733846f
345
src/aoc2024/Day24.kt
Normal file
345
src/aoc2024/Day24.kt
Normal file
@ -0,0 +1,345 @@
|
||||
package aoc2024
|
||||
|
||||
import println
|
||||
import readInput
|
||||
import java.util.*
|
||||
import kotlin.collections.ArrayDeque
|
||||
|
||||
/*
|
||||
--- Day 24: Crossed Wires ---
|
||||
https://adventofcode.com/2024/day/24
|
||||
*/
|
||||
fun main() {
|
||||
|
||||
val inlineTestInput = """
|
||||
x00: 1
|
||||
x01: 1
|
||||
x02: 1
|
||||
y00: 0
|
||||
y01: 1
|
||||
y02: 0
|
||||
|
||||
x00 AND y00 -> z00
|
||||
x01 XOR y01 -> z01
|
||||
x02 OR y02 -> z02
|
||||
"""
|
||||
|
||||
val inlineTestInput2 = """
|
||||
x00: 1
|
||||
x01: 0
|
||||
x02: 1
|
||||
x03: 1
|
||||
x04: 0
|
||||
y00: 1
|
||||
y01: 1
|
||||
y02: 1
|
||||
y03: 1
|
||||
y04: 1
|
||||
|
||||
ntg XOR fgs -> mjb
|
||||
y02 OR x01 -> tnw
|
||||
kwq OR kpj -> z05
|
||||
x00 OR x03 -> fst
|
||||
tgd XOR rvg -> z01
|
||||
vdt OR tnw -> bfw
|
||||
bfw AND frj -> z10
|
||||
ffh OR nrd -> bqk
|
||||
y00 AND y03 -> djm
|
||||
y03 OR y00 -> psh
|
||||
bqk OR frj -> z08
|
||||
tnw OR fst -> frj
|
||||
gnj AND tgd -> z11
|
||||
bfw XOR mjb -> z00
|
||||
x03 OR x00 -> vdt
|
||||
gnj AND wpb -> z02
|
||||
x04 AND y00 -> kjc
|
||||
djm OR pbm -> qhw
|
||||
nrd AND vdt -> hwm
|
||||
kjc AND fst -> rvg
|
||||
y04 OR y02 -> fgs
|
||||
y01 AND x02 -> pbm
|
||||
ntg OR kjc -> kwq
|
||||
psh XOR fgs -> tgd
|
||||
qhw XOR tgd -> z09
|
||||
pbm OR djm -> kpj
|
||||
x03 XOR y03 -> ffh
|
||||
x00 XOR y04 -> ntg
|
||||
bfw OR bqk -> z06
|
||||
nrd XOR fgs -> wpb
|
||||
frj XOR qhw -> z04
|
||||
bqk OR frj -> z07
|
||||
y03 OR x01 -> nrd
|
||||
hwm AND bqk -> z03
|
||||
tgd XOR rvg -> z12
|
||||
tnw OR pbm -> gnj
|
||||
"""
|
||||
|
||||
data class Node(val n1: String, val n2: String, val op: Int, var target: String, var val1: Boolean? = null, var val2: Boolean? = null) {
|
||||
fun output() = when (op) {
|
||||
0 -> val1!! || val2!!
|
||||
1 -> val1!! && val2!!
|
||||
2 -> val1!! != val2!!
|
||||
else -> false
|
||||
}
|
||||
|
||||
override fun equals(other: Any?): Boolean {
|
||||
if (this === other) return true
|
||||
if (javaClass != other?.javaClass) return false
|
||||
|
||||
other as Node
|
||||
|
||||
return target == other.target
|
||||
}
|
||||
|
||||
override fun hashCode(): Int {
|
||||
return target.hashCode()
|
||||
}
|
||||
}
|
||||
|
||||
val nodes = ArrayList<Node>()
|
||||
val nodesWaiting = HashMap<String, MutableList<Node>>()
|
||||
var satisfiedNodes = ArrayList<Node>()
|
||||
val zTargets = TreeSet<String>()
|
||||
val zState = HashMap<String, Boolean>()
|
||||
val targetParent = HashMap<String, Node>()
|
||||
val initialStates = HashMap<String, Boolean>()
|
||||
val zInvolvedNodes = HashMap<String, MutableSet<Node>>()
|
||||
val random = kotlin.random.Random(1337)
|
||||
|
||||
fun readCircuit(input: List<String>) {
|
||||
nodes.clear()
|
||||
nodesWaiting.clear()
|
||||
satisfiedNodes.clear()
|
||||
zTargets.clear()
|
||||
zState.clear()
|
||||
targetParent.clear()
|
||||
initialStates.clear()
|
||||
var i = 0
|
||||
while (input[i++].isNotEmpty()) {
|
||||
val (n, st) = input[i - 1].split(": ")
|
||||
initialStates[n] = (st == "1")
|
||||
}
|
||||
while (i < input.size) {
|
||||
val (n1, op, n2, _, target) = input[i++].split(" ")
|
||||
val opCode = when (op) {
|
||||
"OR" -> 0
|
||||
"AND" -> 1
|
||||
"XOR" -> 2
|
||||
else -> throw IllegalStateException()
|
||||
}
|
||||
if (target.startsWith("z")) {
|
||||
zTargets.add(target)
|
||||
}
|
||||
val node = Node(n1, n2, opCode, target)
|
||||
nodes.add(node)
|
||||
targetParent[target] = node
|
||||
}
|
||||
}
|
||||
|
||||
fun outputState(target: String, output: Boolean, newSatisfiedNodes: MutableCollection<Node>) {
|
||||
if (target.startsWith("z")) {
|
||||
zState[target] = output
|
||||
}
|
||||
val targetList = nodesWaiting[target] ?: return
|
||||
while (targetList.isNotEmpty()) {
|
||||
val tNode = targetList.removeFirst()
|
||||
if (tNode.n1 == target) {
|
||||
tNode.val1 = output
|
||||
if (tNode.val2 != null) {
|
||||
newSatisfiedNodes.add(tNode)
|
||||
}
|
||||
} else {
|
||||
tNode.val2 = output
|
||||
if (tNode.val1 != null) {
|
||||
newSatisfiedNodes.add(tNode)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fun runCircuit(): Boolean {
|
||||
while (zState.size != zTargets.size) {
|
||||
if (satisfiedNodes.isEmpty()) {
|
||||
return false
|
||||
}
|
||||
val newSatisfiedNodes = ArrayList<Node>()
|
||||
for (node in satisfiedNodes) {
|
||||
val output = node.output()
|
||||
node.val1 = null
|
||||
node.val2 = null
|
||||
nodesWaiting.getOrPut(node.n1) { ArrayList() }.add(node)
|
||||
nodesWaiting.getOrPut(node.n2) { ArrayList() }.add(node)
|
||||
|
||||
outputState(node.target, output, newSatisfiedNodes)
|
||||
}
|
||||
satisfiedNodes = newSatisfiedNodes
|
||||
}
|
||||
return true
|
||||
}
|
||||
|
||||
fun reset() {
|
||||
satisfiedNodes.clear()
|
||||
nodesWaiting.clear()
|
||||
zState.clear()
|
||||
for (node in nodes) {
|
||||
node.val1 = null
|
||||
node.val2 = null
|
||||
nodesWaiting.getOrPut(node.n1) { ArrayDeque() }.add(node)
|
||||
nodesWaiting.getOrPut(node.n2) { ArrayDeque() }.add(node)
|
||||
}
|
||||
}
|
||||
|
||||
fun setXY(n: String, value: Long) {
|
||||
var v = value
|
||||
for (i in 0..zTargets.size - 2) {
|
||||
outputState("%s%02d".format(n, i), (v and 1L) != 0L, satisfiedNodes)
|
||||
v = v shr 1
|
||||
}
|
||||
}
|
||||
|
||||
fun readZ(): Long {
|
||||
var result = 0L
|
||||
for (i in zTargets.reversed()) {
|
||||
result *= 2
|
||||
if (zState[i] == true) result++
|
||||
}
|
||||
|
||||
return result
|
||||
}
|
||||
|
||||
fun calcInvolvedNodes() {
|
||||
zInvolvedNodes.clear()
|
||||
for (target in zTargets) {
|
||||
val set = HashSet<Node>()
|
||||
val queue = ArrayDeque<Node>()
|
||||
queue.add(targetParent[target]!!)
|
||||
while (queue.isNotEmpty()) {
|
||||
val node = queue.removeFirst()
|
||||
set.add(node)
|
||||
val t1 = targetParent[node.n1]
|
||||
val t2 = targetParent[node.n2]
|
||||
if (t1 != null && !set.contains(t1)) queue.add(t1)
|
||||
if (t2 != null && !set.contains(t2)) queue.add(t2)
|
||||
}
|
||||
zInvolvedNodes[target] = set
|
||||
}
|
||||
}
|
||||
|
||||
fun swapOutputs(t1: String, t2: String) {
|
||||
val n1 = targetParent[t1]!!
|
||||
val n2 = targetParent[t2]!!
|
||||
n1.target = t2
|
||||
n2.target = t1
|
||||
targetParent[t1] = n2
|
||||
targetParent[t2] = n1
|
||||
}
|
||||
|
||||
fun part1(input: List<String>): Long {
|
||||
readCircuit(input)
|
||||
reset()
|
||||
initialStates.forEach { outputState(it.key, it.value, satisfiedNodes) }
|
||||
runCircuit()
|
||||
|
||||
return readZ()
|
||||
}
|
||||
|
||||
fun checkIt(x: Long, y: Long, sum: Long, mask: Long = -1L): Boolean {
|
||||
reset()
|
||||
setXY("x", x)
|
||||
setXY("y", y)
|
||||
return runCircuit() && (readZ() and mask) == sum
|
||||
}
|
||||
|
||||
fun countGoodBits(startbit: Int): Int {
|
||||
val inv = (1L shl (zTargets.size - 1)) - 1
|
||||
for (b in startbit..zTargets.size - 2) {
|
||||
val tv = 1L shl b
|
||||
val tvi = (1L shl (b + 1)) - 1L
|
||||
if (!(checkIt(tv, 0L, tv) &&
|
||||
checkIt(tvi, 0L, tvi) &&
|
||||
checkIt(0L, tv, tv) &&
|
||||
checkIt(0L, tvi, tvi) &&
|
||||
checkIt(tv, tv, 2 * tv) &&
|
||||
checkIt(tvi, tvi, 2 * tvi) &&
|
||||
checkIt(inv - tvi, 0L, 0L, tvi) &&
|
||||
checkIt(0L, inv - tvi, 0L, tvi)
|
||||
)
|
||||
) {
|
||||
return b
|
||||
}
|
||||
for (i in 0..(1L shl ((b - 8).coerceIn(1..6)))) {
|
||||
val rx = random.nextLong() and tvi
|
||||
val ry = random.nextLong() and tvi
|
||||
if (!checkIt(rx, ry, rx + ry, mask = tvi * 2 + 1)) return b
|
||||
}
|
||||
}
|
||||
return zTargets.size
|
||||
}
|
||||
|
||||
fun part2(input: List<String>): String {
|
||||
readCircuit(input)
|
||||
calcInvolvedNodes()
|
||||
|
||||
val goodGates = HashSet<Node>()
|
||||
|
||||
val swaps = ArrayList<Pair<String, String>>()
|
||||
|
||||
for (b in 0..zTargets.size - 3) {
|
||||
val zb0 = zInvolvedNodes["z%02d".format(b)]!!
|
||||
val zb1 = zInvolvedNodes["z%02d".format(b + 1)]!!
|
||||
val zb2 = zInvolvedNodes["z%02d".format(b + 2)]!!
|
||||
|
||||
val tv = 1L shl b
|
||||
val tvi = (1L shl (b + 1)) - 1L
|
||||
val good = checkIt(tv, 0L, tv) &&
|
||||
checkIt(tvi, 0L, tvi) &&
|
||||
checkIt(0L, tv, tv) &&
|
||||
checkIt(0L, tvi, tvi) &&
|
||||
checkIt(tv, tv, 2 * tv) &&
|
||||
checkIt(tvi, tvi, 2 * tvi)
|
||||
if (good) {
|
||||
goodGates.addAll(zb0)
|
||||
//goodGates.addAll(zb1)
|
||||
} else {
|
||||
println("Bit error at $b")
|
||||
val badList = zb0.union(zb1).union(zb2).minus(goodGates).map { it.target }.toList()
|
||||
var swapped = false
|
||||
out@ for (p1 in badList.indices) {
|
||||
for (p2 in p1 + 1..badList.lastIndex) {
|
||||
swapOutputs(badList[p1], badList[p2])
|
||||
val goodBits = countGoodBits(b)
|
||||
if (goodBits > b + 1) {
|
||||
println("**** Successfully $goodBits swapped ${badList[p1]} with ${badList[p2]}")
|
||||
swapped = true
|
||||
swaps.add(badList[p1] to badList[p2])
|
||||
break@out
|
||||
} else {
|
||||
swapOutputs(badList[p1], badList[p2])
|
||||
}
|
||||
}
|
||||
}
|
||||
if (!swapped) throw IllegalStateException("Sob!")
|
||||
calcInvolvedNodes()
|
||||
}
|
||||
}
|
||||
return swaps.flatMap { listOf(it.first, it.second) }.sorted().joinToString(",")
|
||||
}
|
||||
|
||||
// test if implementation meets criteria from the description, like:
|
||||
val testInput = inlineTestInput.trim().reader().readLines()
|
||||
val testInput2 = inlineTestInput2.trim().reader().readLines()
|
||||
//val testInput = readInput("aoc2024/Day24_test")
|
||||
val testInputPart1Result = part1(testInput)
|
||||
println("Part 1 Test: $testInputPart1Result")
|
||||
val testInputPart1Result2 = part1(testInput2)
|
||||
println("Part 1 Test 2: $testInputPart1Result2")
|
||||
// val testInputPart2Result = part2(testInput2)
|
||||
// println("Part 2 Test: $testInputPart2Result")
|
||||
check(testInputPart1Result == 4L)
|
||||
check(testInputPart1Result2 == 2024L)
|
||||
//check(testInputPart2Result == "z00,z01,z02,z05")
|
||||
|
||||
val input = readInput("aoc2024/Day24")
|
||||
part1(input).println()
|
||||
part2(input).println()
|
||||
}
|
||||
Loading…
Reference in New Issue
Block a user