trackler 2.2.1.61 → 2.2.1.62

data/tracks/python/exercises/connect/example.py

@@ -0,0 +1,61 @@
+
+class ConnectGame:
+
+    directions = [(0, 1), (0, -1), (1, 0), (-1, 0), (1, -1), (-1, 1)]
+    white = "O"
+    black = "X"
+    none = ""
+
+    def __init__(self, lines):
+        self.board = self.make_board(lines)
+        assert len(self.board) > 0
+
+        self.width = len(self.board[0])
+        self.height = len(self.board)
+        assert self.width > 0 and self.height > 0
+
+        for l in self.board:
+            assert len(l) == self.width
+
+    def valid(self, x, y):
+        return x >= 0 and x < self.width and y >= 0 and y < self.height
+
+    def make_board(self, lines):
+        return ["".join(l.split()) for l in lines.splitlines()]
+
+    def player_reach_dest(self, player, x, y):
+        if player == self.black:
+            return x == self.width - 1
+        if player == self.white:
+            return y == self.height - 1
+
+    def walk_board(self, player, x, y, visited=[]):
+        if (x, y) in visited:
+            return False
+
+        if (not self.valid(x, y)) or self.board[y][x] != player:
+            return False
+
+        if self.player_reach_dest(player, x, y):
+            return True
+
+        for d in self.directions:
+            if self.walk_board(player, x + d[0], y + d[1], visited + [(x, y)]):
+                return True
+
+    def check_player_is_winner(self, player):
+        if player == self.black:
+            for y in range(self.height):
+                if self.walk_board(player, 0, y):
+                    return True
+        if player == self.white:
+            for x in range(self.width):
+                if self.walk_board(player, x, 0):
+                    return True
+
+    def get_winner(self):
+        if self.check_player_is_winner(self.black):
+            return self.black
+        if self.check_player_is_winner(self.white):
+            return self.white
+        return self.none

data/tracks/python/exercises/go-counting/README.md

@@ -0,0 +1,44 @@
+# 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.
+
+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.
+
+```
++----+
+|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/).
+
+## Submitting Exercises
+
+Note that, when trying to submit an exercise, make sure the solution is in the `exercism/python/<exerciseName>` directory.
+
+For example, if you're submitting `bob.py` for the Bob exercise, the submit command would be something like `exercism submit <path_to_exercism_dir>/python/bob/bob.py`.
+
+## Submitting Incomplete Solutions
+It's possible to submit an incomplete solution so you can see how others have completed the
+exercise.

data/tracks/python/exercises/go-counting/example.py

@@ -0,0 +1,62 @@
+
+BLACK = "B"
+WHITE = "W"
+NONE = ""
+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])
+        self.height = len(self.board)
+
+    def valid(self, x, y):
+        return x >= 0 and x < self.width and y >= 0 and y < self.height
+
+    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 STONES:
+                if s not in visited_stones:
+                    return (visited_territory, visited_stones + [s])
+            else:  # s is empty
+                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]
+
+        return (visited_territory, visited_stones)
+
+    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 STONES:
+            return (NONE, set())
+
+        visited_territory, visited_stones = self.walk(x, y)
+        result = set(visited_territory)
+
+        if len(visited_stones) == 1:
+            return (visited_stones[0], result)
+        return (NONE, result)
+
+    def territories(self):
+        owners = STONES + [NONE]
+        result = dict([(owner, set()) for owner in owners])
+        visited = set()
+        for y in range(self.height):
+            for x in range(self.width):
+                if not (x, y) in visited:
+                    owner, owned_territories = self.territoryFor((x, y))
+                    result[owner].update(owned_territories)
+                    visited.update(owned_territories)
+
+        return result

data/tracks/python/exercises/go-counting/go_counting.py

@@ -0,0 +1,38 @@
+
+class Board:
+    """Count territories of each player in a Go game
+
+    Args:
+        board (list[str]): A two-dimensional Go board
+    """
+
+    def __init__(self, board):
+        pass
+
+    def territoryFor(self, coord):
+        """Find the owner and the territories given a coordinate on
+           the board
+
+        Args:
+            coord ((int,int)): Coordinate on the board
+
+        Returns:
+            (str, set): A tuple, the first element being the owner
+                        of that area.  One of "W", "B", "".  The
+                        second being a set of coordinates, representing
+                        the owner's territories.
+        """
+        pass
+
+    def territories(self):
+        """Find the owners and the territories of the whole board
+
+        Args:
+            none
+
+        Returns:
+            dict(str, set): A dictionary whose key being the owner
+                        , i.e. "W", "B", "".  The value being a set
+                        of coordinates owned by the owner.
+        """
+        pass

data/tracks/python/exercises/go-counting/go_counting_test.py

@@ -0,0 +1,92 @@
+import unittest
+import gocounting
+
+
+# Tests adapted from `problem-specifications//canonical-data.json` @ v1.1.0
+
+board5x5 = "\n".join([
+    "  B  ",
+    " B B ",
+    "B W B",
+    " W W ",
+    "  W  "
+])
+
+board9x9 = "\n".join([
+    "  B   B  ",
+    "B   B   B",
+    "WBBBWBBBW",
+    "W W W W W",
+    "         ",
+    " W W W W ",
+    "B B   B B",
+    " W BBB W ",
+    "   B B   "
+])
+
+
+class GoCountingTest(unittest.TestCase):
+    def test_5x5_for_black(self):
+        board = gocounting.Board(board5x5)
+        stone, territory = board.territoryFor((0, 1))
+        self.assertEqual(stone, gocounting.BLACK)
+        self.assertEqual(territory, set([(0, 0), (0, 1), (1, 0)]))
+
+    def test_5x5_for_white(self):
+        board = gocounting.Board(board5x5)
+        stone, territory = board.territoryFor((2, 3))
+        self.assertEqual(stone, gocounting.WHITE)
+        self.assertEqual(territory, set([(2, 3)]))
+
+    def test_5x5_for_open_territory(self):
+        board = gocounting.Board(board5x5)
+        stone, territory = board.territoryFor((1, 4))
+        self.assertEqual(stone, gocounting.NONE)
+        self.assertEqual(territory, set([(0, 3), (0, 4), (1, 4)]))
+
+    def test_5x5_for_non_territory(self):
+        board = gocounting.Board(board5x5)
+        stone, territory = board.territoryFor((1, 1))
+        self.assertEqual(stone, gocounting.NONE)
+        self.assertEqual(territory, set())
+
+    def test_5x5_for_valid_coordinate(self):
+        board = gocounting.Board(board5x5)
+        stone, territory = board.territoryFor((-1, 1))
+        self.assertEqual(stone, gocounting.NONE)
+        self.assertEqual(territory, set())
+
+    def test_5x5_for_valid_coordinate2(self):
+        board = gocounting.Board(board5x5)
+        stone, territory = board.territoryFor((1, 5))
+        self.assertEqual(stone, gocounting.NONE)
+        self.assertEqual(territory, set())
+
+    def test_one_territory_whole_board(self):
+        board = gocounting.Board(" ")
+        territories = board.territories()
+        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.Board(input_board)
+        territories = board.territories()
+        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.Board(board9x9)
+        stone, territory = board.territoryFor((0, 8))
+        self.assertEqual(stone, gocounting.NONE)
+        self.assertEqual(territory,
+                         set([(2, 7), (2, 8), (1, 8), (0, 8), (0, 7)]))
+
+
+if __name__ == '__main__':
+    unittest.main()

data/tracks/python/exercises/parallel-letter-frequency/README.md

@@ -0,0 +1,24 @@
+# Parallel Letter Frequency
+
+Count the frequency of letters in texts using parallel computation.
+
+Parallelism is about doing things in parallel that can also be done
+sequentially. A common example is counting the frequency of letters.
+Create a function that returns the total frequency of each letter in a
+list of texts and that employs parallelism.
+
+The letters used consists of ASCII letters `a` to `z`, inclusive, and is case
+insensitive.
+
+## Submitting Exercises
+
+Note that, when trying to submit an exercise, make sure the solution is in the `exercism/python/<exerciseName>` directory.
+
+For example, if you're submitting `bob.py` for the Bob exercise, the submit command would be something like `exercism submit <path_to_exercism_dir>/python/bob/bob.py`.
+
+
+For more detailed information about running tests, code style and linting,
+please see the [help page](http://exercism.io/languages/python).
+
+## Submitting Incomplete Solutions
+It's possible to submit an incomplete solution so you can see how others have completed the exercise.

data/tracks/python/exercises/parallel-letter-frequency/example.py

@@ -0,0 +1,56 @@
+# -*- coding: utf-8 -*-
+from collections import Counter
+from threading import Lock, Thread
+from time import sleep
+import sys
+if sys.version[0] == '2':
+    from Queue import Queue
+else:
+    from queue import Queue
+
+total_workers = 3  # Maximum number of threads chosen arbitrarily
+
+
+class LetterCounter(object):
+
+    def __init__(self):
+        self.lock = Lock()
+        self.value = Counter()
+
+    def add_counter(self, counter_to_add):
+        self.lock.acquire()
+        try:
+            self.value = self.value + counter_to_add
+        finally:
+            self.lock.release()
+
+
+def count_letters(queue_of_texts, letter_to_frequency, worker_id):
+    while not queue_of_texts.empty():
+        sleep(worker_id + 1)
+        line_input = queue_of_texts.get()
+        if line_input is not None:
+            letters_in_line = Counter([x for x in line_input.lower() if
+                                       x.isalpha()])
+            letter_to_frequency.add_counter(letters_in_line)
+        queue_of_texts.task_done()
+        if line_input is None:
+            break
+
+
+def calculate(list_of_texts):
+    queue_of_texts = Queue()
+    [queue_of_texts.put(line) for line in list_of_texts]
+    letter_to_frequency = LetterCounter()
+    threads = []
+    for i in range(total_workers):
+        worker = Thread(target=count_letters, args=(queue_of_texts,
+                                                    letter_to_frequency, i))
+        worker.start()
+        threads.append(worker)
+    queue_of_texts.join()
+    for i in range(total_workers):
+        queue_of_texts.put(None)
+    for t in threads:
+        t.join()
+    return letter_to_frequency.value

data/tracks/python/exercises/parallel-letter-frequency/parallel_letter_frequency.py

@@ -0,0 +1,2 @@
+def calculate(text_input):
+    pass

data/tracks/python/exercises/parallel-letter-frequency/parallel_letter_frequency_test.py

@@ -0,0 +1,61 @@
+# -*- coding: utf-8 -*-
+from collections import Counter
+import unittest
+
+from parallel_letter_frequency import calculate
+
+
+class ParallelLetterFrequencyTest(unittest.TestCase):
+    def test_one_letter(self):
+        actual = calculate(['a'])
+        expected = {'a': 1}
+        self.assertDictEqual(actual, expected)
+
+    def test_case_insensitivity(self):
+        actual = calculate(['aA'])
+        expected = {'a': 2}
+        self.assertDictEqual(actual, expected)
+
+    def test_numbers(self):
+        actual = calculate(['012', '345', '6789'])
+        expected = {}
+        self.assertDictEqual(actual, expected)
+
+    def test_punctuations(self):
+        actual = calculate(['[]\;,', './{}|', ':"<>?'])
+        expected = {}
+        self.assertDictEqual(actual, expected)
+
+    def test_whitespaces(self):
+        actual = calculate(['  ', '\t ', '\n\n'])
+        expected = {}
+        self.assertDictEqual(actual, expected)
+
+    def test_repeated_string_with_known_frequencies(self):
+        letter_frequency = 3
+        text_input = 'abc\n' * letter_frequency
+        actual = calculate(text_input.split('\n'))
+        expected = {'a': letter_frequency, 'b': letter_frequency,
+                    'c': letter_frequency}
+        self.assertDictEqual(actual, expected)
+
+    def test_multiline_text(self):
+        text_input = "3 Quotes from Excerism Homepage:\n" + \
+                     "\tOne moment you feel like you're\n" + \
+                     "getting it. The next moment you're\n" + \
+                     "stuck.\n" + \
+                     "\tYou know what it’s like to be fluent.\n" + \
+                     "Suddenly you’re feeling incompetent\n" + \
+                     "and clumsy.\n" + \
+                     "\tHaphazard, convoluted code is\n" + \
+                     "infuriating, not to mention costly. That\n" + \
+                     "slapdash explosion of complexity is an\n" + \
+                     "expensive yak shave waiting to\n" + \
+                     "happen."
+        actual = calculate(text_input.split('\n'))
+        expected = Counter([x for x in text_input.lower() if x.isalpha()])
+        self.assertDictEqual(actual, expected)
+
+
+if __name__ == '__main__':
+    unittest.main()