From fe5a92fb37641c05600cb4033c2af805543e9948 Mon Sep 17 00:00:00 2001
From: Yanick Champoux <yanick@babyl.ca>
Date: Wed, 8 Dec 2021 12:50:53 -0500
Subject: [PATCH] refactor

---
 2021/08/part2.mjs | 131 +++++++++++++++++++---------------------------
 2021/08/test.mjs  |   2 +-
 2 files changed, 54 insertions(+), 79 deletions(-)

diff --git a/2021/08/part2.mjs b/2021/08/part2.mjs
index 728d567..97cac62 100644
--- a/2021/08/part2.mjs
+++ b/2021/08/part2.mjs
@@ -2,121 +2,96 @@ import fs from "fs-extra";
 import fp from "lodash/fp.js";
 import _ from "lodash";
 
-import * as p1 from './part1.mjs';
+import * as p1 from "./part1.mjs";
 
 function decodedDigits(mapping) {
-            const s = fp.invert(mapping);
-            let solution = fp.invert(p1.digits);
-            solution = fp.mapKeys(
-                k => k.split('').map(
-                    l => s[l]
-                ).join('')
-                ,solution );
+    const s = fp.invert(mapping);
+    let solution = fp.invert(p1.digits);
+    solution = fp.mapKeys(
+        (k) =>
+            k
+                .split("")
+                .map((l) => s[l])
+                .join(""),
+        solution
+    );
 
-            solution = fp.mapKeys( k => { k = k.split('').sort().join(''); return k }, solution );
+    solution = fp.mapKeys((k) => {
+        k = k.split("").sort().join("");
+        return k;
+    }, solution);
 
-            return solution;
+    return solution;
 }
 
-function guess(unknowns,guessed={},inputs) {
-    console.log({unknowns,guessed});
+function guess(unknowns, guessed = {}, inputs) {
+    const [next] = Object.keys(unknowns);
 
-    const [ next ] = Object.keys(unknowns);
+    if (!next) return guessed;
 
-    if(!next) return guessed;
+    if (unknowns[next].size === 0) return;
 
-
-    if(unknowns[next].size === 0) return;
-
-
-    for ( const p of unknowns[next].values() ) {
+    for (const p of unknowns[next].values()) {
         let newUnknowns = fp.omit(next, unknowns);
-        newUnknowns = fp.mapValues(
-            s => {
-                const x = new Set(s.values());
-                x.delete(p);
-                return x;
-            }, newUnknowns );
+        newUnknowns = fp.mapValues((s) => {
+            const x = new Set(s.values());
+            x.delete(p);
+            return x;
+        }, newUnknowns);
 
-            //console.log({ newUnknowns })
-        if(
-            Object.values(newUnknowns).some( s => s.size === 0 )
-        ) continue;
+        if (Object.values(newUnknowns).some((s) => s.size === 0)) continue;
 
-        const r = guess( newUnknowns, { ...guessed, [next]: p }, inputs );
-        if(r) {
-            const s = fp.invert(r);
-            let solution = fp.invert(p1.digits);
-            solution = fp.mapKeys(
-                k => k.split('').map(
-                    l => s[l]
-                ).join('')
-                ,solution );
+        const r = guess(newUnknowns, { ...guessed, [next]: p }, inputs);
 
-            solution = fp.mapKeys( k => { k = k.split('').sort().join(''); return k }, solution );
+        if (r) {
+            const solution = decodedDigits(r);
 
-            console.log({r, solution });
-            console.log({inputs})
-
-            if( inputs.some( i => ! solution.hasOwnProperty(i.join(''))  ) ) {
-                console.log("Oh noes");
-            } else {
-                console.log("Oh yea");
+            if (inputs.every((i) => solution.hasOwnProperty(i.join("")))) {
                 return r;
             }
-
         }
     }
 }
 
 export function findMapping(input) {
-    const values = 'abcdefg'.split('');
+    const values = "abcdefg".split("");
 
-    const possibility = Object.fromEntries(values.map(
-        v => [ v, new Set(values) ]
-    ));
+    const possibility = Object.fromEntries(
+        values.map((v) => [v, new Set(values)])
+    );
 
-    for ( const seq of input ) {
-        const p = Object.values(p1.digits).filter(
-            d => d.length === seq.length
-        ).join('').split('');
+    for (const seq of input) {
+        const p = Object.values(p1.digits)
+            .filter((d) => d.length === seq.length)
+            .join("")
+            .split("");
 
-        for( const l of seq ) {
-                possibility[l] = new Set(
-                    p.filter( x => possibility[l].has(x) )
-                );
+        for (const l of seq) {
+            possibility[l] = new Set(p.filter((x) => possibility[l].has(x)));
         }
-       // console.log(possibility);
     }
 
+    const one = input.find((i) => i.length === 2);
+    const seven = input.find((i) => i.length === 3);
+    const [a] = seven.filter((x) => !one.includes(x));
 
-
-    const one   = input.find( i => i.length === 2 );
-    const seven = input.find( i => i.length === 3 );
-    const [a] = seven.filter( x => !one.includes(x) );
-
-    for( const l of Object.values(possibility) ) {
-        l.delete('a');
+    for (const l of Object.values(possibility)) {
+        l.delete("a");
     }
 
-    possibility[a] = new Set(['a']);
-    console.log(possibility);
+    possibility[a] = new Set(["a"]);
 
-    return guess(possibility,{},input);
+    return guess(possibility, {}, input);
 }
 
-export function decodedOutput({input,output}) {
-    const mapping = findMapping([...input,...output]);
+export function decodedOutput({ input, output }) {
+    const mapping = findMapping([...input, ...output]);
 
     const digits = decodedDigits(mapping);
 
-    console.log({ digits, output });
-
-    return parseInt(output.map( e => digits[e.join('')] ).join(''));
+    return parseInt(output.map((e) => digits[e.join("")]).join(""));
 }
 
 export function solution(input) {
-
-    return _.sum( input.map( decodedOutput ) );
-
+    return _.sum(input.map(decodedOutput));
 }
diff --git a/2021/08/test.mjs b/2021/08/test.mjs
index 30cc8f7..9c5fc8b 100644
--- a/2021/08/test.mjs
+++ b/2021/08/test.mjs
@@ -12,7 +12,7 @@ const input = fs.readFile("input", "utf8").then(p1.processInput);
 
 tap.test("part1", async (t) => {
     t.equal(p1.solution(await sample), 26);
-    t.equal(p1.solution(await input), 26);
+    t.equal(p1.solution(await input), 375);
 });
 
 tap.test("part2", async (t) => {