95 lines
3.2 KiB
Swift
95 lines
3.2 KiB
Swift
import Foundation
|
|
|
|
typealias Op = (Bool, Bool) -> Bool
|
|
typealias Gate = (String, Op, String, String)
|
|
|
|
struct Circuit : CustomStringConvertible {
|
|
let gates: [Gate]
|
|
var nodes: [String: Bool]
|
|
var pendingEndNodes: Set<String>
|
|
var description: String {
|
|
nodes.map { "\($0): \($1 ? 1 : 0)" }.sorted().joined(separator: "\n") +
|
|
"\n\(pendingEndNodes)"
|
|
}
|
|
func value(of prefix: String) -> Int? {
|
|
if pendingEndNodes.count > 0 { return nil }
|
|
return nodes.keys.filter { $0.starts(with: prefix) }
|
|
.sorted().reversed().reduce(0) { $0 * 2 + (nodes[$1]! ? 1 : 0) }
|
|
}
|
|
mutating func run(gate: Gate) {
|
|
let (in1, op, in2, out) = gate
|
|
if let v1 = nodes[in1], let v2 = nodes[in2] {
|
|
nodes[out] = op(v1, v2)
|
|
pendingEndNodes.remove(out)
|
|
}
|
|
}
|
|
mutating func run() {
|
|
gates.forEach { run(gate: $0) }
|
|
}
|
|
}
|
|
|
|
func readInput(_ filePath: String) throws -> Circuit {
|
|
let content = try String(contentsOfFile: filePath, encoding: .ascii)
|
|
let gateRe = try Regex(#"([a-z0-9]+) (AND|OR|XOR) ([a-z0-9]+) -> ([a-z0-9]+)"#)
|
|
let opMap: [String: Op] = [
|
|
"AND": { $0 && $1 },
|
|
"OR": { $0 || $1 },
|
|
"XOR": { $0 != $1 }
|
|
]
|
|
var gates: [Gate] = []
|
|
var endNodes: Set<String> = []
|
|
for line in content.split(separator: "\n") {
|
|
if let m = line.wholeMatch(of: gateRe) {
|
|
let in1 = String(m.output[1].substring!)
|
|
let op = opMap[String(m.output[2].substring!)]!
|
|
let in2 = String(m.output[3].substring!)
|
|
let out = String(m.output[4].substring!)
|
|
gates.append((in1, op, in2, out))
|
|
if out.starts(with: "z") {
|
|
endNodes.insert(out)
|
|
}
|
|
}
|
|
}
|
|
return Circuit(gates: gates, nodes: [:], pendingEndNodes: endNodes)
|
|
}
|
|
|
|
extension Int {
|
|
func toNodes(_ prefix: String) -> [String: Bool] {
|
|
var nodes: [String: Bool] = [:]
|
|
for i in (0..<45) {
|
|
nodes[prefix + String(format: "%02d", i)] = ((self >> i) & 1) == 1
|
|
}
|
|
return nodes
|
|
}
|
|
}
|
|
|
|
var circuit = try readInput(CommandLine.arguments[1])
|
|
// generate random x y to try
|
|
let x = Int.random(in: 0..<(1<<45))
|
|
let y = Int.random(in: 0..<(1<<45))
|
|
circuit.nodes.merge(x.toNodes("x")) { l, r in l }
|
|
circuit.nodes.merge(y.toNodes("y")) { l, r in l }
|
|
// just print out the wrong bits for manual debugging. See input.dot
|
|
// print(circuit)
|
|
while true {
|
|
if let z = circuit.value(of: "z") {
|
|
print("x: " + String(x, radix: 2).reversed())
|
|
print("y: " + String(y, radix: 2).reversed())
|
|
let zStr = String(z, radix: 2).reversed()
|
|
let pStr = String(x+y, radix: 2).reversed()
|
|
let zHighlight = zip(zStr, pStr).map { dz, dp -> String in
|
|
dz == dp ? String(dz) : "\u{001B}[41m\(dz)\u{001B}[0m"
|
|
}
|
|
print("z: " + zHighlight.joined())
|
|
print("\u{001B}[4m!: \(String(pStr))\u{001B}[0m")
|
|
print(" \((0..<zStr.count).map { String($0 % 10) }.joined())")
|
|
break
|
|
}
|
|
circuit.run()
|
|
}
|
|
|
|
// use graphviz to render input.dot to svg
|
|
// run program to find out first bit that failed (highlighted in red)
|
|
// look at svg around that for irregularities (regular full adders are obvious)
|
|
// in this case z16 <-> fkb and z31 <-> rdn
|