go-counting: Rename class name & move constants

Author: yunchih

exercises/go-counting/example.py

@@ -1,12 +1,12 @@
 
-class GoCounting:
+BLACK = "B"
+WHITE = "W"
+NONE = ""
+STONES = [BLACK, WHITE]
+DIRECTIONS = [(0, 1), (0, -1), (1, 0), (-1, 0)]
 
-    none = ""
-    white = "W"
-    black = "B"
-    stones = [black, white]
-    directions = [(0, 1), (0, -1), (1, 0), (-1, 0)]
 
+class Board:
     def __init__(self, board):
         self.board = board.splitlines()
         self.width = len(self.board[0])
@@ -15,21 +15,21 @@ def __init__(self, board):
     def valid(self, x, y):
         return x >= 0 and x < self.width and y >= 0 and y < self.height
 
-    def walk_board(self, x, y,
-                   visited_territory=[],
-                   visited_coords=[],
-                   visited_stones=[]):
+    def walk(self, x, y,
+             visited_territory=[],
+             visited_coords=[],
+             visited_stones=[]):
         if not (x, y) in visited_coords and self.valid(x, y):
             s = self.board[y][x]
-            if s in self.stones:
+            if s in STONES:
                 if s not in visited_stones:
                     return (visited_territory, visited_stones + [s])
             else:  # s is empty
-                for d in self.directions:
-                    visited = self.walk_board(x + d[0], y + d[1],
-                                              visited_territory + [(x, y)],
-                                              visited_coords + [(x, y)],
-                                              visited_stones)
+                for d in DIRECTIONS:
+                    visited = self.walk(x + d[0], y + d[1],
+                                        visited_territory + [(x, y)],
+                                        visited_coords + [(x, y)],
+                                        visited_stones)
                     visited_territory = visited[0]
                     visited_stones = visited[1]
 
@@ -38,18 +38,18 @@ def walk_board(self, x, y,
     def territoryFor(self, coord):
         assert len(coord) == 2
         x, y = coord[0], coord[1]
-        if not self.valid(x, y) or self.board[y][x] in self.stones:
-            return (self.none, set())
+        if not self.valid(x, y) or self.board[y][x] in STONES:
+            return (NONE, set())
 
-        visited_territory, visited_stones = self.walk_board(x, y)
+        visited_territory, visited_stones = self.walk(x, y)
         result = set(visited_territory)
 
         if len(visited_stones) == 1:
             return (visited_stones[0], result)
-        return (self.none, result)
+        return (NONE, result)
 
     def territories(self):
-        owners = self.stones + [self.none]
+        owners = STONES + [NONE]
         result = dict([(owner, set()) for owner in owners])
         visited = set()
         for y in range(self.height):

exercises/go-counting/go_counting.py

@@ -1,5 +1,5 @@
 
-class GoCounting:
+class Board:
     """Count territories of each player in a Go game
 
     Args:

exercises/go-counting/go_counting_test.py

@@ -1,6 +1,7 @@
 import unittest
 import gocounting
 
+
 # Tests adapted from `problem-specifications//canonical-data.json` @ v1.1.0
 
 board5x5 = "\n".join([
@@ -26,63 +27,63 @@
 
 class GoCountingTest(unittest.TestCase):
     def test_5x5_for_black(self):
-        board = gocounting.GoCounting(board5x5)
+        board = gocounting.Board(board5x5)
         stone, territory = board.territoryFor((0, 1))
-        self.assertEqual(stone, board.black)
+        self.assertEqual(stone, gocounting.BLACK)
         self.assertEqual(territory, set([(0, 0), (0, 1), (1, 0)]))
 
     def test_5x5_for_white(self):
-        board = gocounting.GoCounting(board5x5)
+        board = gocounting.Board(board5x5)
         stone, territory = board.territoryFor((2, 3))
-        self.assertEqual(stone, board.white)
+        self.assertEqual(stone, gocounting.WHITE)
         self.assertEqual(territory, set([(2, 3)]))
 
     def test_5x5_for_open_territory(self):
-        board = gocounting.GoCounting(board5x5)
+        board = gocounting.Board(board5x5)
         stone, territory = board.territoryFor((1, 4))
-        self.assertEqual(stone, board.none)
+        self.assertEqual(stone, gocounting.NONE)
         self.assertEqual(territory, set([(0, 3), (0, 4), (1, 4)]))
 
     def test_5x5_for_non_territory(self):
-        board = gocounting.GoCounting(board5x5)
+        board = gocounting.Board(board5x5)
         stone, territory = board.territoryFor((1, 1))
-        self.assertEqual(stone, board.none)
+        self.assertEqual(stone, gocounting.NONE)
         self.assertEqual(territory, set())
 
     def test_5x5_for_valid_coordinate(self):
-        board = gocounting.GoCounting(board5x5)
+        board = gocounting.Board(board5x5)
         stone, territory = board.territoryFor((-1, 1))
-        self.assertEqual(stone, board.none)
+        self.assertEqual(stone, gocounting.NONE)
         self.assertEqual(territory, set())
 
     def test_5x5_for_valid_coordinate2(self):
-        board = gocounting.GoCounting(board5x5)
+        board = gocounting.Board(board5x5)
         stone, territory = board.territoryFor((1, 5))
-        self.assertEqual(stone, board.none)
+        self.assertEqual(stone, gocounting.NONE)
         self.assertEqual(territory, set())
 
     def test_one_territory_whole_board(self):
-        board = gocounting.GoCounting(" ")
+        board = gocounting.Board(" ")
         territories = board.territories()
-        self.assertEqual(territories[board.black], set())
-        self.assertEqual(territories[board.white], set())
-        self.assertEqual(territories[board.none], set([(0, 0)]))
+        self.assertEqual(territories[gocounting.BLACK], set())
+        self.assertEqual(territories[gocounting.WHITE], set())
+        self.assertEqual(territories[gocounting.NONE], set([(0, 0)]))
 
     def test_two_territories_rectangular_board(self):
         input_board = "\n".join([
             " BW ",
             " BW "
         ])
-        board = gocounting.GoCounting(input_board)
+        board = gocounting.Board(input_board)
         territories = board.territories()
-        self.assertEqual(territories[board.black], set([(0, 0), (0, 1)]))
-        self.assertEqual(territories[board.white], set([(3, 0), (3, 1)]))
-        self.assertEqual(territories[board.none], set())
+        self.assertEqual(territories[gocounting.BLACK], set([(0, 0), (0, 1)]))
+        self.assertEqual(territories[gocounting.WHITE], set([(3, 0), (3, 1)]))
+        self.assertEqual(territories[gocounting.NONE], set())
 
     def test_9x9_for_open_territory(self):
-        board = gocounting.GoCounting(board9x9)
+        board = gocounting.Board(board9x9)
         stone, territory = board.territoryFor((0, 8))
-        self.assertEqual(stone, board.none)
+        self.assertEqual(stone, gocounting.NONE)
         self.assertEqual(territory,
                          set([(2, 7), (2, 8), (1, 8), (0, 8), (0, 7)]))