fix(2018 day-02): account for variable padding needed around list of plants between generations

Author: developher-net

2018/day-12/plants.js

@@ -1,13 +1,15 @@
 class Plants {
   constructor (initial, rules) {
     this.generations = []
+    this.boundaryBuffers = [0, 0]
     this.rules = {}
     this._setInitialGeneration(initial)
     if (rules && rules.length > 0) {
       rules.forEach((rule) => {
         this.addRule(rule)
       })
     }
+    this.boundaryBuffers = this.getBoundaryBuffers()
   }
 
   _setInitialGeneration (initial) {
@@ -63,11 +65,14 @@ class Plants {
         state: state
       }
     })
-    // Add 2 pots at the beginning and end to support future generation
-    for (let x = 1; x <= 2; x++) {
+
+    // Padd the list to support future generation
+    for (let x = 1; x <= this.boundaryBuffers[0]; x++) {
       const first = nextGen[0].position
-      const last = nextGen[nextGen.length - 1].position
       nextGen.splice(0, 0, { position: first - 1, state: '.' })
+    }
+    for (let x = 1; x <= this.boundaryBuffers[1]; x++) {
+      const last = nextGen[nextGen.length - 1].position
       nextGen.push({ position: last + 1, state: '.' })
     }
 
@@ -100,6 +105,40 @@ class Plants {
     }, [0, 0])
   }
 
+  /**
+   * Rules need empty pots lef/right of row for verification. Figures out the number of pots we need
+   * to add to the left/right of a row
+   * @returns {Array} [left, right] necessary buffer size of first and last pots
+   */
+  getBoundaryBuffers () {
+    let buffers = [0, 0]
+    Object.keys(this.rules).filter((rule) => this.rules[rule] === '#').forEach((rule) => {
+      // For left edge
+      for (let x = 0; x < rule.length; x++) {
+        if (rule.substr(x, 1) === '.') {
+          let y = x + 1
+          buffers[0] = Math.max(buffers[0], y)
+        } else {
+          // break the loop when we encounter a #
+          x = rule.length
+          break
+        }
+      }
+
+      for (let x = rule.length - 1; x >= 0; x--) {
+        if (rule.substr(x, 1) === '.') {
+          let y = rule.length - x
+          buffers[1] = Math.max(buffers[1], y)
+        } else {
+          // break the loop when we encounter a #
+          x = -1
+          break
+        }
+      }
+    })
+    return buffers
+  }
+
   /**
    * Generates a visual display of the pots in all generations. Accepts optional boundaries.
    * @param {Number} start First pot to include

2018/day-12/plants.test.js

@@ -62,6 +62,7 @@ describe('--- Day 12: Subterranean Sustainability ---', () => {
     describe('advance()', () => {
       it('advances the next generation', () => {
         const expected = [
+          { position: -3, state: '.' },
           { position: -2, state: '.' },
           { position: -1, state: '.' },
           { position: 0, state: '#' },
@@ -90,7 +91,8 @@ describe('--- Day 12: Subterranean Sustainability ---', () => {
           { position: 23, state: '.' },
           { position: 24, state: '#' },
           { position: 25, state: '.' },
-          { position: 26, state: '.' }
+          { position: 26, state: '.' },
+          { position: 27, state: '.' }
         ]
         let plantTracker = new Plants(initialState, rules)
         plantTracker.advance()
@@ -175,5 +177,13 @@ describe('--- Day 12: Subterranean Sustainability ---', () => {
         expect(actual).to.equal(expected)
       })
     })
+    describe('findBoundaryBuffers()', () => {
+      it('figures out how many buffer pots are needed at the ends each row based on the rules', () => {
+        const expected = [3, 3]
+        const plantTracker = new Plants(initialState, rules)
+        const actual = plantTracker.getBoundaryBuffers()
+        expect(actual).to.deep.equal(expected)
+      })
+    })
   })
 })