go-counting: add new exercise (#1351)

* go-counting: add new exercise

* go-counting: add new exercise

* go-counting: add new exercise

* go-counting: add new exercise

* go-counting: add exercise

* go-counting: add new exercise

config.json

@@ -1091,6 +1091,19 @@
     },
     {
       "core": false,
+      "difficulty": 7,
+      "slug": "go-counting",
+      "topics": [
+        "algorithms",
+        "loops",
+        "conditionals",
+        "games"
+      ],
+      "unlocked_by": "scrabble-score",
+      "uuid": "2e760ae2-fadd-4d31-9639-c4554e2826e9"
+    },
+    {
+      "core": false,
       "difficulty": 8,
       "slug": "ocr-numbers",
       "topics": [

exercises/go-counting/.meta/src/reference/java/GoCounting.java

@@ -0,0 +1,152 @@
+import java.awt.Point;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Set;
+
+class GoCounting {
+	private Player[][] board;
+	
+	GoCounting (String boardString) {
+		String[] lines = boardString.split("\n");
+		
+		board = new Player[lines[0].length()][lines.length];
+		
+		for (int i = 0; i < lines.length; i++) {
+			for (int j = 0; j < lines[i].length(); j++) {
+				if (lines[i].charAt(j) == 'B') {
+					board[j][i] = Player.BLACK;
+				} else if (lines[i].charAt(j) == 'W') {
+					board[j][i] = Player.WHITE;
+				} else {
+					board[j][i] = Player.NONE;
+				}
+			}
+		}
+	}
+	
+	private ArrayList<Point> getAdjacent(Point p) {
+		ArrayList<Point> adjacent = new ArrayList<>();
+		if (p.x > 0) {
+			adjacent.add(new Point(p.x - 1, p.y));
+		}
+		if (p.x < board.length - 1) {
+			adjacent.add(new Point(p.x + 1, p.y)); 
+		}
+		if (p.y > 0) {
+			adjacent.add(new Point(p.x, p.y - 1));
+		}
+		if (p.y < board[0].length - 1) {
+			adjacent.add(new Point(p.x, p.y + 1));
+		}
+		return adjacent;
+	}
+	
+	Player getTerritoryOwner(int x, int y) {
+		
+		if (x < 0 || x >= board.length || y < 0 || y >= board[0].length) {
+			throw new IllegalArgumentException("Invalid coordinate");
+		}
+		
+		if (board[x][y] == Player.BLACK || board[x][y] == Player.WHITE) {
+			return Player.NONE;
+		}
+		
+		ArrayList<Point> visited = new ArrayList<>();
+		ArrayList<Point> edges = new ArrayList<>();
+		ArrayList<Point> territory = new ArrayList<>();
+		
+		ArrayList<Point> tovisit = new ArrayList<>();
+		
+		tovisit.add(new Point(x, y));
+		
+		while (tovisit.size() > 0) {
+			Point current = tovisit.remove(0);
+			
+			if (board[current.x][current.y] == Player.NONE) {
+				visited.add(current);
+				territory.add(current);
+				
+				ArrayList<Point> adjacent = getAdjacent(current);
+				
+				for (Point p : adjacent) {
+					if (!visited.contains(p) && !tovisit.contains(p)) {
+						tovisit.add(p);
+					}
+				}
+			} else {
+				edges.add(current);
+			}
+		}
+		
+		if (edges.size() == 0) {
+			return Player.NONE;
+		}
+		
+		Player owner = board[edges.get(0).x][edges.get(0).y];
+		for (int i = 0; i < edges.size(); i++) {
+			if (owner != board[edges.get(i).x][edges.get(i).y]) {
+				owner = Player.NONE;
+			}
+		}
+		
+		return owner;
+	}
+	
+	Set<Point> getTerritory(int x, int y) {
+		
+		if (x < 0 || x >= board.length || y < 0 || y >= board[0].length) {
+			throw new IllegalArgumentException("Invalid coordinate");
+		}
+		
+		ArrayList<Point> visited = new ArrayList<>();
+		HashSet<Point> territory = new HashSet<>();
+		
+		ArrayList<Point> tovisit = new ArrayList<>();
+		
+		tovisit.add(new Point(x, y));
+		
+		while (tovisit.size() > 0) {
+			Point current = tovisit.remove(0);
+			
+			if (board[current.x][current.y] == Player.NONE) {
+				visited.add(current);
+				territory.add(current);
+				
+				ArrayList<Point> adjacent = getAdjacent(current);
+				
+				for (Point p : adjacent) {
+					if (!visited.contains(p) && !tovisit.contains(p)) {
+						tovisit.add(p);
+					}
+				}
+			}
+		}
+		
+		return territory;
+	}
+	
+	HashMap<String, Set<Point>> getTerritories() {
+		HashMap<String, Set<Point>> territories = new HashMap<String, Set<Point>>();
+		
+		territories.put("WHITE", new HashSet<Point>());
+		territories.put("BLACK", new HashSet<Point>());
+		territories.put("NONE", new HashSet<Point>());
+		
+		for (int i = 0; i < board[0].length; i++) {
+			for (int j = 0; j < board.length; j++) {
+				if (board[j][i] == Player.NONE) {
+					if (getTerritoryOwner(j, i) == Player.NONE) {
+						territories.get("NONE").add(new Point(j, i));
+					} else if (getTerritoryOwner(j, i) == Player.BLACK) {
+						territories.get("BLACK").add(new Point(j, i));
+					} else {
+						territories.get("WHITE").add(new Point(j, i));
+					}
+				}
+			}
+		}
+		
+		return territories;
+	}
+}

exercises/go-counting/.meta/src/reference/java/Player.java

@@ -0,0 +1,3 @@
+enum Player {
+    NONE, BLACK, WHITE
+}

exercises/go-counting/.meta/version

@@ -0,0 +1,2 @@
+1.0.0
+

exercises/go-counting/README.md

@@ -0,0 +1,50 @@
+# Go Counting
+
+Count the scored points on a Go board.
+
+In the game of go (also known as baduk, igo, cờ vây and wéiqí) points
+are gained by completely encircling empty intersections with your
+stones. The encircled intersections of a player are known as its
+territory.
+
+Write a function that determines the territory of each player. You may
+assume that any stones that have been stranded in enemy territory have
+already been taken off the board.
+
+Write a function that determines the territory which includes a specified coordinate.
+
+Multiple empty intersections may be encircled at once and for encircling
+only horizontal and vertical neighbours count. In the following diagram
+the stones which matter are marked "O" and the stones that don't are
+marked "I" (ignored).  Empty spaces represent empty intersections.
+
+```text
++----+
+|IOOI|
+|O  O|
+|O OI|
+|IOI |
++----+
+```
+
+To be more precise an empty intersection is part of a player's territory
+if all of its neighbours are either stones of that player or empty
+intersections that are part of that player's territory.
+
+For more information see
+[wikipedia](https://en.wikipedia.org/wiki/Go_%28game%29) or [Sensei's
+Library](http://senseis.xmp.net/).
+
+# Running the tests
+
+You can run all the tests for an exercise by entering
+
+```sh
+$ gradle test
+```
+
+in your terminal.
+
+## Submitting Incomplete Solutions
+
+It's possible to submit an incomplete solution so you can see how others have completed the exercise.

exercises/go-counting/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/go-counting/src/main/java/Player.java

@@ -0,0 +1,3 @@
+enum Player {
+    NONE, BLACK, WHITE
+}

exercises/go-counting/src/test/java/GoCountingTest.java

@@ -0,0 +1,178 @@
+import org.junit.Ignore;
+import org.junit.Test;
+
+import java.awt.Point;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Set;
+
+import static org.junit.Assert.assertEquals;
+
+import org.junit.Rule;
+import org.junit.rules.ExpectedException;
+
+public class GoCountingTest {
+	
+	@Rule
+	public ExpectedException expectedException = ExpectedException.none(); 
+	
+	String board5x5 = "  B  \n" +
+	                  " B B \n" +
+	                  "B W B\n" +
+	                  " W W \n" +
+	                  "  W  ";
+	
+	@Test
+	public void blackCorner5x5BoardTest() {
+		GoCounting gocounting = new GoCounting(board5x5);
+		
+		Set<Point> territory = new HashSet<>();
+		territory.add(new Point(0, 0));
+		territory.add(new Point(0, 1));
+		territory.add(new Point(1, 0));
+		
+		assertEquals(Player.BLACK, gocounting.getTerritoryOwner(0, 1));
+		assertEquals(territory, gocounting.getTerritory(0, 1));
+	}
+	
+	@Ignore("Remove to run test")
+	@Test
+	public void whiteCenter5x5BoardTest() {
+		GoCounting gocounting = new GoCounting(board5x5);
+		
+		Set<Point> territory = new HashSet<>();
+		territory.add(new Point(2, 3));
+		
+		assertEquals(Player.WHITE, gocounting.getTerritoryOwner(2, 3));
+		assertEquals(territory, gocounting.getTerritory(2, 3));
+	}
+	
+	@Ignore("Remove to run test")
+	@Test
+	public void openCorner5x5BoardTest() {
+		GoCounting gocounting = new GoCounting(board5x5);
+		
+		Set<Point> territory = new HashSet<>();
+		territory.add(new Point(0, 3));
+		territory.add(new Point(0, 4));
+		territory.add(new Point(1, 4));
+		
+		assertEquals(Player.NONE, gocounting.getTerritoryOwner(1, 4));
+		assertEquals(territory, gocounting.getTerritory(1, 4));
+	}
+	
+	@Ignore("Remove to run test")
+	@Test
+	public void stoneNotTerritory5x5Board() {
+		GoCounting gocounting = new GoCounting(board5x5);
+		
+		Set<Point> territory = new HashSet<>();
+		
+		assertEquals(Player.NONE, gocounting.getTerritoryOwner(1, 1));
+		assertEquals(territory, gocounting.getTerritory(1, 1));
+	}
+	
+	@Ignore("Remove to run test")
+	@Test
+	public void invalidXTooLow5x5Board() {
+		GoCounting gocounting = new GoCounting(board5x5);
+		
+		expectedException.expect(IllegalArgumentException.class);
+		expectedException.expectMessage("Invalid coordinate");
+		
+		gocounting.getTerritory(-1, 1);
+	}
+	
+	@Ignore("Remove to run test")
+	@Test
+	public void invalidXTooHigh5x5Board() {
+		GoCounting gocounting = new GoCounting(board5x5);
+		
+		expectedException.expect(IllegalArgumentException.class);
+		expectedException.expectMessage("Invalid coordinate");
+		
+		gocounting.getTerritory(5, 1);
+	}
+	
+	@Ignore("Remove to run test")
+	@Test
+	public void invalidYTooLow5x5Board() {
+		GoCounting gocounting = new GoCounting(board5x5);
+		
+		expectedException.expect(IllegalArgumentException.class);
+		expectedException.expectMessage("Invalid coordinate");
+		
+		gocounting.getTerritory(1, -1);
+	}
+	
+	@Ignore("Remove to run test")
+	@Test
+	public void invalidYTooHigh5x5Board() {
+		GoCounting gocounting = new GoCounting(board5x5);
+		
+		expectedException.expect(IllegalArgumentException.class);
+		expectedException.expectMessage("Invalid coordinate");
+		
+		gocounting.getTerritory(1, 5);
+	}
+	
+	@Ignore("Remove to run test")
+	@Test
+	public void oneTerritoryIsWholeBoardTest() {
+		GoCounting gocounting = new GoCounting(" ");
+		
+		HashMap<String, Set<Point>> territories = new HashMap<>();
+		Set<Point> blackTerritory = new HashSet<>();
+		Set<Point> whiteTerritory = new HashSet<>();
+		Set<Point> noneTerritory = new HashSet<>();
+		noneTerritory.add(new Point(0, 0));
+		
+		territories.put("BLACK", blackTerritory);
+		territories.put("WHITE", whiteTerritory);
+		territories.put("NONE", noneTerritory);
+		
+		assertEquals(territories, gocounting.getTerritories());
+	}
+	
+	@Ignore("Remove to run test")
+	@Test
+	public void twoTerritoryRectangularBoardTest() {
+		GoCounting gocounting = new GoCounting(" BW \n BW ");
+		
+		Set<Point> blackTerritory = new HashSet<>();
+		blackTerritory.add(new Point(0, 0));
+		blackTerritory.add(new Point(0, 1));
+		
+		Set<Point> whiteTerritory = new HashSet<>();
+		whiteTerritory.add(new Point(3, 0));
+		whiteTerritory.add(new Point(3, 1));
+		
+		Set<Point> noneTerritory = new HashSet<>();
+		
+		HashMap<String, Set<Point>> territories = new HashMap<>();
+		territories.put("BLACK", blackTerritory);
+		territories.put("WHITE", whiteTerritory);
+		territories.put("NONE", noneTerritory);
+		
+		assertEquals(territories, gocounting.getTerritories());
+	}
+	
+	@Ignore("Remove to run test")
+	@Test
+	public void twoRegionRectangularBoardTest() {
+		GoCounting gocounting = new GoCounting(" B ");
+		
+		HashMap<String, Set<Point>> territories = new HashMap<>();
+		Set<Point> blackTerritory = new HashSet<>();
+		blackTerritory.add(new Point(0, 0));
+		blackTerritory.add(new Point(2, 0));
+		Set<Point> whiteTerritory = new HashSet<>();
+		Set<Point> noneTerritory = new HashSet<>();
+		
+		territories.put("BLACK", blackTerritory);
+		territories.put("WHITE", whiteTerritory);
+		territories.put("NONE", noneTerritory);
+		
+		assertEquals(territories, gocounting.getTerritories());
+	}
+}

exercises/settings.gradle

@@ -31,6 +31,7 @@ include 'flatten-array'
 include 'food-chain'
 include 'forth'
 include 'gigasecond'
+include 'go-counting'
 include 'grade-school'
 include 'hamming'
 include 'hexadecimal'