Javascript bowling challenge - Louis Claremont

README.md

@@ -2,6 +2,21 @@
 Bowling Challenge
 =================
 
+# Overview
+In this challenge I have created a javascript program which will score a bowling game (10 frames) based on the rolls thrown in each frame, which will be inputted by the user.
+The logic for this proved very difficult - since when a spare or a strike is thrown, the total score for that frame is unknown until the next roll(s) are complete.
+I have a frame class which handles the behaviour of a frame. This includes checking whether the frame is a spare or strike, finding the number of pins knocked down and updating the spare/strike frame's score based on the following frame (or following two frames if a strike is followed by another strike).
+Then I created a scorecard class which allows a user to add a frame and calculate the total score up to a given point. This is useful since on the scorecard, if a spare is thrown, we do not want to update the current score straight away since we need to wait for the following frame. Hence, we would like to know the score up to the previous frame (to retrospectively show the running total at that point) in order to correctly score the frames one by one.
+
+**NOTE** --
+In my tests, I refer to a frame which is not a spare or a strike as a 'simple frame'.
+
+## Further
+I have added a server.js file which runs an express application, so that you can view the scorecard. I have added a POST /frame route so that you are able to add a frame through body parameters. This can be built upon to create a UI for users to add frames and view their scorecard.
+
+
+## Instruction
+
 * Feel free to use google, your notes, books, etc. but work on your own
 * If you refer to the solution of another coach or student, please put a link to that in your README
 * If you have a partial solution, **still check in a partial solution**

api/.eslintrc.js

@@ -0,0 +1,15 @@
+module.exports = {
+    "env": {
+        "browser": true,
+        "es2021": true
+    },
+    "extends": "eslint:recommended",
+    "overrides": [
+    ],
+    "parserOptions": {
+        "ecmaVersion": "latest",
+        "sourceType": "module"
+    },
+    "rules": {
+    }
+}

api/server.js

@@ -0,0 +1,28 @@
+const express = require('express');
+const app = express();
+const port = 3000;
+
+const Scorecard = require('./src/scorecard.js');
+const scorecard = new Scorecard()
+
+app.use(express.json());
+
+app.get('/', (req, res) => {
+  res.send('Bowling scorecard')
+});
+
+app.get('/scorecard', (req, res) => {
+  res.send(scorecard.show())
+})
+
+app.post('/frame', (req, res) => {
+  const { roll1, roll2, roll3 } = req.body;
+  const rolls = [roll1, roll2, roll3].filter(roll => roll !== undefined);
+
+  scorecard.addFrame(...rolls);
+
+  res.send('Frame added')
+})
+
+console.log(`Server listening on localhost:${port}`);
+app.listen(port);

api/src/frame.js

@@ -0,0 +1,42 @@
+class Frame {
+
+  constructor(rolls) {
+    this.rolls = rolls,
+    this.score = null
+  }
+
+  getFrameScore() {
+    if (this.spare() || this.strike()) {
+      return this.score;
+    } else {
+      return this.#pinsDown();
+    }
+  }
+
+  spare() {
+    return this.#pinsDown() === 10 && this.rolls.length === 2;
+  }
+
+  strike() {
+    return this.#pinsDown() === 10 && this.rolls.length === 1;
+  }
+
+  scoreWithSpareBonus(frame) {
+    this.score = 10 + frame.rolls[0];
+  }
+
+  scoreWithStrikeBonus(frame1, frame2) {
+    if (frame1.strike() && frame2 !== undefined) {
+      this.score = 20 + frame2.rolls[0];
+    } else if (!frame1.strike()) {
+      this.score = 10 + frame1.rolls[0] + frame1.rolls[1];
+    }
+  }
+
+  #pinsDown() {
+    return this.rolls.reduce(
+      (sum, pins) => sum += pins, 0)
+  }
+}
+
+module.exports = Frame;

api/src/scorecard.js

@@ -0,0 +1,63 @@
+const Frame = require('./frame');
+
+class Scorecard {
+  constructor() {
+    this.frames = [];
+  }
+
+  addFrame() {
+    const rolls = Array.from(arguments);
+    const frame = new Frame(rolls);
+    this.frames.push(frame);
+    this.#updateScores()
+  }
+
+  currentScore() {
+    return this.calculateScoreUpTo(this.frames.length);
+  }
+
+  calculateScoreUpTo(i) {
+    return this.frames.slice(0, i + 1)
+    .map((frame) => frame.getFrameScore())
+    .reduce((sum, num) => sum += num, 0)
+  }
+
+  show() {
+    let scoresArray = []
+    const framesLength = this.frames.length;
+
+    for(let i = 0 ; i < framesLength ; i ++) {
+      const currentFrame = this.frames[i]
+      const frameData = {
+        "rolls": currentFrame.rolls,
+        "score": this.calculateScoreUpTo(i)
+      }
+
+      scoresArray.push(frameData);
+    }
+
+    return {"scorecard": scoresArray}
+  }
+
+  #updateScores() {
+    for(let i = 0 ; i < this.frames.length - 1 ; i++) {
+      const currentFrame = this.frames[i]
+      const frameScore = currentFrame.getFrameScore()
+
+      if (frameScore !==null) {
+        continue
+      }
+
+      const nextFrame = this.frames[i + 1]
+      const frameAfterNext = this.frames[i + 2]
+
+      if (currentFrame.spare()) {
+        currentFrame.scoreWithSpareBonus(nextFrame);
+      } else if (currentFrame.strike()) {
+        currentFrame.scoreWithStrikeBonus(nextFrame, frameAfterNext)
+      }
+    }
+  }
+}
+
+module.exports = Scorecard;

api/tests/frame.test.js

@@ -0,0 +1,148 @@
+const Frame = require('../src/frame');
+
+describe('Frame', () => {
+  it('constructs a zero frame', () => {
+    frame = new Frame([0, 0]);
+
+    expect(frame.rolls).toEqual([0, 0]);
+    expect(frame.getFrameScore()).toEqual(0);
+  })
+
+  it('finds score of a simple frame', () => {
+    frame = new Frame([1, 2]);
+
+    expect(frame.rolls).toEqual([1, 2]);
+    expect(frame.getFrameScore()).toEqual(3);
+  })
+
+  it('recognises a spare', () => {
+    frame = new Frame([4, 6]);
+    frame2 = new Frame([4, 5]);
+
+    expect(frame.spare()).toEqual(true);
+    expect(frame2.spare()).toEqual(false);
+  })
+
+  it('recognises a strike', () => {
+    frame = new Frame([10]);
+
+    expect(frame.spare()).toEqual(false);
+    expect(frame.strike()).toEqual(true);
+  })
+
+  it('scores a spare or strike as null', () => {
+    frame = new Frame([10]);
+    frame2 = new Frame([8, 2]);
+
+    expect(frame.getFrameScore()).toEqual(null);
+    expect(frame2.getFrameScore()).toEqual(null);
+  })
+
+
+  describe('scoring a spare frame', () => {
+    it('updates spare score once next roll is 0', () => {
+      frame = new Frame([4, 6])
+      frame2 = new Frame([0, 0])
+
+      frame.scoreWithSpareBonus(frame2)
+      expect(frame.getFrameScore()).toEqual(10)
+    })
+
+    it('updates spare score once next roll is 4', () => {
+      frame = new Frame([4, 6])
+      frame2 = new Frame([4, 0])
+
+      expect(frame.getFrameScore()).toEqual(null)
+      frame.scoreWithSpareBonus(frame2)
+      expect(frame.getFrameScore()).toEqual(14)
+    })
+
+    it('updates spare score once next roll is strike', () => {
+      frame = new Frame([4, 6])
+      frame2 = new Frame([10])
+
+      expect(frame.getFrameScore()).toEqual(null)
+      frame.scoreWithSpareBonus(frame2)
+      expect(frame.getFrameScore()).toEqual(20)
+    })
+  })
+
+  describe('scoring a strike frame', () => {
+    it('updates the score when followed by zero frame', () => {
+      frame = new Frame([10])
+      frame2 = new Frame([0, 0])
+
+      expect(frame.getFrameScore()).toEqual(null)
+      frame.scoreWithStrikeBonus(frame2, undefined)
+      expect(frame.getFrameScore()).toEqual(10)
+    })
+
+    it('updates the score when followed by simple frame', () => {
+      frame = new Frame([10])
+      frame2 = new Frame([2, 2])
+
+      expect(frame.getFrameScore()).toEqual(null)
+      frame.scoreWithStrikeBonus(frame2, undefined)
+      expect(frame.getFrameScore()).toEqual(14)
+    })
+
+    it('updates the score when followed by a spare', () => {
+      frame = new Frame([10])
+      frame2 = new Frame([2, 8])
+
+      expect(frame.getFrameScore()).toEqual(null)
+      frame.scoreWithStrikeBonus(frame2, undefined)
+      expect(frame.getFrameScore()).toEqual(20)
+    })
+
+    it('does not update the score when followed by a strike', () => {
+      frame = new Frame([10])
+      frame2 = new Frame([10])
+
+      frame.scoreWithStrikeBonus(frame2, undefined)
+      expect(frame.getFrameScore()).toEqual(null)
+    })
+
+    it('updates the score when followed by a strike then zero', () => {
+      frame = new Frame([10])
+      frame2 = new Frame([10])
+      frame3 = new Frame([0, 5])
+      frame.scoreWithStrikeBonus(frame2, frame3)
+
+      expect(frame.getFrameScore()).toEqual(20)
+    })
+
+    it('updates the score when followed by a strike then simplle frame', () => {
+      frame = new Frame([10])
+      frame2 = new Frame([10])
+      frame3 = new Frame([2, 5])
+      frame.scoreWithStrikeBonus(frame2, frame3)
+
+      expect(frame.getFrameScore()).toEqual(22)
+    })
+
+    it('updates the score when followed by two strikes', () => {
+      frame = new Frame([10])
+      frame2 = new Frame([10])
+      frame3 = new Frame([10])
+      frame.scoreWithStrikeBonus(frame2, frame3)
+
+      expect(frame.getFrameScore()).toEqual(30)
+    })
+  })
+
+  describe('final frame', () => {
+    it('scores a spare on final frame', () => {
+      frame = new Frame([3, 7, 4])
+      frame2 = new Frame([5, 5, 0])
+
+      expect(frame.getFrameScore()).toEqual(14)
+      expect(frame2.getFrameScore()).toEqual(10)
+    })
+
+    it('scores a strike on final frame', () => {
+      frame = new Frame([10, 5, 5])
+      expect(frame.getFrameScore()).toEqual(20)
+    })
+  })
+})