developher-net
diff --git a/‎2020/day-02/cleanupPasswords.js
Copy file name to clipboardExpand all lines: 2020/day-02/cleanupPasswords.js
+45Lines changed: 45 additions & 0 deletions b/‎2020/day-02/cleanupPasswords.js
Copy file name to clipboardExpand all lines: 2020/day-02/cleanupPasswords.js
+45Lines changed: 45 additions & 0 deletions
diff --git a/‎2020/day-02/cleanupPasswords.test.js
Copy file name to clipboardExpand all lines: 2020/day-02/cleanupPasswords.test.js
+32-1Lines changed: 32 additions & 1 deletion b/‎2020/day-02/cleanupPasswords.test.js
Copy file name to clipboardExpand all lines: 2020/day-02/cleanupPasswords.test.js
+32-1Lines changed: 32 additions & 1 deletion
diff --git a/‎2020/day-02/solution.js
Copy file name to clipboardExpand all lines: 2020/day-02/solution.js
+5-5Lines changed: 5 additions & 5 deletions b/‎2020/day-02/solution.js
Copy file name to clipboardExpand all lines: 2020/day-02/solution.js
+5-5Lines changed: 5 additions & 5 deletions
@@ -13,6 +13,7 @@ const splitRecord = (row) => {
 
 /**
  * Splits a password validation rule into its component parts
+ * using the original rules
  */
 const oldSplitRule = (rule) => {
   const splitRow = rule.split(/-| /)
@@ -24,8 +25,25 @@ const oldSplitRule = (rule) => {
   }
 }
 
+/**
+ * Splits a password validation rule into its component parts
+ * using the new rules
+ */
+const newSplitRule = (rule) => {
+  const splitRow = rule.split(/-| /)
+
+  return {
+    positions: [
+      Number(splitRow[0]),
+      Number(splitRow[1])
+    ],
+    char: String(splitRow[2])
+  }
+}
+
 /**
  * Validates a password against the specified rule
+ * using the original rules
  */
 const oldIsValidPassword = (rule, password) => {
   // count how many times `rule.char` exists in `password`
@@ -40,17 +58,44 @@ const oldIsValidPassword = (rule, password) => {
   return true
 }
 
+/**
+ * Validates a password against the specified rule
+ * using the new rules
+ */
+const newIsValidPassword = (rule, password) => {
+  let matches = 0
+  rule.positions.forEach((pos) => {
+    // index starts with 1
+    if (password[pos - 1] === rule.char) {
+      matches++
+    }
+  })
+  // Only one match allowed, not 2, not 0
+  return (matches === 1)
+}
+
 const oldIsValidRecord = (record) => {
   const { rule, password } = splitRecord(record)
   const parsedRule = oldSplitRule(rule)
   return oldIsValidPassword(parsedRule, password)
 }
 
+const newIsValidRecord = (record) => {
+  const { rule, password } = splitRecord(record)
+  const parsedRule = newSplitRule(rule)
+  return newIsValidPassword(parsedRule, password)
+}
+
 module.exports = {
   old: {
     splitRule: oldSplitRule,
     isValidPassword: oldIsValidPassword,
     isValidRecord: oldIsValidRecord
   },
+  cur: {
+    splitRule: newSplitRule,
+    isValidPassword: newIsValidPassword,
+    isValidRecord: newIsValidRecord
+  },
   splitRecord
 }
@@ -1,6 +1,6 @@
 /* eslint-env mocha */
 const { expect } = require('chai')
-const { splitRecord, old } = require('./cleanupPasswords')
+const { splitRecord, old, cur } = require('./cleanupPasswords')
 
 const testData = [
   '1-3 a: abcde',
@@ -53,4 +53,35 @@ describe('--- Day 2: Password Philosophy ---', () => {
       })
     })
   })
+  describe('Part 2', () => {
+    describe('splitRule()', () => {
+      it('splits a password formatting rule into component parts', () => {
+        testData.forEach((row, idx) => {
+          const { rule, password } = splitRecord(row)
+          const { positions, char } = cur.splitRule(rule)
+          expect(`${positions.join('-')} ${char}: ${password}`).to.equal(testData[idx])
+        })
+      })
+    })
+    describe('isValidPassword()', () => {
+      it('checks if a specified password matches the specified rule', () => {
+        const expectedResults = [true, false, false]
+        testData.forEach((row, idx) => {
+          const { rule, password } = splitRecord(row)
+          const ruleObj = cur.splitRule(rule)
+          expect(cur.isValidPassword(ruleObj, password))
+            .to.equal(expectedResults[idx])
+        })
+      })
+    })
+    describe('isValidRecord()', () => {
+      it('checks if a specified record contains valid rule and password', () => {
+        const expectedResults = [true, false, false]
+        testData.forEach((row, idx) => {
+          expect(cur.isValidRecord(row))
+            .to.equal(expectedResults[idx])
+        })
+      })
+    })
+  })
 })
@@ -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 { isValidRecord } = require('./cleanupPasswords')
+const { old, cur } = require('./cleanupPasswords')
 
 fs.readFile(filePath, { encoding: 'utf8' }, (err, initData) => {
   if (err) throw err
@@ -16,14 +16,14 @@ fs.readFile(filePath, { encoding: 'utf8' }, (err, initData) => {
 
   const part1 = () => {
     const data = resetInput()
-    // Count the valid passwords
-    return data.filter(isValidRecord).length
+    // Count the valid passwords with old rules
+    return data.filter(old.isValidRecord).length
   }
 
   const part2 = () => {
     const data = resetInput()
-    console.debug(data)
-    return 'No answer yet'
+    // Count the valid passwords with new rules
+    return data.filter(cur.isValidRecord).length
   }
   const answers = []
   answers.push(part1())