From a265489084dd41fcabe6c9b73b2574675d46820c Mon Sep 17 00:00:00 2001 From: amclin Date: Wed, 15 Dec 2021 06:24:04 +0000 Subject: [PATCH 1/9] docs: Update badges [skip ci] --- README.md | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/README.md b/README.md index 279f0ef..ea8e34b 100644 --- a/README.md +++ b/README.md @@ -5,9 +5,9 @@ ## Status ### 2021 -![](https://img.shields.io/badge/day%20📅-14-blue) -![](https://img.shields.io/badge/stars%20⭐-6-yellow) -![](https://img.shields.io/badge/days%20completed-3-red) +![](https://img.shields.io/badge/day%20📅-15-blue) +![](https://img.shields.io/badge/stars%20⭐-14-yellow) +![](https://img.shields.io/badge/days%20completed-7-red) ## Start a boilerplate for a new day `npm run new` From 556767c6fc55f9f13aabd919cab62cd83ecd1fd7 Mon Sep 17 00:00:00 2001 From: amclin Date: Thu, 16 Dec 2021 06:25:01 +0000 Subject: [PATCH 2/9] docs: Update badges [skip ci] --- README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.md b/README.md index ea8e34b..4e9b7e7 100644 --- a/README.md +++ b/README.md @@ -5,7 +5,7 @@ ## Status ### 2021 -![](https://img.shields.io/badge/day%20📅-15-blue) +![](https://img.shields.io/badge/day%20📅-16-blue) ![](https://img.shields.io/badge/stars%20⭐-14-yellow) ![](https://img.shields.io/badge/days%20completed-7-red) From a6c49eb728d15510aac26a50c752406605bfa6db Mon Sep 17 00:00:00 2001 From: Anthony McLin Date: Wed, 15 Dec 2021 16:00:06 -0800 Subject: [PATCH 3/9] feat(2021-day-08): descramble seven-segment-signal codes --- 2021/day-08/display.js | 450 ++++++++++++++++++++++++++++++++++++ 2021/day-08/display.test.js | 28 +++ 2021/day-08/index.js | 3 + 2021/day-08/input.txt | 0 2021/day-08/solution.js | 35 +++ 5 files changed, 516 insertions(+) create mode 100644 2021/day-08/display.js create mode 100644 2021/day-08/display.test.js create mode 100644 2021/day-08/index.js create mode 100644 2021/day-08/input.txt create mode 100644 2021/day-08/solution.js diff --git a/2021/day-08/display.js b/2021/day-08/display.js new file mode 100644 index 0000000..678bac9 --- /dev/null +++ b/2021/day-08/display.js @@ -0,0 +1,450 @@ +// const renderDigit = (num) => { +// const topper = ` ${num}: ` +// const patterns = [ +// 'abcefg', +// 'cf', +// 'acdeg', +// 'acdfg', +// 'bcdf', +// 'abdfg', +// 'abdefg', +// 'acf', +// 'abcdefg', +// 'abcdfg' +// ] +// const template = ` +// aaaa +// b c +// b c +// dddd +// e f +// e f +// gggg +// ` + +// const out = template +// patterns[8].forEach((segment) => { +// if(patterns[num].indexOf(segment) >= -1 +// }) +// } + +const alphabetical = (a, b) => a - b + +/** + * Takes a string of scrambled codes and deduces which codes correspond + * to which bit in a Seven Segment Display. Order of codes is irrelevant, as + * is order of characters within each code. Resulting order of segments + * is mapped to the standard order as described in + * https://en.wikipedia.org/wiki/Seven-segment_display + */ +const descrambleSignal = (data) => { + console.debug('2021-day-08 descrambleSignal()') + + const scrambledCodes = data.split(' ') + .map((code) => code.split('').sort(alphabetical)) // Convert each code to alphabetized arrays + const segmentCodes = Array(7) // For caching the identified segment codes as we find them + const sortedCodes = Array(10) // For caching the identified number codes as we find them + + const numCached = (num) => { + return ( + typeof sortedCodes[num] === typeof [] && + sortedCodes[num].length >= 1 + ) + } + const segCached = (num) => { + return ( + typeof segmentCodes[num] === typeof '' && + segmentCodes[num].length === 1 + ) + } + + // #0 is one of 3 6-character numbers + // Can be found if the other 2 are already identified + const findNum0 = (number6, number9) => { + if (numCached(0)) { + return sortedCodes[0] + } + + sortedCodes[0] = scrambledCodes + .filter((code) => code.length === 6) // Find 6-character codes + .filter((code) => !(JSON.stringify(code) === JSON.stringify(number6))) // remove #5 + .filter((code) => !(JSON.stringify(code) === JSON.stringify(number9)))[0] // remove #9 + + console.debug('Found #0') + return sortedCodes[0] + } + + // #1 is the only 2-character code + const findNum1 = () => { + if (numCached(1)) { + return sortedCodes[1] + } + + sortedCodes[1] = scrambledCodes + .filter((code) => code.length === 2)[0] + + console.debug('Found #1') + return sortedCodes[1] + } + + // #2 is one of 3 5-character numbers + // Can be found if the other two are already identified + const findNum2 = (number3, number5) => { + if (numCached(2)) { + return sortedCodes[2] + } + + sortedCodes[2] = scrambledCodes + .filter((code) => code.length === 5) // Find 5-character codes + .filter((code) => !(JSON.stringify(code) === JSON.stringify(number3))) // remove #3 + .filter((code) => !(JSON.stringify(code) === JSON.stringify(number5)))[0] // remove #5 + + console.debug('Found #2') + return sortedCodes[2] + } + + // #3 is one of 3 5-character codes + // It is the only one that contains BOTH segments of #1 + const findNum3 = (number1) => { + if (numCached(3)) { + return sortedCodes[3] + } + + sortedCodes[3] = scrambledCodes + .filter((code) => code.length === 5) // Find 5-character codes + .filter((code) => { + // Remove codes that don't include both segments of #1 + return code.filter((letter) => !number1.includes(letter)).length === 0 + })[0] + + console.debug('Found #3') + return sortedCodes[3] + } + + // #4 is the only 4-character code + const findNum4 = () => { + if (numCached(4)) { + return sortedCodes[4] + } + + sortedCodes[4] = scrambledCodes + .filter((code) => code.length === 4)[0] + + console.debug('Found #4') + return sortedCodes[4] + } + + // #5 is one of 3 5-character codes + // It is the only one that does not contain Segment 1 + const findNum5 = (segment1) => { + if (numCached(5)) { + return sortedCodes[5] + } + + sortedCodes[5] = scrambledCodes + .filter((code) => code.length === 5) // Find 5-character codes + .filter((code) => !code.includes(segment1))[0] // Filter out codes containing Seg1 + + console.debug('Found #5') + return sortedCodes[5] + } + + // #6 is one of 3 6-character codes + // It is the only one that does NOT contain both segments of #1 + const findNum6 = (number1) => { + if (numCached(6)) { + return sortedCodes[6] + } + + sortedCodes[6] = scrambledCodes + .filter((code) => code.length === 6) // Find 6-character codes + .filter((code) => { + // Remove codes that include both segments of #1 + return !( + code.includes(number1[0]) && + code.includes(number1[1]) + ) + // return ( + // code.filter((letter) => !number1.includes(letter)).length > 0 + // ) + })[0] + + console.debug('Found #6') + return sortedCodes[6] + } + + // #7 is the only three-character code + const findNum7 = () => { + if (numCached(7)) { + return sortedCodes[7] + } + + sortedCodes[7] = scrambledCodes + .filter((code) => code.length === 3)[0] + + console.debug('Found #7') + return sortedCodes[7] + } + + // #8 is the only 7-character code + const findNum8 = () => { + if (numCached(8)) { + return sortedCodes[8] + } + + sortedCodes[8] = scrambledCodes + .filter((code) => code.length === 7)[0] + + console.debug('Found #8') + return sortedCodes[8] + } + + // #9 is one of 3 6-segment numbers + // It is the only one that does not contain segment 4 + const findNum9 = (segment4) => { + if (numCached(9)) { + return sortedCodes[9] + } + + sortedCodes[9] = scrambledCodes + .filter((code) => code.length === 6) // Find 6-character codes + .filter((code) => !code.includes(segment4))[0] // Filter out codes containing Seg4 + + console.debug('Found #9') + return sortedCodes[9] + } + + // Segment 0 is the letter in #7 but not #1 + const findSeg0 = (number1, number7) => { + if (!segCached(0)) { + segmentCodes[0] = number7.filter((letter) => !number1.includes(letter))[0] + console.debug('Found segment 0') + } + + return segmentCodes[0] + } + + // Segment 1 is the letter in #1 that is not in #6 + const findSeg1 = (number1, number6) => { + if (!segCached(1)) { + segmentCodes[1] = number1.filter((letter) => !number6.includes(letter))[0] + console.debug('Found segment 1') + } + + return segmentCodes[1] + } + + // Segment 2 is the letter in #1 that is not segment 1 + const findSeg2 = (number1, segment1) => { + if (!segCached(2)) { + segmentCodes[2] = number1.filter((letter) => letter !== segment1)[0] + console.debug('Found segment 2') + } + + return segmentCodes[2] + } + + // Segment 3 is the letter remaining if all other segments are removed from #8 + // WARNING - only works if all 6 other segments are present + const findSeg3 = (number8, segmentCodes) => { + if (segCached(3)) { + return segmentCodes[3] + } + + // validate other segments are present + for (let x = 0; x < 7; x++) { + if (x !== 3 && segmentCodes[x].length !== 1) { + throw new Error(`segmentCodes[${x}] appears to be invalid: ${segmentCodes[x]}`) + } + } + + segmentCodes[3] = number8 + .filter((letter) => !segmentCodes.includes(letter))[0] // remove existing segments + console.debug('Found segment 3') + + return segmentCodes[3] + } + + // Segment 4 is the letter remaining if #5 and #1 are removed from #8 + const findSeg4 = (number1, number5, number8) => { + if (!segCached(4)) { + segmentCodes[4] = number8 + .filter((letter) => !number5.includes(letter)) // remove #5 + .filter((letter) => !number1.includes(letter))[0] // remove #1 + console.debug('Found segment 4') + } + + return segmentCodes[4] + } + + // Segment 5 is the letter remaining if #2 and #1 are removed from #8 + const findSeg5 = (number1, number2, number8) => { + if (!segCached(5)) { + segmentCodes[5] = number8 + .filter((letter) => !number2.includes(letter)) // remove #2 + .filter((letter) => !number1.includes(letter))[0] // remove #1 + console.debug('Found segment 5') + } + + return segmentCodes[5] + } + + // Segement 6 is the letter remaining if #0 is removed from #8 + const findSeg6 = (number0, number8) => { + if (!segCached(6)) { + segmentCodes[6] = number8 + .filter((letter) => !number0.includes(letter))[0] // remove #0 + console.debug('Found segment 6') + } + + return segmentCodes[6] + } + + // Descramble the codes to identify each number. Order matters because of dependencies + // findNum0() deferred after 9 + // findNum1() + // // findNum2() deferred after #3, #5, and Seg6 + // findNum3( + // findNum1() + // ) + // findNum4() + // findNum5( + // findSeg1() + // ) + + // findNum6( + // findNum1() + // ) + // findNum7() + // findNum8() + // findNum9( + // findSeg4( + // findNum1(), + // findNum5( + // findSeg1() + // ), + // findNum8() + // ) + // ) + // findNum0( // #0 out of order + // findNum6( + // findNum1() + // ), + // findNum9( + // findSeg4( + // findNum1(), + // findNum5( + // findSeg1( + // findNum1(), + // findNum6( + // findNum1() + // ) + // ) + // ), + // findNum8() + // ) + // ) + // ) + // findNum2( // #2 out of order + // findNum3( + // findNum1() + // ), + // findNum5( + // findSeg1() + // ) + // ) + + // #4 is the only number we need that doesn't come from identifying segments + findNum4() + + // Find the codes for each segment + findSeg0( + findNum1(), + findNum7() + ) + + console.debug(segmentCodes) + + findSeg1( + findNum1(), + findNum6( + findNum1() + ) + ) + + console.debug(segmentCodes) + + findSeg2( + findNum1(), + findSeg1( + findNum1(), + findNum6( + findNum1() + ) + ) + ) + + console.debug(segmentCodes) + + // findSeg3 is moved to last because it depends on finding all other segments first + + findSeg4( + findNum1(), + findNum5( + findSeg1() + ), + findNum8() + ) + + console.debug(segmentCodes) + + findSeg5( + findNum1(), + findNum2( + findNum3( + findNum1() + ), + findNum5( + findSeg1() + ) + ), + findNum8() + ) + + console.debug(segmentCodes) + + findSeg6( + findNum0( + findNum6( + findNum1() + ), + findNum9( + findSeg4( + findNum1(), + findNum5( + findSeg1() + ), + findNum8() + ) + ) + ), + findNum8() + ) + + console.debug(segmentCodes) + + findSeg3( + findNum8(), + segmentCodes + ) + + console.debug(segmentCodes) + + return { + segmentCodes + } +} + +module.exports = { + descrambleSignal +} diff --git a/2021/day-08/display.test.js b/2021/day-08/display.test.js new file mode 100644 index 0000000..d4d11e3 --- /dev/null +++ b/2021/day-08/display.test.js @@ -0,0 +1,28 @@ +/* eslint-env mocha */ +const { expect } = require('chai') +const { descrambleSignal } = require('./display') + +const testSingle = `acedgfb cdfbe gcdfa fbcad dab cefabd cdfgeb eafb cagedb ab | +cdfeb fcadb cdfeb cdbaf` + +console.debug( + testSingle.split('|')[0].trim() + .split(' ').map( + (code) => code.split('') + .sort((a, b) => a - b) + ).sort((a, b) => a.length - b.length) +) + +describe('--- Day 8: Seven Segment Search ---', () => { + describe('Part 1', () => { + describe('descrambleSignal()', () => { + const testData = testSingle.split('|')[0].trim() + const result = descrambleSignal(testData).segmentCodes + + it('takes scambled string of 10 codes and identifies the letters matching each seven-digit-display segment', () => { + expect(result.length).to.equal(7) + expect(result.filter((code) => !['a', 'b', 'c', 'd', 'e', 'f', 'g'].includes(code)).length).to.equal(0) + }) + }) + }) +}) diff --git a/2021/day-08/index.js b/2021/day-08/index.js new file mode 100644 index 0000000..af7e035 --- /dev/null +++ b/2021/day-08/index.js @@ -0,0 +1,3 @@ +// eslint-disable-next-line no-unused-vars +const console = require('../helpers') +require('./solution') diff --git a/2021/day-08/input.txt b/2021/day-08/input.txt new file mode 100644 index 0000000..e69de29 diff --git a/2021/day-08/solution.js b/2021/day-08/solution.js new file mode 100644 index 0000000..779f7ea --- /dev/null +++ b/2021/day-08/solution.js @@ -0,0 +1,35 @@ +const fs = require('fs') +const path = require('path') +const filePath = path.join(__dirname, 'input.txt') +const { inputToArray } = require('../../2018/inputParser') + +fs.readFile(filePath, { encoding: 'utf8' }, (err, initData) => { + if (err) throw err + + initData = inputToArray(initData.trim()) + + const resetInput = () => { + // Deep copy to ensure we aren't mutating the original data + return JSON.parse(JSON.stringify(initData)) + } + + const part1 = () => { + const data = resetInput() + console.debug(data) + return 'No answer yet' + } + + const part2 = () => { + const data = resetInput() + console.debug(data) + return 'No answer yet' + } + const answers = [] + answers.push(part1()) + answers.push(part2()) + + answers.forEach((ans, idx) => { + console.info(`-- Part ${idx + 1} --`) + console.info(`Answer: ${ans}`) + }) +}) From 5ad79525148183b99f22c8294ad05411836bb1b8 Mon Sep 17 00:00:00 2001 From: Anthony McLin Date: Thu, 16 Dec 2021 08:47:46 -0800 Subject: [PATCH 4/9] feat: add `npm start` command --- README.md | 7 ++++++- package.json | 3 ++- 2 files changed, 8 insertions(+), 2 deletions(-) diff --git a/README.md b/README.md index 279f0ef..3031ef3 100644 --- a/README.md +++ b/README.md @@ -9,7 +9,12 @@ ![](https://img.shields.io/badge/stars%20⭐-6-yellow) ![](https://img.shields.io/badge/days%20completed-3-red) -## Start a boilerplate for a new day +## Run the currently configured default day +`npm start` + +### Run in debug mode for extended logging +`DEBUG=1 npm start` +## Generate a boilerplate for a new day `npm run new` ### Special Instructions Run by modifying `index.js` to point to the puzzle you want to execute. diff --git a/package.json b/package.json index aa60ef3..c214314 100644 --- a/package.json +++ b/package.json @@ -10,7 +10,8 @@ "posttest": "nyc report --reporter=html --reporter=text-lcov > coverage.lcov", "lint": "standard", "report-coverage": "codecov", - "new": "npx plop --plopfile ./plop-templates/plopfile.js" + "new": "npx plop --plopfile ./plop-templates/plopfile.js", + "start": "node ./index.js" }, "repository": { "type": "git", From 156ca8edc1cec6ca4893a592708b83042b645dee Mon Sep 17 00:00:00 2001 From: Anthony McLin Date: Thu, 16 Dec 2021 09:35:47 -0800 Subject: [PATCH 5/9] fix(2021-day-08): descrambled display codes weren't properly alphabatized --- 2021/day-08/display.js | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/2021/day-08/display.js b/2021/day-08/display.js index 678bac9..dd45af4 100644 --- a/2021/day-08/display.js +++ b/2021/day-08/display.js @@ -28,7 +28,6 @@ // }) // } -const alphabetical = (a, b) => a - b /** * Takes a string of scrambled codes and deduces which codes correspond @@ -41,7 +40,7 @@ const descrambleSignal = (data) => { console.debug('2021-day-08 descrambleSignal()') const scrambledCodes = data.split(' ') - .map((code) => code.split('').sort(alphabetical)) // Convert each code to alphabetized arrays + .map((code) => code.split('').sort()) // Convert each code to alphabetized arrays const segmentCodes = Array(7) // For caching the identified segment codes as we find them const sortedCodes = Array(10) // For caching the identified number codes as we find them From 17a6552e10c2ad418eb1d9b870d52877f2c21596 Mon Sep 17 00:00:00 2001 From: Anthony McLin Date: Thu, 16 Dec 2021 10:17:14 -0800 Subject: [PATCH 6/9] fix(2021-day-08): the number 3 was not always descrambled --- 2021/day-08/display.js | 10 +++++++++- 1 file changed, 9 insertions(+), 1 deletion(-) diff --git a/2021/day-08/display.js b/2021/day-08/display.js index dd45af4..9d2a748 100644 --- a/2021/day-08/display.js +++ b/2021/day-08/display.js @@ -113,7 +113,7 @@ const descrambleSignal = (data) => { .filter((code) => code.length === 5) // Find 5-character codes .filter((code) => { // Remove codes that don't include both segments of #1 - return code.filter((letter) => !number1.includes(letter)).length === 0 + return code.filter((letter) => !number1.includes(letter)).length === 3 })[0] console.debug('Found #3') @@ -354,9 +354,11 @@ const descrambleSignal = (data) => { // ) // #4 is the only number we need that doesn't come from identifying segments + console.debug('Find #4') findNum4() // Find the codes for each segment + console.debug('Find segment 0') findSeg0( findNum1(), findNum7() @@ -364,6 +366,7 @@ const descrambleSignal = (data) => { console.debug(segmentCodes) + console.debug('Find segment 1') findSeg1( findNum1(), findNum6( @@ -373,6 +376,7 @@ const descrambleSignal = (data) => { console.debug(segmentCodes) + console.debug('Find segment 2') findSeg2( findNum1(), findSeg1( @@ -387,6 +391,7 @@ const descrambleSignal = (data) => { // findSeg3 is moved to last because it depends on finding all other segments first + console.debug('Find segment 4') findSeg4( findNum1(), findNum5( @@ -397,6 +402,7 @@ const descrambleSignal = (data) => { console.debug(segmentCodes) + console.debug('Find segment 5') findSeg5( findNum1(), findNum2( @@ -412,6 +418,7 @@ const descrambleSignal = (data) => { console.debug(segmentCodes) + console.debug('Find segment 6') findSeg6( findNum0( findNum6( @@ -432,6 +439,7 @@ const descrambleSignal = (data) => { console.debug(segmentCodes) + console.debug('Find segment 3') findSeg3( findNum8(), segmentCodes From 17cc8f7749015bcb74ca68d366956b631ebc7244 Mon Sep 17 00:00:00 2001 From: Anthony McLin Date: Thu, 16 Dec 2021 10:44:01 -0800 Subject: [PATCH 7/9] feat(2021-day-08): generate codes for each possible number --- 2021/day-08/display.js | 3 ++- 2021/day-08/display.test.js | 17 ++++++++++++----- 2 files changed, 14 insertions(+), 6 deletions(-) diff --git a/2021/day-08/display.js b/2021/day-08/display.js index 9d2a748..c3bf1cc 100644 --- a/2021/day-08/display.js +++ b/2021/day-08/display.js @@ -448,7 +448,8 @@ const descrambleSignal = (data) => { console.debug(segmentCodes) return { - segmentCodes + segmentCodes, + charCodes: sortedCodes } } diff --git a/2021/day-08/display.test.js b/2021/day-08/display.test.js index d4d11e3..00dd3ec 100644 --- a/2021/day-08/display.test.js +++ b/2021/day-08/display.test.js @@ -2,8 +2,7 @@ const { expect } = require('chai') const { descrambleSignal } = require('./display') -const testSingle = `acedgfb cdfbe gcdfa fbcad dab cefabd cdfgeb eafb cagedb ab | -cdfeb fcadb cdfeb cdbaf` +const testSingle = 'acedgfb cdfbe gcdfa fbcad dab cefabd cdfgeb eafb cagedb ab | cdfeb fcadb cdfeb cdbaf' console.debug( testSingle.split('|')[0].trim() @@ -17,11 +16,19 @@ describe('--- Day 8: Seven Segment Search ---', () => { describe('Part 1', () => { describe('descrambleSignal()', () => { const testData = testSingle.split('|')[0].trim() - const result = descrambleSignal(testData).segmentCodes + const { segmentCodes, charCodes } = descrambleSignal(testData) it('takes scambled string of 10 codes and identifies the letters matching each seven-digit-display segment', () => { - expect(result.length).to.equal(7) - expect(result.filter((code) => !['a', 'b', 'c', 'd', 'e', 'f', 'g'].includes(code)).length).to.equal(0) + expect(segmentCodes.length).to.equal(7) + expect(segmentCodes.filter((code) => !['a', 'b', 'c', 'd', 'e', 'f', 'g'].includes(code)).length).to.equal(0) + }) + + it('produces a list of character codes for each number that can be displayed', () => { + // There should be exactly 10 numbers + expect(charCodes.length).to.equal(10) + // lengths of each code is predictable as each number has a specific count of segments + const expectedLengths = [6, 2, 5, 5, 4, 5, 6, 3, 7, 6] + expect(charCodes.map(code => code.length)).to.deep.equal(expectedLengths) }) }) }) From 84894e9c4fea07461f51cc5667dc9b15e5e726cc Mon Sep 17 00:00:00 2001 From: Anthony McLin Date: Thu, 16 Dec 2021 11:09:08 -0800 Subject: [PATCH 8/9] feat(2021-day-08): count occurrences of numbers 1,4,7,8 in scrambled signals solves part 1 --- 2021/day-08/display.js | 31 ++++++++++++++++++++++++++ 2021/day-08/display.test.js | 43 ++++++++++++++++++++++++++++++++++++- 2021/day-08/solution.js | 26 +++++++++++++++++----- index.js | 2 +- 4 files changed, 95 insertions(+), 7 deletions(-) diff --git a/2021/day-08/display.js b/2021/day-08/display.js index c3bf1cc..ebe84d8 100644 --- a/2021/day-08/display.js +++ b/2021/day-08/display.js @@ -28,6 +28,36 @@ // }) // } +/** + * Using a map of character codes, decode a signal + * @param {array} charCodes + * @param {string} signal + */ +const decodeSignal = (charCodes, signal) => { + console.debug('2021-day-08 decodeSignal()') + + const digits = signal.split(' ') + .map( + (code) => { + const clean = code.split('').sort() // cleanup format to match expected map of codes + const matches = charCodes.filter((c) => { + // sort here on the charCode is just in case non-alphabatized data is provided + return (JSON.stringify(c.sort()) === JSON.stringify(clean)) + }) + if (matches.length < 1) { + throw new Error(`No match found for ${code} when cleaned up to ${clean}`) + } + if (matches.length > 1) { + throw new Error(`Too many matches for ${code} when cleaned up to ${clean}. This most likely indicates a bad list of character codes.`) + } + + // The key in charCodes for the match is the decoded number we want + return charCodes.indexOf(matches[0]) + } + ) + + return digits +} /** * Takes a string of scrambled codes and deduces which codes correspond @@ -454,5 +484,6 @@ const descrambleSignal = (data) => { } module.exports = { + decodeSignal, descrambleSignal } diff --git a/2021/day-08/display.test.js b/2021/day-08/display.test.js index 00dd3ec..87d6660 100644 --- a/2021/day-08/display.test.js +++ b/2021/day-08/display.test.js @@ -1,9 +1,20 @@ /* eslint-env mocha */ const { expect } = require('chai') -const { descrambleSignal } = require('./display') +const { descrambleSignal, decodeSignal } = require('./display') const testSingle = 'acedgfb cdfbe gcdfa fbcad dab cefabd cdfgeb eafb cagedb ab | cdfeb fcadb cdfeb cdbaf' +const testMultiple = `be cfbegad cbdgef fgaecd cgeb fdcge agebfd fecdb fabcd edb | fdgacbe cefdb cefbgd gcbe +edbfga begcd cbg gc gcadebf fbgde acbgfd abcde gfcbed gfec | fcgedb cgb dgebacf gc +fgaebd cg bdaec gdafb agbcfd gdcbef bgcad gfac gcb cdgabef | cg cg fdcagb cbg +fbegcd cbd adcefb dageb afcb bc aefdc ecdab fgdeca fcdbega | efabcd cedba gadfec cb +aecbfdg fbg gf bafeg dbefa fcge gcbea fcaegb dgceab fcbdga | gecf egdcabf bgf bfgea +fgeab ca afcebg bdacfeg cfaedg gcfdb baec bfadeg bafgc acf | gebdcfa ecba ca fadegcb +dbcfg fgd bdegcaf fgec aegbdf ecdfab fbedc dacgb gdcebf gf | cefg dcbef fcge gbcadfe +bdfegc cbegaf gecbf dfcage bdacg ed bedf ced adcbefg gebcd | ed bcgafe cdgba cbgef +egadfb cdbfeg cegd fecab cgb gbdefca cg fgcdab egfdb bfceg | gbdfcae bgc cg cgb +gcafb gcf dcaebfg ecagb gf abcdeg gaef cafbge fdbac fegbdc | fgae cfgab fg bagce`.split('\n') + console.debug( testSingle.split('|')[0].trim() .split(' ').map( @@ -31,5 +42,35 @@ describe('--- Day 8: Seven Segment Search ---', () => { expect(charCodes.map(code => code.length)).to.deep.equal(expectedLengths) }) }) + describe('decodeSignal()', () => { + const testData = testMultiple[0].split('|').map((a) => a.trim()) + const { charCodes } = descrambleSignal(testData[0]) + + it('decodes a display pattern using the provided map of display codes', () => { + const result = decodeSignal(charCodes, testData[1]) + expect(result[0]).to.equal(8) + expect(result[3]).to.equal(4) + }) + it('throws an error if a digit doesn`t have a matching code', () => { + expect( + () => decodeSignal( + [['a']], + 'dcb' + ) + ).to.throw( + 'No match found for dcb when cleaned up to b,c,d' + ) + }) + it('throws an error if a digit has multiple matches (meaning a bad codes map)', () => { + expect( + () => decodeSignal( + [['a'], ['d', 'c', 'b'], ['b', 'c', 'd']], + 'dcb' + ) + ).to.throw( + 'Too many matches for dcb when cleaned up to b,c,d. This most likely indicates a bad list of character codes.' + ) + }) + }) }) }) diff --git a/2021/day-08/solution.js b/2021/day-08/solution.js index 779f7ea..1b9f37d 100644 --- a/2021/day-08/solution.js +++ b/2021/day-08/solution.js @@ -1,22 +1,38 @@ const fs = require('fs') const path = require('path') const filePath = path.join(__dirname, 'input.txt') -const { inputToArray } = require('../../2018/inputParser') +const { linesToArray } = require('../../2018/inputParser') +const { descrambleSignal, decodeSignal } = require('./display') fs.readFile(filePath, { encoding: 'utf8' }, (err, initData) => { if (err) throw err - initData = inputToArray(initData.trim()) + initData = linesToArray(initData.trim()) const resetInput = () => { // Deep copy to ensure we aren't mutating the original data - return JSON.parse(JSON.stringify(initData)) + return JSON.parse(JSON.stringify( + initData.map( + (line) => line.split('|') + .map((e) => e.trim()) + ) + )) } const part1 = () => { const data = resetInput() - console.debug(data) - return 'No answer yet' + + return data.map((entry) => { + const { charCodes } = descrambleSignal(entry[0]) + return decodeSignal(charCodes, entry[1]) + }).reduce((total, signal) => { + const search = [1, 4, 7, 8] + + // Find how many of our desired numbers are in the signal + total += signal.filter((digit) => search.includes(digit)).length + + return total + }, 0) } const part2 = () => { diff --git a/index.js b/index.js index fe03a56..23dbf0d 100644 --- a/index.js +++ b/index.js @@ -1 +1 @@ -require('./2021/day-07/solution') +require('./2021/day-08/solution') From 85cac2a48d020541ce7ddf1690fd467c2858454d Mon Sep 17 00:00:00 2001 From: Anthony McLin Date: Thu, 16 Dec 2021 11:31:02 -0800 Subject: [PATCH 9/9] feat(2021-day-08): tally up the decoded numbers for each scrambled display Solves part 2 --- 2021/day-08/display.js | 42 ++------ 2021/day-08/display.test.js | 28 +++-- 2021/day-08/input.txt | 200 ++++++++++++++++++++++++++++++++++++ 2021/day-08/solution.js | 7 +- 4 files changed, 234 insertions(+), 43 deletions(-) diff --git a/2021/day-08/display.js b/2021/day-08/display.js index ebe84d8..bd0b09e 100644 --- a/2021/day-08/display.js +++ b/2021/day-08/display.js @@ -1,33 +1,3 @@ -// const renderDigit = (num) => { -// const topper = ` ${num}: ` -// const patterns = [ -// 'abcefg', -// 'cf', -// 'acdeg', -// 'acdfg', -// 'bcdf', -// 'abdfg', -// 'abdefg', -// 'acf', -// 'abcdefg', -// 'abcdfg' -// ] -// const template = ` -// aaaa -// b c -// b c -// dddd -// e f -// e f -// gggg -// ` - -// const out = template -// patterns[8].forEach((segment) => { -// if(patterns[num].indexOf(segment) >= -1 -// }) -// } - /** * Using a map of character codes, decode a signal * @param {array} charCodes @@ -483,7 +453,17 @@ const descrambleSignal = (data) => { } } +const parseEntry = (entry) => { + const codes = entry[0] + const signal = entry[1] + const { charCodes } = descrambleSignal(codes) + return parseInt( + decodeSignal(charCodes, signal).join('') + ) +} + module.exports = { decodeSignal, - descrambleSignal + descrambleSignal, + parseEntry } diff --git a/2021/day-08/display.test.js b/2021/day-08/display.test.js index 87d6660..fdf3439 100644 --- a/2021/day-08/display.test.js +++ b/2021/day-08/display.test.js @@ -1,6 +1,6 @@ /* eslint-env mocha */ const { expect } = require('chai') -const { descrambleSignal, decodeSignal } = require('./display') +const { descrambleSignal, decodeSignal, parseEntry } = require('./display') const testSingle = 'acedgfb cdfbe gcdfa fbcad dab cefabd cdfgeb eafb cagedb ab | cdfeb fcadb cdfeb cdbaf' @@ -15,14 +15,6 @@ bdfegc cbegaf gecbf dfcage bdacg ed bedf ced adcbefg gebcd | ed bcgafe cdgba cbg egadfb cdbfeg cegd fecab cgb gbdefca cg fgcdab egfdb bfceg | gbdfcae bgc cg cgb gcafb gcf dcaebfg ecagb gf abcdeg gaef cafbge fdbac fegbdc | fgae cfgab fg bagce`.split('\n') -console.debug( - testSingle.split('|')[0].trim() - .split(' ').map( - (code) => code.split('') - .sort((a, b) => a - b) - ).sort((a, b) => a.length - b.length) -) - describe('--- Day 8: Seven Segment Search ---', () => { describe('Part 1', () => { describe('descrambleSignal()', () => { @@ -73,4 +65,22 @@ describe('--- Day 8: Seven Segment Search ---', () => { }) }) }) + describe('Part 2', () => { + describe('parseEntry()', () => { + it('parses a set of scrambled codes and signal to produce a number for display', () => { + expect( + parseEntry( + testSingle.split('|').map((x) => x.trim()) + ) + ).to.equal(5353) + + const testData = testMultiple.map( + (entry) => entry.split('|') + .map((x) => x.trim()) + ).map(parseEntry) + + expect(testData.reduce((a, b) => a + b)).to.equal(61229) + }) + }) + }) }) diff --git a/2021/day-08/input.txt b/2021/day-08/input.txt index e69de29..758add7 100644 --- a/2021/day-08/input.txt +++ b/2021/day-08/input.txt @@ -0,0 +1,200 @@ +ecgabfd gfbe dgbeaf aeg gfbda eg bgdcaf efgdca abced eadgb | begf decgfa aeg eg +ebfg bfgdea gaf gf baedgc dafec cfdabg ecfabgd fdgea dbaeg | gaedbc egbf dbgcea dagfebc +cfadeg ca bacg dfabe dgcbf dbegafc dac afbdgc gcbedf bfcda | fbdac adbef bgcdfae dcagfe +eag cdgfae cbdge ae fcgad eabdfg ecaf gefbadc dgafcb degca | dacbefg fcdage agdcf fedagb +dga edac gdfbea bgdfec da cfbga dbgec cadgb bdgace dcbfage | acgfb gaecbfd dag gedfab +cefb fb abcgefd fagbde fcbgae faecg cbadg cbfga bfa agcdef | gbacf agbfc bgcaef baf +ebdacf cbgfae cgdebaf afdcb gabdc df cdf eafd ecabf begdfc | cbdaf gdabc fd cbefda +ge daebc fcagb fdebac gaed ecabg egc gacedb cbdfeg adcfbeg | gec gebdca ebagc adbgcfe +bgfade gcefbd eafgd fcae cadgf gcf dgcba cfdega cagbdfe cf | cdgeaf agfed cf cf +abfge ebac acfegbd bc fcged gbfec cfgbad fecabg agbfde fcb | aefgdb cfb egbfca cbfaedg +dfcbag gda dcafe gcdeb ag ecgdaf edagc bcdaef gcbadfe gaef | gbced dga cbadef fgecda +cagb adgceb cdb cfgeda egfbd abcefd decag bc cgebd bgedfca | cegbd dfegac dbc befdg +cbfe bgefdc ceabdfg cf dbgaef gdfbac edcga gcfed dfc fbedg | fgbaed fcd fcegd becf +degabf bfg bcgaf gdacf dbfc gecfda gcaeb fagedbc adfgbc bf | egbdfa gbf adfbceg dcfb +dbfae dfbc ecadg cb cbdea fcebag fgadbec gadebf bec ceabfd | dbfc bgfcead agbedf fdabe +dafcge ecafbg cegaf egdac abegd cd debfca edc cgfd bfdeagc | dec dc ecd dbgae +fgabce bfa acbfegd fcegda bfgd acgfd bcaed bfcda bf cbagdf | bf bafgcd bfdg dgbacfe +fgea gad fcbgaed gdebc afdeb fagcbd cbfeda ag egfdba degab | dgeab badge eacfbdg fdceba +fabdce cagdb gcb bcefag degba dfagbc dgcf dcfab egfcabd cg | befcda dbagc cbdgfa gcdf +be fgaced fdeag badegf fdbea ebdg bea agfbec ebgadcf bcfad | acdfge agbfce debaf dgafe +cdfbeg bg fegca gdefac cadbf eadbcgf cgb egba gcfbea cagfb | gfaced agfcb cbdfaeg cgfdabe +fadcebg cgda ebfag adebc fcebdg fadbce gd begcda bdg gedba | dcga fbage dcabef fcebadg +bfcga adfbgc fbcdage gfedac ab gcfbe cgafd efabgd gab bdca | gcafd cdba gba dfabgc +bdfae gfa cdgabe egfba fg gfeadc acegb fgcb fbecgad ecafgb | bgeaf agfecbd fga agdceb +dgab ebfad cdefgb gbefd fab cefabg fegcbda aedcf ba ebadgf | defbag afb gbfead dbefag +cfabed ecabf cgafdeb bfc fecbgd dcab cb bfeda eagfc adfgeb | fgcae dfbega ebcdfg fabec +eb cbgaef eagcfbd caebd gaedbc badfc abe degac dgeb cgdeaf | aeb gfaebc bceafg abcged +gdecba ecbdgf def fcbade fd fdcg bgfae gdecb gfbde faegdbc | fbage ecgdbf egdfb dfe +dc dac egcadbf gadbe cgaebd abgcd geadbf agfced edcb gabfc | agcbefd edbc bacfg cd +gaebfc gdc cedbg dbeag cefd cd bcfgde cbgfda bcegf dabgecf | bgdea dbgec fecd cfed +afd dfcbga dcbeagf bfecda egbcdf dagec fa bgfa fdbcg fgadc | egbcdf decga gbfa fa +fg baefc gafeb dgaf cbgdea afegbd fbg cebgfd gaecdfb dbgae | ebfag dgbae gafd abgedfc +cbaed gedac cefgbda feba be cadebf gdcefb fcbad bde cdagbf | bcadef cfgdab fdabc feab +cfbdg fdgce adgcbf fb cbf acfegdb adgebc ebafdc dbacg agbf | fgba fgced ecfdabg bf +fceabd gfb agfdb deabg beacgf cfdgbae fcdg gf abfdc dfbgca | dbaeg bfdga dgeab dfcg +gfde facbde dcgbf fg gbf ecafgb cfgdbe ecdfb adcgb ecafbdg | gcdbf fg cfbdg fdeg +fbgdce bg bacefg decab cbg fecgd egdcfa dbfg egdcb fagdbce | gb dcbea fedbgc fagecb +abgcef fgbaedc dfaebg cgad ad egadcb abd cgbea bfecd cabde | efbcd abdfeg afbegd ad +fagecdb bcafg ecadfb fa bagecf cdgba efbdcg befgc fac agfe | bdfcge ecgbf cfedba edagfcb +dgf fcdbg cegbd fd bfcega daebgf dfca abgcf gafbdc fbeacgd | bcfdg fdg dfg adcf +deb cbdgae edfbac dbcgf fbecga gdfcbea bgdec ed ecabg egad | bgcfd faedcb cageb ed +gecfba dfagc afdbc adbcfg cag cabgdfe fdega cbdg dbacfe cg | afcbdeg dabcf cbafed dcfga +feab ae cbgfe agecf bgecda bgecdf eca gfebca fcdbgea cgfad | bgdfec gcfbed eca cbdgaef +fbaceg edcbaf dba becgd egafb degbfca fbadeg dafg da agebd | fbdega gfebca acebdf gbefa +dbce gfbec defgb ed efdagc def gfbeca abfgd bgfedc fcbgade | fdbgce ebdfcg cgfbdea efcbgd +abcdfg fcaegb egf dgcaf bdecf aged bdeacfg ge dgcafe gfcde | acbgfd gcadf cgbdaf gafecb +fb gbfaed eabgdc abcgef adcbfge dgfac fecb bgf fcbga cageb | acebg cfeabg edgcab adgfbce +fad ceafdg dcfag fbcadge geadbf deac da gcfea gdcfb efcagb | aegdfb cgadf aefbcg bgdcf +dagcbf ef dacfg gfdce egf ebdgc dfcgea fabdeg aefc ebdacfg | gdefc dcfag bgdceaf acef +dbegf eabcgd ebdafg fbdac cbg cefg eagbdfc cdbgf gdfbce cg | eabcdgf gecadbf decgbf gc +degf cbefd bfcdeg bfdaec bcage cfgdba fg fcg fbcge cefgdba | fged cfgedab fdgceb efcbd +cgbdae dbeca bcfdeg fcaged edgca be cbdaf ebd gfbadec egba | cefdgab cdfega bcgeda agcbde +cdfgea gbedacf gacbf cdb decag db edcabf gabedc dgeb bgdca | bcfag bcgad ecdgfab bd +ebcg cfgbae acgdbef eag agdfc ge edgabf cgefa facbe dacebf | cbgefa agcfd fgcad dfgac +beagcf dafcgbe da acd bedcf begacd cdbae cefadg bagd bgcae | da fgbecad bdcef bfdec +dg acgfebd fagecb bgeadf ebfgc gdb cdbgf dbafc gecd debfgc | egcbf cafbd facbd afbegcd +geabd cadefb ec eadgfcb cedag gdbeca dec gfbdae dcfag cbeg | ec bdeafgc cbdafe ebcg +be bfade caefgb eab gdbafe bedg agfdb edacfbg gdcabf daefc | acfegb bae fecadgb bgcfea +be acdfb cgfae cbe agbe fgeacbd adegcf bcfae bgcefa fgbecd | cfabeg ecb efcdbg ageb +afbg cfedb dacfgb fgdcb bgfedac cbdage bg acgdf fadceg dgb | cdbgfa fgeadc bafg dfbce +debfc efb adgbce ef fbadec dfcbg feac dacgebf aebdc eadgfb | fcdgb efca cbdeaf edbca +gcbde dgcbf dfc bfcgda df ceadgbf gcabf dbaf gcefab dfcega | adfb egcdb dgbce bdfa +egbdca bgfed baefd cfdgaeb gdefc gcbfed gcfead bg cfgb egb | dcbage cbdgef dgfbe aedbcg +dceaf fc fcge bgdaec agced dfbea cgeabdf adcfbg fdc egcfad | fedca fadeb dabegc aedfb +acfbgd efcda cfagd decg de efcgdab eabfc gdaecf dae bedfag | fceda acdef ed cfeba +defbcg ge egb eagbdc afdgcb cgbae fcadebg geda dcagb efcba | gdecba abgce gbadc daeg +afbd fadgce gbfdea fcgedb bf bgf gefda bfedgac bgcea gaebf | bgfaed fdgecb fbgedc bfg +cbafgd cbdge bc cbd bcef fgbde afgbde fgcbed dgebfca edcga | cb cb acged fdgbec +acgd dceagf dc bafde fbaceg ced cdfbge fdeca egcabfd cgefa | dc egdcfa afegcd efcgbd +bgdfac fb aebgc bfde bdecaf bfa aebcf edabfcg cgdeaf daefc | decfa fb baf fcbdea +bdfegc gebda gecbfa fedbg fed dgfc fabdec dbcagef fd gfcbe | edcfbag dgfeb cdeafb fd +gbeadf fdcga ecadb bceg ge egd dgebacf beafcd aedgc cgbade | dabec dge begdac dgaebc +begc dcgbfa eb dfeag eafgb bae bcgaf gfaebc fbagecd becfad | gabdcfe fdcagb bgcdaf be +eca febdcg fedag ecdaf fcba beagdc fcdeb ca dbefca acebfdg | ebdcgf fdceb gecdab cedfbga +decfbga abgdce gefd afd aecdbf gcfeda acgde cafbg fd fadcg | edgf dafbceg egfd cedga +faedgbc fbgaec dacb eba geacdb bcgefd ba bdegc eadbg gdaef | dfcbge deabcg bfecadg gfcbaed +egfacbd acdgf gecdab ebacf abcfed eg begf caegf aeg bfgeca | dafbcge cadfg fbace cefdbag +dgcfbae ac gbfeca badce gcad dfgcbe defab cea acgdbe dbgce | cgdeba egcdb gcad cagd +dcfg agdfbc caedfgb df bagecf daf gcafb ebcad fdbac agebdf | bdfage fgdbac daf fd +agefbd agcbfde egafb eg adge fge bfaced egdbcf daefb cabgf | bagef afgbe eg efbcdg +adfegb caefgb ade ecgd cafed dbfeacg de fgcae fbcda fgadce | dbefgac eafcg gbaefc fedgac +dbafg ecfga gfbae bae egdbac geabfc gcedfab ebcf eb cagdef | be cbfe bae be +cfgadbe eca bcfadg ebdgac adgcb ebdca adbfe egcb cadfeg ec | adebgc feabd cae cgdfea +caefdg cdfagbe fadbc afd eacbd fd bcadeg cgfba dacfeb bfed | df afcgb fceabdg fda +edcgaf cfbdag cbfdaeg ec cae bgeafc cdafe abfde decg gdcaf | eca dbcafg aec ce +fbgae cagef egdbac cg gcdafbe cfbg bgefda gce ceadf gebfac | gadbce cdegba gc cg +bafgecd bdf ecabfg dgbfe dcefg gbefa bdea bdfcga bd bgfdae | cdfagb cfeabg faebgd fagbe +afg dfcg fg eacdbg fgadeb cfdgea ecagd fcagebd eacfg bacfe | fg dagecb egdca cfdg +dac dc fgcd agbecf gcdaef agbed edcabf fgace caged faecdbg | dabge gceaf gdafecb cdafgeb +aefbg egf bagcf afegdc dfgceab begd gafebd eafbd eg fabcde | egadfb feg bgcfa efg +fa debfg acgfdb eagbc dcebagf cedfbg dafe baf febga eagbfd | af cbfdga dcfgab befcdg +db dbfe fdbga cafdg adgceb egbfa dbg bgfdcea ceagbf befagd | afdbge dceabg gdfab fdaegb +fgeacdb cadg dfg edfga fdagce dg dfaec gebfa cbefgd defabc | geabf dfaec cfdae faegb +abdce bafcg gdecaf cegba fbcadge adbcfe degb eg bdcgae eag | abdec facbg edgb ebagcd +bcaef fg dgbcae adegb bafeg feadcgb egbfad fdgb fecagd efg | agfeb fge fdgb eadgb +dbfage cdab bgcaef ecb cb dgfce dfbce fedbgac deabf beadcf | cbfed dabfe ebadf cefbd +gcedb ceafdg dcg gecdfb dcfaeb cg egdba befdgac fdceb gcfb | begdc bedag eadgb dfecb +bf dbcgea eabdfc feb gbfeac fagb becga fcdaebg dcgef gecfb | efbdcag abceg gcdabef gcbef +ged dagfbe eg cgfe bgfacde gedac dceba agcfd cadegf gcfdba | gefc ge ge acegfbd +gfabed aecdgf ecbag dge gbdae befd bfgad fdcabeg de fagbdc | egbad afdbg dgacef gdafb +dabfegc gbcad gafd acd da fgbadc ecdabf bfgca fcabge gbdec | gbface fgcab bdgac ebdcg +afbceg cdgfb gb afcbed dfcbge gbf adfgc fecbgad egdb bcdfe | fedbc cfeabd edbg cfebgd +cbdae gc gdfc ebgdf gcafbe fbaecdg gbedc ecg fbgecd fdebag | gcedb ebgafc acfgdeb ceg +bdce efacgd dgfbc ebfgad bcfga gdc fgbedac egdfb dc bfdgce | bagdfec efdgb ecbd fdaegc +bdgefc fbca bc gfbcae fdcgae gdaeb cbega gcb efagdcb feagc | gcb bacefgd ecdbgf cfab +fdbe defcbga adf cfgeba gcdae bacef cfadgb df fdeca dcefba | cbegfa degfcab fad acgfbe +gabfdc ebcfd bacgf da fcgbea aedbfcg gdfa eadcbg cdfba abd | dab dabcf afcgb ad +gb bfgcae dbgf cadeg bagdc gefadcb gbc acdbef cgabdf dbafc | gb fbdcae afdbgce dabgc +cfgadbe agecfd ea gedfc edafc fage fbdgce ead aecdbg fabdc | fcbdage cdbage fbadc ae +decgbaf edcgba afgd aebgfd da bfeag gfbcae bad cebfd bfeda | ecfdb eagbf efdba eabgdf +cfdbae dc gbdef fbedag egbfcd gafec edc edacgbf egdcf bdgc | fceag gacfe daegfb bgdcef +cbgda egdfb agebd cgedfb aed bfgdcea ae agdefb efab facedg | gdcaef aefb faeb begfd +fdc begdf adecg gfaced cf efac abedfgc cbedag gdbacf fecgd | cdf fbgadc cabgdf acfe +fedbg gabfe feda gde fcdbg de dbegacf bdfaeg abcdeg cegbfa | bgaef gadebf efgbac gbefa +dgf fgdbea dg dafcb gdec edcfbga dbegfc gbdcf cfbge gcebfa | bdfgc dg egcfab bcdafge +ceg daecb gcfdea fgacbe ecadbfg eg gbacdf cgabf ebfg ecabg | acgeb bfgca geacdf cge +ge geabf gea abecgf fdabg caedbf egbc cgebafd cbfea agdefc | feabc bcdafe age eg +gecdba ebdfg gcdef ecf cefadb fgac cf ecgafd cbfgead adgec | dfecg afcg bcfead ecadg +gd cbfad fdagb cfbeag fabge efabdg aged bdgfec dgf gbfadec | acefgb eabfgc becagf bfgda +ebgc fedabcg fdbgce fdebg eg badgf ebcdf edg adcfeb cfgade | bgefd cbgefd bgefd abfdg +dgbfc abecfg gcdab fcgdbe dfge cbdfea defbc fgc dabgefc gf | gf dbgecf bafgec cgf +degbac fda cdbag eafgbcd df fdbc agfdcb dabfg fbgea fcgade | fd bdceafg fdagbce df +cedaf fgeabc egdbf gbaedcf aeg cgda dfaeg cfdbea fagdce ga | febadc gefad bfacde gae +gea ebfgdc bcae cgafd abecfgd gbced ea gbdeaf dcgae gebcda | efgdab fcegdb cbgade acged +cdabgef gb fceag fgb bfdgac gbcfa cbadfe dfcegb fbdca bgda | bg cbgfa dcfgeb afcgb +fcbage adefc gceda bdegca cbeag dgeb efacdgb cfbgda adg dg | gad gabced gebd dg +ecbdga gedbf dafeg faecbdg eacfg dbaf ad dbfcge gda dfbeag | ad gfbcde dgfea aecfg +agfbde begfca bca baegc bc bcef ecdgbfa adegc bgaef acbfdg | fdbcag baecg cgdbaf bcdagf +beafc badfc daecfb fd fad fdec badefg cbdag fbecgad gecfab | dcfe cbgeaf gdcfabe agdbc +caedgbf fcgead ca gbadf abcd adcfbg fegbc dfaebg gfbac agc | fcgeda dbac afcgb dafebg +gdfeb gdbafe bc ecb ebfagdc bgfce gfeca fdcbge aebdcf bcdg | cdfbeg gdbfe gefcb dbcafe +gfbca gcdfe dbafgc cafgbe eacfbgd cdb agdb db cgdbf ecdbaf | adfcbe abdgfc cdb fcabed +bcdaf fbed edbac cdaegf ed dbgaecf edc ebgac dbagfc fdbace | cbgae efdb gcdafe gbafedc +cdfba cbdfae cfga bafdgc aedfgbc dbgef dag adgfb bdaegc ag | ebacgd adfgcb bdaefc gfac +caefd ce abfdc egcbdf cfe fgaced bdgfea gcae fadcbge eagfd | fcdae fgecad ec cbefgd +eafbd deb aefdg bd aecfbg bdcf abcfe gebcdaf agdbec bcaedf | dbcfae abfecd efabcd cbafe +bdafeg efg gfcdae bagfd dfacgb ef dgfecba befa efbdg dbceg | fe gadbf aebfdg afeb +cgbef ceb bfdgcae gedbac acgfbe be gceafd eacfg fcdgb fbea | abcedg dcgefa be fcegadb +gacb gfbaedc fagdc baf gadcef bfcdea fgebd gfabd cfdgba ba | baf cadfg gbfad fab +gafce df cbdfge gfd gdecb gecdf fdeb cadbeg agdbcf abgdcef | cgfea abgcde decgf fgcdbea +egdbf cbfgde aed befa gfdbae ea abcgd edfcga bcaegdf agdbe | bfae cagbfde cbgda gedcaf +eb dfbacge dbgae becafg abe gadfb cdega cedagb ecfgad debc | cfgeda fagedc afdbg fdcega +efcba becagd gafcdbe eafdbg dagbcf agfbd gefd de bfaed deb | fabce bgaedc ceadbg bed +cbaedf fdgebca gdbe dabce eag ge bacge bagcf decfga bgecda | defgabc bceagd aeg gbacf +dgeabf aefgcdb ad bcfae bdacf dacg bgfdc ebfdgc gfdbac abd | dcga adgc decfbg bafce +fgcba cbdfeag dagfb dcgbaf dcaegb ecbafg bdg bd fcbd faegd | bgdaec feadg cbdage dcgafb +bdc dcfgeb ebgca bdea bdcga abfecg gdcaf bd aecdbfg aebgdc | bade bdecgf bdc cbadg +bcdaeg facgbd caedfb aefdb dgfbe eba ae dcegfab fcea fbcad | cbafed baecdf ae ceabfd +efcbg egd dg cabgef bfdceag fgcbde fdcea gdfb dgebca dfcge | fdgb gd fbgd deg +cbgdfa ebgcfa abdge bdeca efcgbad cd fbedac abecf adc edcf | agebd gfabedc dabfegc abfce +edg abdgce gcefb dcbge dgabfe gcdab de cdebfga cdae fdabcg | gbdafc agcdb dgfceab bafgdec +acdb dgbfec eagfcdb dafbec cae ebdfc ca gfaed acdef gfebac | defac begdfc daegf fdeacb +cgedf gfadce debgcf fedagcb aefbc bcdagf db ebfcd bfd begd | db cgfde dbefc gedcfb +afcbegd dcfge edgbf bdg fabd dabfeg gaebdc abgecf gfeab db | debacg gfbaec fadbegc afcgbe +fcbg cdegf ecdga eacdfb befdg dcf fc dfegba dbfgce agdfcbe | dcf adcge fbcg dgaefbc +bcfea fcbead ecd cgeafb aebcgd bfed bcgedfa de cadfg fedac | de egadfbc debf bfagec +efcdabg afecbd defba cabfd ebca cgdaf dfabeg bc efcdbg fbc | bgdefc afcgebd gdefcb efabgd +edbaf agfbcde gbfcae ag dega aefcdb dfbega dfgbc afdgb bag | dagefb ga decbfa aecbgf +cbdg aegbcfd badce dgaebf abdcfe gad cgeda gd fcage ceagbd | fdcaeb dbeca beafdc bdace +decb dagfe dcgbafe fecbda acfdb adfbcg agefbc fec ec faced | fcadeb cdagfb agbfce gcfdba +acdbef dgca gbfae agecfdb ebdcg bda bgeda gedbfc ad bcadge | cgdbe cdag dcga efdcgab +gc efbdg eadcf ebcafg adecgf gfdbaec gcf gcda dcgfe dcbaef | gc acedbf fcead gdca +bfgce dabfg ecdf cebgfa dfegb ed deb fecbgda becgda cfbedg | cdgbefa ebd gafdb cdgefba +ce gecb ecd debaf ecdfb dcfega dagcbef fbgcd bdcgaf dcgfeb | dec dfbec agcfed bedfa +cgbfd gb dcafg gadb gbfcea bcfdeag fcbde fbg gcbfad agdfec | dcfgab bfgdc dfaceg dfgac +bgacef cdagf bgdcae gd dag dbagfc fecagbd fdbg cfead agbfc | gfcba adgcf facgb gd +efdc adbgc gec acfgde feadg gbecaf fbdgae agdec daefbgc ce | ec cedf cge bdfagce +aecdbg cabfe acfgeb bcefda fgac fdgeb afdcbge bcg cebfg gc | gcbfae febcda facg baefcg +dgbafce gfacdb gecb dcaefg gfaeb egf gebacf bdefa bgcaf eg | abfge fgabe fge deagfc +ceafdb dcbega afd gdbeaf fdgea fgeac gbade cbfadeg fd dfbg | adbcge gdcfeab afd fd +dacegf ed dfcbg cfgea dcfge fcgdbae acgbef ced eagd abefcd | dfbeac fgcdb geda dbfgc +egbcdf ecbdga afegc aefdbgc dgeca dge dg dcfbae dgab cdbea | gcead eabdcf gdeac cfadbe +gca fceagd fdgbc ga fecab fgcabed bgcaf cdbfge adbg acdfgb | agdb bfadcg bfgac gbfca +acgdeb baefd fa gdfa bgdea bdcfe fdagebc fdgbea ecfgba fab | adbecg agcbed febagc feagcdb +fedagc dcfge ef bgdcf gdceba egf fead edcag gfbaec fdgaebc | cgade aecfdg efg eadf +dbagf gcdefab fc badfc cbaed gfadbe dgfc gfbcad gaebfc bcf | cfb cdbea bdagf fc +bae be gcadeb dbge dgebacf eagcd geabc fbcga eagfdc edbafc | gcabf ecdfbag afbcg cbgfa +bd gdbcf cbfegd cfbeag febdagc fbd fcgeb decb afgbed dfgac | cbefg eadcbfg cbegfad egdfcb +febacg dega cegfd cefda ae agebcfd abcdf eca defacg ecgfbd | badcf cae bdcefg acedf +geabcd gdbcfa gaedc cbeagf bdgeacf gdefc bdacg ae adbe cae | gcebad agfbdc gefbcad ea +fa bfdacge adecgb eacf bdfgac gfdbe aegdc egacfd gadfe fga | gedfb egfbd efagd dagfbc +gcdb dg beagdf feacg cebgdfa afbcd adcgf dbfcga ebfdac agd | gd acdfg dcbaf gacfe +aefgbd cgfdb gfdea eabfgc dcgfe cfe ceda gdcaef ce fdeabgc | bdcgf edgaf cbdfg egfbda +facegb cfdabeg bd cedgbf adcfeb cfabe cdb eadb cgdfa dfbca | dfbca eadb adecbgf bdc +bacfeg agfcdeb acegf gfcade ecagbd fdbag afegd cdfe ed edg | dfce egd degaf dagfb +df gdfcea efbadg cegafbd eacfd fad cedbga dgaec dfcg fbcea | caedg dgafbe edgac df +bfdac cdbgfa cefbgd bfag afgbdec cdgafe cbfdg acf ecbda fa | dgcfae af cabfd beadc +befgd dea ecab baefcd gfbcad ea bafcd dbcgefa afebd cadfeg | gfbadc eda cadgfb eda +gf cgadb gebf becfdga gaefcd febac gcbaf cbfdea bfgeac fag | fg afcbg efbg afg +ba aebg gafdceb bca bdacg dagcf fcbdae gcbed cadebg bgcefd | dcagf gdabc afgcd edcfgb +de dbec bfaecdg gdfeca fegcb edg dbgaf fceabg febcgd bgdef | afdbg adbfg debfgc bdgfa +afbced adebfg efagdbc caebf afgec ecgb ega eg fgdac acegfb | aedgbf cbge egbfda badfgec +fg gbfcdea eafbcd fdaeb cdage egf agdefb fdcbge efgda fgab | deacg cdage gedca adfeb +gde gbdc dg fdgec dfaegb fedca bcgefd fbeacg gadecbf fcbeg | cgfabe edcgf fgeabdc cbefg +befcdg agbcef fcbdeag gdfae bdecf eab fcdeab ab efbad bcad | cfgeba befda aefgd degbcfa +abcef dbfaegc aefcg dcgbae fbcg efgacb cg cdabfe gec dfeag | dgfae gdefa agcbde afbced +dgf fcbega afdbeg fgabe dg efadg bged adfbceg agbcfd fedca | aefgb begd fceda debg +cdgaeb ba befgdca defbc gdecaf bae gabc afgdeb gedac decab | fbecd bae gdecfa edcba +ebagfd dfg dcbaeg dgbceaf gf gacdf fcade gacbd gcfb fbagcd | adgfc acbgd edbagf degabc +gba eagbcf gb gbacf dacgebf bceg gcafed acfeg acbfd adegfb | abfcdeg dbcfage faecg afebgc diff --git a/2021/day-08/solution.js b/2021/day-08/solution.js index 1b9f37d..713b7a2 100644 --- a/2021/day-08/solution.js +++ b/2021/day-08/solution.js @@ -2,7 +2,7 @@ const fs = require('fs') const path = require('path') const filePath = path.join(__dirname, 'input.txt') const { linesToArray } = require('../../2018/inputParser') -const { descrambleSignal, decodeSignal } = require('./display') +const { descrambleSignal, decodeSignal, parseEntry } = require('./display') fs.readFile(filePath, { encoding: 'utf8' }, (err, initData) => { if (err) throw err @@ -37,8 +37,9 @@ fs.readFile(filePath, { encoding: 'utf8' }, (err, initData) => { const part2 = () => { const data = resetInput() - console.debug(data) - return 'No answer yet' + + return data.map(parseEntry) + .reduce((a, b) => a + b) } const answers = [] answers.push(part1())