feat(2018 day-03): rewrite to use iterators over nested array storage

Author: developher-net

2018/day-03/claims.js

@@ -1,88 +1,75 @@
 var _conflicts = []
 var _claims = []
+var _cloth = []
 
 /**
- * Check if a value is within the designated range (inclusive)
- * @param {number} s1 start of first range
- * @param {number} e1 end of first range
- * @param {number} s2 start of first range
- * @param {number} e2 end of first range
+ * Generates an empty matrix of X columns and Y rows
  */
-const _isOverlap = (s1, e1, s2, e2) => {
-  return Math.max(s1, e1) <= Math.min(s2, e2)
+const emptyMatrix = (x, y) => {
+  return Array(x).fill().map(() => Array(y).fill())
+}
+
+const resetState = () => {
+  _cloth = emptyMatrix(1000, 1000)
+  _conflicts = []
+  _claims = []
 }
 
 /**
- * Compares claims to see if they overlap
- * @param {Object} c1 claim to compare
- * @param {Object*} c2 claim to compare
+ * Iterates through the cloth and tallies the conflicing points
  */
-const _isOverlappingClaim = (c1, c2) => {
-  // x range overlaps
-  const x = _isOverlap(
-    c1.x,
-    c1.x + c1.width,
-    c2.x,
-    c2.x + c2.width
-  )
-  // y range overlaps
-  const y = _isOverlap(
-    c1.y,
-    c1.y + c1.height,
-    c2.y,
-    c2.y + c2.height
-  )
-  return (x && y)
+const countConflicts = () => {
+  let conflicts = 0
+  for (let x = 0; x < _cloth.length; x++) {
+    for (let y = 0; y < _cloth[x].length; y++) {
+      if (isConflict(x, y)) {
+        conflicts += 1
+      }
+    }
+  }
+  return conflicts
 }
 
 /**
- * Iterates through the list of claims and checks to see if any cover the specified point
+ * Checks a point in the cloth to see if it's already claimed
  * @param {number} x point x value
  * @param {number} y point y value
  * @returns {Boolean}
  */
 const isClaimed = (x, y) => {
-  const matches = _claims.filter((claim) =>
-    x >= claim.x &&
-    x <= claim.x + claim.width &&
-    y >= claim.y &&
-    y <= claim.y + claim.height
-  )
-  return (matches.length > 0)
+  return (typeof _cloth[x][y] === 'object' && _cloth[x][y].length > 0)
 }
 
-/**
- * Logs a conflict about multiple claims for a singel point
- * @param {number} x
- * @param {number} y
- * @param {Array} claims list of claim IDs
- */
-const logConflict = (x, y, claims) => {
-  let existing = _conflicts.find((c) => c.x === x && c.y === y)
-  if (existing) {
-    // Append new claims to existing list for this coordiante
-    existing.claims = existing.claims.concat(claims)
-  } else {
-    // Record a new claim conflict
-    _conflicts.push({ x: x, y: y, claims: claims })
+const isConflict = (x, y) => {
+  return (isClaimed(x, y) && _cloth[x][y].length > 1)
+}
+
+const claimPoint = (x, y, id) => {
+  // Point doesn't have a claim yet
+  if (typeof _cloth[x][y] === 'undefined') {
+    _cloth[x][y] = [id]
+    return
+  }
+  // Point has claims already
+  if (typeof _cloth[x][y] === 'object') {
+    _cloth[x][y].push(id)
+    return
   }
+  throw new Error('Tried to set a point with an unknown type')
 }
 
+/**
+ * Marks claimed points on the cloth
+ * @param {Object} claim
+ */
 const makeClaim = (claim) => {
-  // Check if there's any overlap with an exisiting claim
-  const overlaps = _claims.filter((existing) => _isOverlappingClaim(existing, claim))
-  if (overlaps.length > 0) {
-    console.log(`Claim ${claim.id} overlaps ${overlaps.length} already existing claims.`)
-    // step through individual points to log conflicts
-    for (let x = claim.x; x < claim.x + claim.width; x++) {
-      for (let y = claim.y; y < claim.y + claim.height; y++) {
-        if (isClaimed(x, y)) {
-          logConflict(x, y, [claim.id])
-        }
-      }
+  for (let x = claim.x; x < claim.x + claim.width; x++) {
+    for (let y = claim.y; y < claim.y + claim.height; y++) {
+      claimPoint(x, y, claim.id)
     }
   }
-  _claims.push(claim)
+
+  return _cloth
 }
 
 /**
@@ -109,11 +96,15 @@ const parseClaim = (str) => {
   return claim
 }
 
+resetState()
+
 module.exports = {
   _conflicts,
   _claims,
+  _cloth,
+  countConflicts,
   isClaimed,
-  logConflict,
   makeClaim,
-  parseClaim
+  parseClaim,
+  resetState
 }

2018/day-03/claims.test.js

@@ -1,18 +1,14 @@
 /* eslint-env mocha */
 const expect = require('chai').expect
-let {
-  _conflicts,
-  _claims,
+var {
+  _cloth,
+  countConflicts,
   isClaimed,
-  logConflict,
   makeClaim,
+  resetState,
   parseClaim
 } = require('./claims')
 
-function _randomInt (min, max) {
-  return Math.floor(Math.random() * (max - min + 1)) + min
-}
-
 describe('--- Day 3: No Matter How You Slice It ---', () => {
   const claims = [
     '#123 @ 3,2: 5x4',
@@ -21,6 +17,14 @@ describe('--- Day 3: No Matter How You Slice It ---', () => {
     '#3 @ 5,5: 2x2'
   ]
 
+  beforeEach(() => {
+    resetState()
+  })
+
+  afterEach(() => {
+    resetState()
+  })
+
   describe('parseClaim()', () => {
     it('converts a claim into a readable object', () => {
       const claim = claims[0]
@@ -37,29 +41,27 @@ describe('--- Day 3: No Matter How You Slice It ---', () => {
   })
 
   describe('makeClaim(claim)', () => {
-    it('claims a piece of cloth for the specified elf', () => {
+    it('marks the points on the cloth with the claim ID', () => {
       const claim = parseClaim(claims[0])
-      makeClaim(claim)
-      const actual = _claims.find((el) => el.x === claim.x && el.y === claim.y)
-      expect(actual).to.deep.equal(claim)
+      let result = makeClaim(claim)
+      expect(result[1][1]).to.equal(undefined)
+      expect(result[3][2]).to.deep.equal([123])
+      expect(result[7][5]).to.deep.equal([123])
     })
 
-    it('logs an overlap when one is encountered', () => {
-      const claim1 = claims[1]
-      const claim2 = claims[2]
-      makeClaim(claim1)
-      makeClaim(claim2)
-      expect(_conflicts)
-    })
+    it('marks the points that are overlapped', () => {
+      let testClaims = claims.map(parseClaim)
+      let result = _cloth
+      for (let x = 1; x < claims.length; x++) {
+        result = makeClaim(testClaims[x])
+      }
 
-    // it('does not claim points outside the region', () => {
-    //   const claim = parseClaim(claims[0])
-    //   makeClaim(claim)
-    //   expect(_cloth.length).to.equal(claim.width)
-    //   _cloth.forEach((col) => {
-    //     expect(col.length).to.equal(claim.height)
-    //   })
-    // })
+      expect(result[0][0]).to.equal(undefined)
+      expect(result[3][1]).to.deep.equal([2])
+      expect(result[2][3]).to.deep.equal([1])
+      expect(result[3][3]).to.deep.equal([1, 2])
+      expect(result[5][5]).to.deep.equal([3])
+    })
   })
 
   describe('isClaimed(x,y)', () => {
@@ -76,19 +78,15 @@ describe('--- Day 3: No Matter How You Slice It ---', () => {
     })
   })
 
-  describe('logConflict(x,y,claims)', () => {
-    it('records claim conflicts', () => {
-      const x = _randomInt(0, 500)
-      const y = _randomInt(0, 500)
-      const id = _randomInt(0, 500)
-      const expected = {
-        x: x,
-        y: y,
-        claims: [id]
+  describe('countConflicts()', () => {
+    it('counts the number of points with conflicting claims', () => {
+      let testClaims = claims.map(parseClaim)
+      for (let x = 1; x < claims.length; x++) {
+        makeClaim(testClaims[x])
       }
-      logConflict(x, y, [id])
-      const actual = _conflicts.find((c) => c.x === x && c.y === y)
-      expect(actual).to.deep.equal(expected)
+      const expected = 4
+      const actual = countConflicts()
+      expect(actual).to.equal(expected)
     })
   })
 })

2018/day-03/solution.js

@@ -0,0 +1,15 @@
+const claims = require('./claims')
+const fs = require('fs')
+const path = require('path')
+const filePath = path.join(__dirname, 'input.txt')
+const inputParser = require('../inputParser')
+
+fs.readFile(filePath, { encoding: 'utf8' }, (err, data) => {
+  if (err) throw err
+
+  const claimsList = inputParser.linesToArray(data)
+  claimsList.forEach((claim) => claims.makeClaim(claims.parseClaim(claim)))
+  const answer = claims.countConflicts()
+  console.log(`-- Part 1 --`)
+  console.log(`Answer: ${answer}`)
+})

2018/inputParser.js

@@ -10,6 +10,14 @@ function inputToArray (input) {
   return list
 }
 
+function linesToArray (input) {
+  // convert list into array of strings split by lines
+  let list = input.split(/[\n]+/)
+  // drop the empty entries created by extraneous whitespace
+  list = list.filter((item) => item !== '')
+  return list
+}
+
 /**
  * Takes an input string and parses it into an array of integers
  * list can be newline or comma delineated
@@ -28,5 +36,6 @@ function parseData (input) {
 
 module.exports = {
   inputToArray,
+  linesToArray,
   parseData
 }

2018/inputParser.test.js

@@ -1,6 +1,6 @@
 /* eslint-env mocha */
 const expect = require('chai').expect
-const { inputToArray } = require('./inputParser')
+const { inputToArray, linesToArray } = require('./inputParser')
 
 describe('inputParser', () => {
   describe('inputToArray()', () => {
@@ -26,4 +26,28 @@ describe('inputParser', () => {
       expect(actual).to.deep.equal(expected)
     })
   })
+
+  describe('linesToArray()', () => {
+    it('converts the contents of an input file to an array of strings, breaking on new lines', () => {
+      const input = `
+abcdef
+bababc
+abbcde
+abcccd
+aabcdd
+abcdee
+ababab`
+      const expected = [
+        'abcdef',
+        'bababc',
+        'abbcde',
+        'abcccd',
+        'aabcdd',
+        'abcdee',
+        'ababab'
+      ]
+      const actual = linesToArray(input)
+      expect(actual).to.deep.equal(expected)
+    })
+  })
 })