Merge pull request #675 from dawcars/bowling-exercise

bowling: add to track

config.json

@@ -388,6 +388,13 @@
     	]
     },
     {
+    	"slug": "bowling",
+    	"difficulty": 6,
+    	"topics": [
+
+    	]
+    },
+    {
       "slug": "anagram",
       "difficulty": 7,
       "topics": [

exercises/bowling/build.gradle

@@ -0,0 +1,18 @@
+apply plugin: "java"
+apply plugin: "eclipse"
+apply plugin: "idea"
+
+repositories {
+  mavenCentral()
+}
+
+dependencies {
+  testCompile "junit:junit:4.12"
+}
+
+test {
+  testLogging {
+    exceptionFormat = 'full'
+    events = ["passed", "failed", "skipped"]
+  }
+}

exercises/bowling/src/example/java/BowlingGame.java

@@ -0,0 +1,84 @@
+import java.util.ArrayList;
+import java.util.List;
+
+public class BowlingGame {
+    private static final int NUMBER_OF_FRAMES = 10;
+    private static final int MAXIMUM_FRAME_SCORE = 10;
+    private List<Integer> rolls = new ArrayList<Integer>();
+
+    public void roll(int pins) {
+        rolls.add(pins);
+    }
+
+    public int score() {
+        int score = 0;
+        int frameIndex = 0;
+
+        for (int i = 1; i <= NUMBER_OF_FRAMES; i++) {
+            if (rolls.size() <= frameIndex) {
+                throw new IllegalStateException("Score cannot be taken until the end of the game");
+            }
+
+            if (isStrike(frameIndex)) {
+                if (rolls.size() <= frameIndex + 2) {
+                    throw new IllegalStateException("Score cannot be taken until the end of the game");
+                }
+
+                int strikeBonus = strikeBonus(frameIndex);
+                if (strikeBonus > MAXIMUM_FRAME_SCORE && !isStrike(frameIndex + 1)) {
+                    throw new IllegalStateException("Pin count exceeds pins on the lane");
+                }
+
+                score += 10 + strikeBonus;
+                frameIndex += i == NUMBER_OF_FRAMES ? 3 : 1;
+            } else if (isSpare(frameIndex)) {
+                if (rolls.size() <= frameIndex + 2) {
+                    throw new IllegalStateException("Score cannot be taken until the end of the game");
+                }
+
+                score += 10 + spareBonus(frameIndex);
+                frameIndex += i == NUMBER_OF_FRAMES ? 3 : 2;
+            } else {
+                int frameScore = frameScore(frameIndex);
+                if (frameScore < 0) {
+                    throw new IllegalStateException("Negative roll is invalid");
+                } else if (frameScore > 10) {
+                    throw new IllegalStateException("Pin count exceeds pins on the lane");
+                }
+
+                score += frameScore;
+                frameIndex += 2;
+            }
+        }
+
+        if (!correctNumberOfRolls(frameIndex)) {
+            throw new IllegalStateException("Cannot roll after game is over");
+        }
+
+        return score;
+    }
+
+    private boolean correctNumberOfRolls(int frameIndex) {
+        return frameIndex == rolls.size();
+    }
+
+    private boolean isStrike(int frameIndex) {
+        return rolls.get(frameIndex) == MAXIMUM_FRAME_SCORE;
+    }
+
+    private boolean isSpare(int frameIndex) {
+        return rolls.get(frameIndex) + rolls.get(frameIndex + 1) == MAXIMUM_FRAME_SCORE;
+    }
+
+    private int strikeBonus(int frameIndex) {
+        return rolls.get(frameIndex + 1) + rolls.get(frameIndex + 2);
+    }
+
+    private int spareBonus(int frameIndex) {
+        return rolls.get(frameIndex + 2);
+    }
+
+    private int frameScore(int frameIndex) {
+        return rolls.get(frameIndex) + rolls.get(frameIndex + 1);
+    }
+}

exercises/bowling/src/test/java/BowlingTest.java

@@ -0,0 +1,291 @@
+import org.junit.Before;
+import org.junit.Ignore;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.rules.ExpectedException;
+
+import static org.junit.Assert.assertEquals;
+
+public class BowlingTest {
+    private BowlingGame game;
+
+    @Rule
+    public ExpectedException expectedException = ExpectedException.none();
+
+    @Before
+    public void setup() {
+        game = new BowlingGame();
+    }
+
+    private void playGame(int[] rolls) {
+        for (int pins : rolls) {
+            game.roll(pins);
+        }
+    }
+
+    @Test
+    public void shouldBeAbleToScoreAGameWithAllZeros() {
+        int[] rolls = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
+
+        playGame(rolls);
+        assertEquals(0, game.score());
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void shouldBeAbleToScoreAGameWithNoStrikesOrSpares() {
+        int[] rolls = {3, 6, 3, 6, 3, 6, 3, 6, 3, 6, 3, 6, 3, 6, 3, 6, 3, 6, 3, 6};
+
+        playGame(rolls);
+        assertEquals(90, game.score());
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void aSpareFollowedByZerosIsWorthTenPoints() {
+        int[] rolls = {6, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
+
+        playGame(rolls);
+        assertEquals(10, game.score());
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void pointsScoredInTheRollAfterASpareAreCountedTwice() {
+        int[] rolls = {6, 4, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
+
+        playGame(rolls);
+        assertEquals(16, game.score());
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void consecutiveSparesEachGetAOneRollBonus() {
+        int[] rolls = {5, 5, 3, 7, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
+
+        playGame(rolls);
+        assertEquals(31, game.score());
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void aSpareInTheLastFrameGetsAOneRollBonusThatIsCountedOnce() {
+        int[] rolls = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 3, 7};
+
+        playGame(rolls);
+        assertEquals(17, game.score());
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void aStrikeEarnsTenPointsInFrameWithASingleRoll() {
+        int[] rolls = {10, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
+
+        playGame(rolls);
+        assertEquals(10, game.score());
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void pointsScoredInTheTwoRollsAfterAStrikeAreCountedTwiceAsABonus() {
+        int[] rolls = {10, 5, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
+
+        playGame(rolls);
+        assertEquals(26, game.score());
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void consecutiveStrikesEachGetTheTwoRollBonus() {
+        int[] rolls = {10, 10, 10, 5, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
+
+        playGame(rolls);
+        assertEquals(81, game.score());
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void aStrikeInTheLastFrameGetsATwoRollBonusThatIsCountedOnce() {
+        int[] rolls = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 7, 1};
+
+        playGame(rolls);
+        assertEquals(18, game.score());
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void rollingASpareWithTheTwoRollBonusDoesNotGetABonusRoll() {
+        int[] rolls = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 7, 3};
+
+        playGame(rolls);
+        assertEquals(20, game.score());
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void strikesWithTheTwoRollBonusDoNotGetBonusRolls() {
+        int[] rolls = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 10, 10};
+
+        playGame(rolls);
+        assertEquals(30, game.score());
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void aStrikeWithTheOneRollBonusAfterASpareInTheLastFrameDoesNotGetABonus() {
+        int[] rolls = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 3, 10};
+
+        playGame(rolls);
+        assertEquals(20, game.score());
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void allStrikesIsAPerfectGame() {
+        int[] rolls = {10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10};
+
+        playGame(rolls);
+        assertEquals(300, game.score());
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void rollsCanNotScoreNegativePoints() throws IllegalStateException {
+        int[] rolls = {-1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
+
+        playGame(rolls);
+
+        expectedException.expect(IllegalStateException.class);
+        expectedException.expectMessage("Negative roll is invalid");
+
+        game.score();
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void aRollCanNotScoreMoreThan10Points() throws IllegalStateException {
+        int[] rolls = {11, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
+
+        playGame(rolls);
+
+        expectedException.expect(IllegalStateException.class);
+        expectedException.expectMessage("Pin count exceeds pins on the lane");
+
+        game.score();
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void twoRollsInAFrameCanNotScoreMoreThan10Points() throws IllegalStateException {
+        int[] rolls = {5, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
+
+        playGame(rolls);
+
+        expectedException.expect(IllegalStateException.class);
+        expectedException.expectMessage("Pin count exceeds pins on the lane");
+
+        game.score();
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void twoBonusRollsAfterAStrikeInTheLastFrameCanNotScoreMoreThan10Points() throws IllegalStateException {
+        int[] rolls = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 5, 6};
+
+        playGame(rolls);
+
+        expectedException.expect(IllegalStateException.class);
+        expectedException.expectMessage("Pin count exceeds pins on the lane");
+
+        game.score();
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void twoBonusRollsAfterAStrikeInTheLastFrameCanScoreMoreThan10PointsIfOneIsAStrike() throws IllegalStateException {
+        int[] rolls = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 10, 6};
+
+        playGame(rolls);
+
+        assertEquals(26, game.score());
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void anUnstartedGameCanNotBeScored() throws IllegalStateException {
+        int[] rolls = new int[0];
+
+        playGame(rolls);
+
+        expectedException.expect(IllegalStateException.class);
+        expectedException.expectMessage("Score cannot be taken until the end of the game");
+
+        game.score();
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void anIncompleteGameCanNotBeScored() throws IllegalStateException {
+        int[] rolls = {0, 0};
+
+        playGame(rolls);
+
+        expectedException.expect(IllegalStateException.class);
+        expectedException.expectMessage("Score cannot be taken until the end of the game");
+
+        game.score();
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void aGameWithMoreThanTenFramesCanNotBeScored() throws IllegalStateException {
+        int[] rolls = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
+
+        playGame(rolls);
+
+        expectedException.expect(IllegalStateException.class);
+        expectedException.expectMessage("Cannot roll after game is over");
+
+        game.score();
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void bonusRollsForAStrikeInTheLastFrameMustBeRolledBeforeScoreCanBeCalculated() throws IllegalStateException {
+        int[] rolls = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10};
+
+        playGame(rolls);
+
+        expectedException.expect(IllegalStateException.class);
+        expectedException.expectMessage("Score cannot be taken until the end of the game");
+
+        game.score();
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void bothBonusRollsForAStrikeInTheLastFrameMustBeRolledBeforeScoreCanBeCalculated() throws IllegalStateException {
+        int[] rolls = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 10};
+
+        playGame(rolls);
+
+        expectedException.expect(IllegalStateException.class);
+        expectedException.expectMessage("Score cannot be taken until the end of the game");
+
+        game.score();
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void bonusRollForASpareInTheLastFrameMustBeRolledBeforeScoreCanBeCalculated() throws IllegalStateException {
+        int[] rolls = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 3};
+
+        playGame(rolls);
+
+        expectedException.expect(IllegalStateException.class);
+        expectedException.expectMessage("Score cannot be taken until the end of the game");
+
+        game.score();
+    }
+
+}

exercises/settings.gradle

@@ -11,6 +11,7 @@ include 'binary-search'
 include 'binary-search-tree'
 include 'bob'
 include 'book-store'
+include 'bowling'
 include 'bracket-push'
 include 'change'
 include 'clock'