solve Day19 in JS

Day19/js/solution.js

@@ -0,0 +1,111 @@
+const fs = require('fs');
+
+/**
+ * Parses the input file to create workflows.
+ * @param {string} filePath Path to the input file.
+ * @returns {Object} Parsed workflows.
+ */
+function parseInput(filePath) {
+    const content = fs.readFileSync(filePath, 'utf8');
+    const lines = content.split('\n').filter(line => line.trim());
+
+    const workflows = {};
+    lines.forEach(line => {
+        const [name, rulesStr] = line.split('{');
+        const rules = rulesStr.slice(0, -1).split(',');
+        const fallback = rules.pop();
+
+        workflows[name] = {
+            rules: rules.map(rule => {
+                const [condition, target] = rule.split(':');
+                const [key, comparison, ...value] = condition.split('');
+                return { key, comparison, value: parseInt(value.join('')), target };
+            }),
+            fallback
+        };
+    });
+
+    return workflows;
+}
+
+/**
+ * Recursively counts the number of valid ranges.
+ * @param {Object} workflows Workflows object.
+ * @param {Object} ranges Current ranges of ratings.
+ * @param {string} name Current workflow name.
+ * @returns {number} Count of valid ranges.
+ */
+function countRanges(workflows, ranges, name = 'in') {
+    if (name === 'R') return 0;
+    if (name === 'A') return Object.values(ranges).reduce((acc, [start, stop]) => acc * (stop - start + 1), 1);
+
+    const { rules, fallback } = workflows[name];
+    let total = 0;
+
+    for (const { key, comparison, value, target } of rules) {
+        const [start, stop] = ranges[key];
+        let tStart, tStop, fStart, fStop;
+
+        if (comparison === '<') {
+            tStart = start;
+            tStop = value - 1;
+            fStart = value;
+            fStop = stop;
+        } else {
+            tStart = value + 1;
+            tStop = stop;
+            fStart = start;
+            fStop = value;
+        }
+
+        if (tStart <= tStop) {
+            const newRanges = { ...ranges, [key]: [tStart, tStop] };
+            total += countRanges(workflows, newRanges, target);
+        }
+
+        if (fStart <= fStop) {
+            ranges[key] = [fStart, fStop];
+        } else {
+            break;
+        }
+    }
+
+    if (total === 0) total += countRanges(workflows, ranges, fallback);
+
+    return total;
+}
+
+/**
+ * Test the algorithm with a test file.
+ * @param {string} testFile Path to the test file.
+ * @param {number} expected Expected result.
+ */
+function testAlgorithm(testFile, expected) {
+    const workflows = parseInput(testFile);
+    const result = countRanges(workflows, { x: [1, 4000], m: [1, 4000], a: [1, 4000], s: [1, 4000] });
+    console.assert(result === expected, `Test failed: Expected ${expected}, got ${result}`);
+    console.log("Test passed successfully.");
+}
+
+/**
+ * Main function to execute the algorithm.
+ */
+function main() {
+    try {
+        const testFile = "../test.txt";
+        const expectedTestResult = 167409079868000;
+        console.log("Running test...");
+        testAlgorithm(testFile, expectedTestResult);
+
+        console.log("Test passed. Running on actual input...");
+        const inputFile = "../input.txt";
+        const workflows = parseInput(inputFile);
+        const result = countRanges(workflows, { x: [1, 4000], m: [1, 4000], a: [1, 4000], s: [1, 4000] });
+        console.log(`Result for the puzzle input: ${result}`);
+    } catch (error) {
+        console.error(`Unexpected error: ${error}`);
+        process.exit(1);
+    }
+}
+
+main();