Not getting stars here really.

Solved with the help of claude.ai

The base-26 arithmetics is a bit over my head.

Author: mfloryan

2021/24/ai.js

@@ -0,0 +1,123 @@
+// Each block's parameters
+const blocks = [
+    { divZ: 1, addX: 14, addY: 0 },    // 0
+    { divZ: 1, addX: 13, addY: 12 },   // 1
+    { divZ: 1, addX: 15, addY: 14 },   // 2
+    { divZ: 1, addX: 13, addY: 0 },    // 3
+    { divZ: 26, addX: -2, addY: 3 },   // 4
+    { divZ: 1, addX: 10, addY: 15 },   // 5
+    { divZ: 1, addX: 13, addY: 11 },   // 6
+    { divZ: 26, addX: -15, addY: 12 }, // 7
+    { divZ: 1, addX: 11, addY: 1 },    // 8
+    { divZ: 26, addX: -9, addY: 12 },  // 9
+    { divZ: 26, addX: -9, addY: 3 },   // 10
+    { divZ: 26, addX: -7, addY: 10 },  // 11
+    { divZ: 26, addX: -4, addY: 14 },  // 12
+    { divZ: 26, addX: -6, addY: 12 }   // 13
+];
+
+function findRelationships() {
+    let stack = [];
+    let relationships = [];
+    
+    for (let i = 0; i < blocks.length; i++) {
+        if (blocks[i].divZ === 1) {
+            stack.push({ pos: i, value: blocks[i].addY });
+        } else {
+            const prev = stack.pop();
+            relationships.push({
+                pos1: prev.pos,
+                pos2: i,
+                diff: prev.value + blocks[i].addX
+            });
+        }
+    }
+    return relationships;
+}
+
+function findAllValidPairs(diff) {
+    const pairs = [];
+    for (let w1 = 1; w1 <= 9; w1++) {
+        const w2 = w1 + diff;
+        if (w2 >= 1 && w2 <= 9) {
+            pairs.push([w1, w2]);
+        }
+    }
+    return pairs;
+}
+
+function* generateAllValidNumbers(relationships, currentDigits = new Array(14).fill(null), relationshipIndex = 0) {
+    if (relationshipIndex === relationships.length) {
+        // Fill in any remaining unassigned digits with 9 (for maximum) or 1 (for minimum)
+        const result = [...currentDigits];
+        for (let i = 0; i < result.length; i++) {
+            if (result[i] === null) {
+                result[i] = 9; // or 1 for minimum
+            }
+        }
+        yield result;
+        return;
+    }
+    
+    const rel = relationships[relationshipIndex];
+    const validPairs = findAllValidPairs(rel.diff);
+    
+    for (const [w1, w2] of validPairs) {
+        if ((currentDigits[rel.pos1] === null || currentDigits[rel.pos1] === w1) && 
+            (currentDigits[rel.pos2] === null || currentDigits[rel.pos2] === w2)) {
+            const nextDigits = [...currentDigits];
+            nextDigits[rel.pos1] = w1;
+            nextDigits[rel.pos2] = w2;
+            yield* generateAllValidNumbers(relationships, nextDigits, relationshipIndex + 1);
+        }
+    }
+}
+
+function verifyNumber(digits) {
+    let z = 0;
+    for (let i = 0; i < 14; i++) {
+        const w = digits[i];
+        let x = z % 26;
+        z = Math.floor(z / blocks[i].divZ);
+        x += blocks[i].addX;
+        x = (x === w) ? 0 : 1;
+        const y = (w + blocks[i].addY) * x;
+        z = z * (25 * x + 1) + y;
+    }
+    return z === 0;
+}
+
+// Find all valid numbers
+function findAllValidNumbers() {
+    const relationships = findRelationships();
+    const validNumbers = [];
+    
+    console.log('Digit relationships:');
+    relationships.forEach(rel => {
+        console.log(`digit[${rel.pos1}] + ${rel.diff} = digit[${rel.pos2}]`);
+    });
+    
+    console.log('\nSearching for valid numbers...');
+    for (const digits of generateAllValidNumbers(relationships)) {
+        if (verifyNumber(digits)) {
+            validNumbers.push([...digits]);
+        }
+    }
+    
+    // Sort numbers for better display
+    validNumbers.sort((a, b) => {
+        const numA = BigInt(a.join(''));
+        const numB = BigInt(b.join(''));
+        return numA < numB ? -1 : numA > numB ? 1 : 0;
+    });
+    
+    return validNumbers;
+}
+
+// Find and display all solutions
+const allValidNumbers = findAllValidNumbers();
+console.log(`\nFound ${allValidNumbers.length} valid numbers:`);
+console.log('Smallest:', allValidNumbers[0].join(''));
+console.log('Largest:', allValidNumbers[allValidNumbers.length - 1].join(''));
+console.log('\nAll valid numbers:');
+allValidNumbers.forEach(digits => console.log(digits.join('')));

2021/24/day24.js

@@ -0,0 +1,59 @@
+const { loadLines } = require('../input')
+let input = loadLines('24/input.txt')
+
+const instructions = {
+    'inp': (cpu, a) => cpu.var[a] = cpu.input.shift(),
+    'add': (cpu, a, b) => cpu.var[a] = cpu.var[a] + cpu.var[b],
+    'addv': (cpu, a, b) => cpu.var[a] = cpu.var[a] + b,
+    'mul': (cpu, a, b) => cpu.var[a] = cpu.var[a] * cpu.var[b],
+    'mulv': (cpu, a, b) => cpu.var[a] = cpu.var[a] * b,
+    'div': (cpu, a, b) => cpu.var[a] = Math.floor(cpu.var[a] / cpu.var[b]),
+    'divv': (cpu, a, b) => cpu.var[a] = Math.floor(cpu.var[a] / b),
+    'mod': (cpu, a, b) => cpu.var[a] = cpu.var[a] % cpu.var[b],
+    'modv': (cpu, a, b) => cpu.var[a] = cpu.var[a] % b,
+    'eql': (cpu, a, b) => cpu.var[a] = cpu.var[a] == cpu.var[b] ? 1 : 0,
+    'eqlv': (cpu, a, b) => cpu.var[a] = cpu.var[a] == b ? 1 : 0,
+}
+
+function parseCode(line) {
+    let ops = line.split(' ')
+    let instruction = ops.shift()
+    if (ops.length == 1) {
+        return (cpu) => instructions[instruction](cpu, ops[0])
+    } else {
+        let value = parseInt(ops[1])
+        if (isNaN(value)) {
+            return (cpu) => instructions[instruction](cpu, ops[0], ops[1])
+        } else {
+            return (cpu) => instructions[instruction+'v'](cpu, ops[0], value)
+        }
+    }
+}
+
+function runCode(code, input) {
+    let cpu = {
+        var: {
+            w: 0,
+            x: 0,
+            y: 0,
+            z: 0
+        },
+        input: [...input]
+    }
+
+    for (op of code) {
+        op(cpu)
+    }
+
+    return cpu
+}
+
+let code = input.map(l => parseCode(l))
+
+console.log(
+    runCode(code, [7,1,1,3,1,1,5,1,9,1,7,8,9,1]).var.z
+)
+
+console.log(
+    runCode(code, [9,1,2,9,7,3,9,5,9,1,9,9,9,3]).var.z
+)