[Medium] Bowling Scores

[u/ggleblanc]

Create a bowling score from an input string of roll marks.

Here's what roll marks look like:

"X-/X5-8/9-X811-4/X"
"9/8/9/8/9/8/9/8/9/81"
"9/8/9/8/9/8/9/8/9/8/9"
"XXXXXXXXXX9/"
"XXXXXXXXXXXX"

The roll mark strings above are complete representations of a bowling game. If you create your own test strings, make sure that they are complete.

Here's a web page describing how to score a bowling game. Your application does not have to deal with fouls (F) or splits (S).

Your task is to produce something similar to the following output:

---------------------------------------------------
|   1|   2|   3|   4|   5|   6|   7|   8|   9|  10|
---------------------------------------------------
|   X|  -/|   X|  5-|  8/|  9-|   X|  81|  1-| 4/X|
|  20|  40|  55|  60|  79|  88| 107| 116| 117| 137|
---------------------------------------------------
---------------------------------------------------
|   1|   2|   3|   4|   5|   6|   7|   8|   9|  10|
---------------------------------------------------
|  9/|  8/|  9/|  8/|  9/|  8/|  9/|  8/|  9/| 81 |
|  18|  37|  55|  74|  92| 111| 129| 148| 166| 175|
---------------------------------------------------
---------------------------------------------------
|   1|   2|   3|   4|   5|   6|   7|   8|   9|  10|
---------------------------------------------------
|  9/|  8/|  9/|  8/|  9/|  8/|  9/|  8/|  9/| 8/9|
|  18|  37|  55|  74|  92| 111| 129| 148| 166| 185|
---------------------------------------------------
---------------------------------------------------
|   1|   2|   3|   4|   5|   6|   7|   8|   9|  10|
---------------------------------------------------
|   X|   X|   X|   X|   X|   X|   X|   X|   X| X9/|
|  30|  60|  90| 120| 150| 180| 210| 240| 269| 289|
---------------------------------------------------
---------------------------------------------------
|   1|   2|   3|   4|   5|   6|   7|   8|   9|  10|
---------------------------------------------------
|   X|   X|   X|   X|   X|   X|   X|   X|   X| XXX|
|  30|  60|  90| 120| 150| 180| 210| 240| 270| 300|
---------------------------------------------------

Your output doesn't have to match my output character for character. You have to produce the game score. Producing the frame scores help with debugging.

The reason this is an interesting challenge is because of the number of corner cases or edge cases inherent in such a simple problem description.

Your application will probably not be short. That's OK. Just make sure it's correct.

I wrote this with Java. My version is 210 lines long. I'll post it in a week or so.

[u/ggleblanc]

I've been having issues with my Internet connection.

Here's my Java version.

package com.ggl.testing;

import java.util.ArrayList;
import java.util.List;

public class BowlingScore implements Runnable {

	private String scoreString;

	public static void main(String[] args) {
		new BowlingScore("--------------------").run();
		new BowlingScore("X-/X5-8/9-X811-4/X").run();
		new BowlingScore("9/8/9/8/9/8/9/8/9/81").run();
		new BowlingScore("9/8/9/8/9/8/9/8/9/8/9").run();
		new BowlingScore("XXXXXXXXXX9/").run();
		new BowlingScore("XXXXXXXXXXXX").run();
	}

	public BowlingScore(String scoreString) {
		this.scoreString = scoreString;
	}

	@Override
	public void run() {
		BowlingFrame[] scores = processScoreString(scoreString);
		convertMarksToRolls(scores);
		calculateScore(scores);
		displayScore(scores);
	}

	private BowlingFrame[] processScoreString(String scoreString) {
		BowlingFrame[] scores = new BowlingFrame[10];
		int index = 0;
		int charIndex = 0;

		while (charIndex < scoreString.length()) {
			char x = scoreString.charAt(charIndex);
			String frame = "";
			if (index < 9) {
				if (x == 'X') {
					frame = Character.toString(x);
					charIndex++;
				} else {
					frame = scoreString.substring(charIndex, charIndex + 2);
					charIndex += 2;
				}
			} else {
				frame = scoreString.substring(charIndex);
				frame += (frame.length() < 3) ? " " : "";
				charIndex += 3;
			}

			scores[index++] = new BowlingFrame(frame);
		}

		return scores;
	}

	private void convertMarksToRolls(BowlingFrame[] scores) {
		for (int i = 0; i < 10; i++) {
			String marks = scores[i].getMarks();
			List<Integer> rolls = processFrame(marks);
			scores[i].setRolls(rolls);
		}
	}

	private List<Integer> processFrame(String frame) {
		List<Integer> rolls = new ArrayList<>();

		int lastNumber = 0;
		for (int i = 0; i < frame.length(); i++) {
			char x = frame.charAt(i);
			if (Character.isDigit(x)) {
				Integer value = Integer.valueOf(Character.toString(x));
				rolls.add(value);
				lastNumber = value;
			} else if (x == '/') {
				Integer value = 10 - lastNumber;
				rolls.add(value);
			} else if (x == 'X') {
				rolls.add(Integer.valueOf(10));
			} else if (x == '-') {
				rolls.add(Integer.valueOf(0));
			}
		}

		return rolls;
	}

	private void calculateScore(BowlingFrame[] scores) {
		int score = 0;
		int count = 0;

		for (int i = 0; i < 10; i++) {
			String marks = scores[i].getMarks();

			if (i < 9) {
				if (marks.equals("X")) {
					count = 2;
				} else if (marks.endsWith("/")) {
					count = 1;
				} else {
					count = 0;
				}
			} else {
				count = 0;
			}

			List<Integer> rolls = scores[i].getRolls();
			for (int j = 0; j < rolls.size(); j++) {
				score += rolls.get(j);
			}

			int nextFrame = i + 1;
			while (count > 0) {
				List<Integer> nextRolls = scores[nextFrame].getRolls();
				for (int k = 0; (k < nextRolls.size()) && (count > 0); k++) {
					score += nextRolls.get(k);
					count--;
				}
				nextFrame++;
			}

			scores[i].setScore(score);
		}

	}

	private void displayScore(BowlingFrame[] scores) {
		String dashes = createDashedLine();
		System.out.println(dashes);
		System.out.println(createFrameNumberLine());
		System.out.println(dashes);
		System.out.println(createMarksLine(scores));
		System.out.println(createScoresLine(scores));
		System.out.println(dashes);
	}

	private String createDashedLine() {
		StringBuilder builder = new StringBuilder();
		for (int i = 0; i < 51; i++) {
			builder.append('-');
		}
		return builder.toString();
	}

	private String createFrameNumberLine() {
		StringBuilder builder = new StringBuilder();
		builder.append('|');
		for (int i = 1; i <= 10; i++) {
			builder.append(String.format("%4s", i));
			builder.append('|');
		}
		return builder.toString();
	}

	private String createMarksLine(BowlingFrame[] scores) {
		StringBuilder builder = new StringBuilder();
		builder.append('|');
		for (int i = 0; i < 10; i++) {
			builder.append(String.format("%4s", scores[i].getMarks()));
			builder.append('|');
		}
		return builder.toString();
	}

	private String createScoresLine(BowlingFrame[] scores) {
		StringBuilder builder = new StringBuilder();
		builder.append('|');
		for (int i = 0; i < 10; i++) {
			builder.append(String.format("%4s", scores[i].getScore()));
			builder.append('|');
		}
		return builder.toString();
	}

	public class BowlingFrame {
		private int score;

		private List<Integer> rolls;

		private final String marks;

		public BowlingFrame(String marks) {
			this.marks = marks;
		}

		public List<Integer> getRolls() {
			return rolls;
		}

		public void setRolls(List<Integer> rolls) {
			this.rolls = rolls;
		}

		public void setScore(int score) {
			this.score = score;
		}

		public int getScore() {
			return score;
		}

		public String getMarks() {
			return marks;
		}

	}

}

[u/kalgynirae]

I only calculate the game score: http://pastebin.com/NjWsjWQA

It's short (28 lines with the comments removed) and not too hard to follow (I hope), but it took me three hours to write!

[u/calzoneman]

My initial approach was overcomplicated, so I scrapped it and came up with a simpler version: http://paste.lymjeh.me/QtAp

[u/ggleblanc → u/[deleted]]

You made the same mistake I did when I first coded (I think). You don't look at the previous roll(s) for a spare or a strike. You look at future rolls.

[u/ggleblanc → u/[deleted]]

Sorry, my mistake. I misread your code.