- implement Counter ADT

- add Flips and Rolls clients

Author: Isaac Ramirez

src/adts/counter/counter.js

@@ -0,0 +1,39 @@
+/**
+ * Counter
+ * @classdesc An abstract data type for a simple Counter.
+ * @see p. 85
+ */
+class Counter {
+  constructor (id) {
+    this._count = 0
+    // static final string _id
+    Object.defineProperty(this, '_id', { value: id })
+  }
+
+  /**
+   * Increments the internal count
+   */
+  increment () {
+    this._count++
+  }
+
+  /**
+   * Returns the total count.
+   * @returns {number} The total count
+   */
+  tally () {
+    return this._count
+  }
+
+  /**
+   * Returns the tally and the Counter's id as String.
+   * @returns {string} The tally + id as string.
+   * @example
+   * // 3 heads
+   */
+  toString () {
+    return `${this.tally()} ${this._id}`
+  }
+}
+
+module.exports = Counter

src/adts/counter/counter.spec.js

@@ -0,0 +1,51 @@
+const Counter = require('./counter')
+
+describe('Unit Tests: Counter ADT', () => {
+  describe('instance', () => {
+    beforeEach(() => {
+      this.name = 'test'
+      this.counter = new Counter(this.name)
+    })
+
+    it('should not allow to change its name', () => {
+      this.counter._id = 'new name'
+
+      expect(this.counter._id).toBe(this.name)
+    })
+
+    describe('increment method', () => {
+      it('should increment the `count`', () => {
+        const trials = 1000
+
+        for (let i = 0; i < trials; i++) {
+          this.counter.increment()
+        }
+
+        expect(this.counter._count).toEqual(trials)
+      })
+    })
+
+    describe('tally method', () => {
+      it('should return the total `count`', () => {
+        const trials = 1000
+
+        for (let i = 0; i < trials; i++) {
+          this.counter.increment()
+        }
+
+        expect(this.counter.tally()).toEqual(trials)
+      })
+    })
+
+    describe('toString method', () => {
+      it('should return a formatted string with the count and id values', () => {
+        this.counter.increment()
+        this.counter.increment()
+        this.counter.increment()
+        const expectedStr = `3 ${this.name}`
+
+        expect(String(this.counter)).toBe(expectedStr)
+      })
+    })
+  })
+})

src/adts/index.js

@@ -0,0 +1,3 @@
+module.exports = {
+  Counter: require('./counter/counter')
+}

src/examples/test-clients/flips.client.js

@@ -0,0 +1,65 @@
+const { StdOut, StdRandom } = require('../../libs')
+const { Counter } = require('../../adts')
+
+/**
+ * Flips
+ * @classdesc Counter Client
+ * @see p. 70, 71, 85, 89
+ */
+class Flips {
+  /**
+   * Returns the counter with the max tally.
+   * @param {Counter} counterX Counter X
+   * @param {Counter} counterY Counter Y
+   */
+  static max (counterX, counterY) {
+    if (counterX.tally() > counterY.tally()) {
+      return counterX
+    } else {
+      return counterY
+    }
+  }
+
+  /**
+   * Simulates the flips of a coin and computes the delta.
+   * @param {[]} args [trials]
+   * @example
+   * ```sh
+   * $ node flips.client.js 1000
+   * 490 heads
+   * 510 tails
+   * delta: 20
+   * 510 tails wins
+   * ```
+   */
+  static main (args) {
+    const trials = parseInt(args[0], 10)
+    const heads = new Counter('heads')
+    const tails = new Counter('tails')
+
+    for (let i = 0; i < trials; i++) {
+      if (StdRandom.bernoulli(0.5)) {
+        heads.increment()
+      } else {
+        tails.increment()
+      }
+    }
+
+    StdOut.println(heads.toString())
+    StdOut.println(tails.toString())
+
+    const delta = heads.tally() - tails.tally()
+
+    StdOut.println(`delta: ${Math.abs(delta)}`)
+
+    if (heads.tally() === tails.tally()) {
+      StdOut.println(`It's a Tie!`)
+    } else {
+      StdOut.println(`${Flips.max(heads, tails)} wins`)
+    }
+  }
+}
+
+// Execution
+// ==============================
+Flips.main(process.argv.slice(2))

src/examples/test-clients/rolls.client.js

@@ -0,0 +1,46 @@
+const { StdOut, StdRandom } = require('../../libs')
+const { Counter } = require('../../adts')
+
+/**
+ * Rolls
+ * @classdesc Counter client
+ * @see p. 72
+ */
+class Rolls {
+  /**
+   * Simulates rolls of a die
+   * @param {[]} args [trials]
+   * @example
+   * ```sh
+   * $ node rolls.client.js 100000
+   * 16399 1s
+   * 16785 2s
+   * 16661 3s
+   * 16511 4s
+   * 16904 5s
+   * 16740 6s
+   * ```
+   */
+  static main (args) {
+    const trials = parseInt(args[0], 10)
+    const SIDES = 6
+    const rolls = new Array(SIDES + 1)
+
+    for (let i = 1; i <= SIDES; i++) {
+      rolls[i] = new Counter(`${i}s`)
+    }
+
+    for (let t = 0; t < trials; t++) {
+      const result = StdRandom.uniform(1, SIDES + 1)
+      rolls[result].increment()
+    }
+
+    for (let i = 1; i <= SIDES; i++) {
+      StdOut.println(String(rolls[i]))
+    }
+  }
+}
+
+// Execution
+// ==============================
+Rolls.main(process.argv.slice(2))