trackler 2.2.1.127 → 2.2.1.128

data/tracks/python/exercises/pascals-triangle/pascals_triangle_test.py

@@ -1,37 +1,51 @@
 import unittest
 
-from pascals_triangle import triangle, row, is_triangle
+from pascals_triangle import rows
+
+
+# Tests adapted from `problem-specifications//canonical-data.json` @ v1.2.0
+
+TRIANGLE = [
+    [1],
+    [1, 1],
+    [1, 2, 1],
+    [1, 3, 3, 1],
+    [1, 4, 6, 4, 1],
+    [1, 5, 10, 10, 5, 1],
+    [1, 6, 15, 20, 15, 6, 1],
+    [1, 7, 21, 35, 35, 21, 7, 1],
+    [1, 8, 28, 56, 70, 56, 28, 8, 1],
+    [1, 9, 36, 84, 126, 126, 84, 36, 9, 1]
+]
 
 
 class PascalsTriangleTest(unittest.TestCase):
-    def test_triangle1(self):
-        ans = ['1', '1 1', '1 2 1', '1 3 3 1', '1 4 6 4 1']
-        self.assertEqual(triangle(4), ans)
-
-    def test_triangle2(self):
-        ans = ['1', '1 1', '1 2 1', '1 3 3 1', '1 4 6 4 1', '1 5 10 10 5 1',
-               '1 6 15 20 15 6 1']
-        self.assertEqual(triangle(6), ans)
-
-    def test_is_triangle_true(self):
-        inp = ['1', '1 1', '1 2 1', '1 3 3 1', '1 4 6 4 1', '1 5 10 10 5 1']
-        self.assertIs(is_triangle(inp), True)
-
-    def test_is_triangle_false(self):
-        inp = ['1', '1 1', '1 2 1', '1 4 4 1']
-        self.assertIs(is_triangle(inp), False)
-
-    def test_row1(self):
-        ans = '1'
-        self.assertEqual(row(0), ans)
-
-    def test_row2(self):
-        ans = '1 2 1'
-        self.assertEqual(row(2), ans)
-
-    def test_row3(self):
-        ans = '1 7 21 35 35 21 7 1'
-        self.assertEqual(row(7), ans)
+    def test_zero_rows(self):
+        self.assertEqual(rows(0), [])
+
+    def test_single_row(self):
+        self.assertEqual(rows(1), TRIANGLE[:1])
+
+    def test_two_rows(self):
+        self.assertEqual(rows(2), TRIANGLE[:2])
+
+    def test_three_rows(self):
+        self.assertEqual(rows(3), TRIANGLE[:3])
+
+    def test_four_rows(self):
+        self.assertEqual(rows(4), TRIANGLE[:4])
+
+    def test_five_rows(self):
+        self.assertEqual(rows(5), TRIANGLE[:5])
+
+    def test_six_rows(self):
+        self.assertEqual(rows(6), TRIANGLE[:6])
+
+    def test_ten_rows(self):
+        self.assertEqual(rows(10), TRIANGLE[:10])
+
+    def test_negative_rows(self):
+        self.assertEqual(rows(-1), None)
 
 
 if __name__ == '__main__':

data/tracks/python/exercises/sgf-parsing/README.md

@@ -0,0 +1,110 @@
+# SGF Parsing
+
+Parsing a Smart Game Format string.
+
+[SGF](https://en.wikipedia.org/wiki/Smart_Game_Format) is a standard format for
+storing board game files, in particular go.
+
+SGF is a fairly simple format. An SGF file usually contains a single
+tree of nodes where each node is a property list. The property list
+contains key value pairs, each key can only occur once but may have
+multiple values.
+
+An SGF file may look like this:
+
+```text
+(;FF[4]C[root]SZ[19];B[aa];W[ab])
+```
+
+This is a tree with three nodes:
+
+- The top level node has two properties: FF\[4\] (key = "FF", value =
+  "4") and C\[root\](key = "C", value = "root"). (FF indicates the
+  version of SGF and C is a comment.)
+  - The top level node has a single child which has a single property:
+    B\[aa\].  (Black plays on the point encoded as "aa", which is the
+    1-1 point (which is a stupid place to play)).
+    - The B\[aa\] node has a single child which has a single property:
+      W\[ab\].
+
+As you can imagine an SGF file contains a lot of nodes with a single
+child, which is why there's a shorthand for it.
+
+SGF can encode variations of play. Go players do a lot of backtracking
+in their reviews (let's try this, doesn't work, let's try that) and SGF
+supports variations of play sequences. For example:
+
+```text
+(;FF[4](;B[aa];W[ab])(;B[dd];W[ee]))
+```
+
+Here the root node has two variations. The first (which by convention
+indicates what's actually played) is where black plays on 1-1. Black was
+sent this file by his teacher who pointed out a more sensible play in
+the second child of the root node: `B[dd]` (4-4 point, a very standard
+opening to take the corner).
+
+A key can have multiple values associated with it. For example:
+
+```text
+(;FF[4];AB[aa][ab][ba])
+```
+
+Here `AB` (add black) is used to add three black stones to the board.
+
+There are a few more complexities to SGF (and parsing in general), which
+you can mostly ignore. You should assume that the input is encoded in
+UTF-8, the tests won't contain a charset property, so don't worry about
+that. Furthermore you may assume that all newlines are unix style (`\n`,
+no `\r` or `\r\n` will be in the tests) and that no optional whitespace
+between properties, nodes, etc will be in the tests.
+
+The exercise will have you parse an SGF string and return a tree
+structure of properties. You do not need to encode knowledge about the
+data types of properties, just use the rules for the
+[text](http://www.red-bean.com/sgf/sgf4.html#text) type everywhere.
+
+## Exception messages
+
+Sometimes it is necessary to raise an exception. When you do this, you should include a meaningful error message to
+indicate what the source of the error is. This makes your code more readable and helps significantly with debugging. Not
+every exercise will require you to raise an exception, but for those that do, the tests will only pass if you include
+a message.
+
+To raise a message with an exception, just write it as an argument to the exception type. For example, instead of
+`raise Exception`, you should write:
+
+```python
+raise Exception("Meaningful message indicating the source of the error")
+```
+
+## Running the tests
+
+To run the tests, run the appropriate command below ([why they are different](https://github.com/pytest-dev/pytest/issues/1629#issue-161422224)):
+
+- Python 2.7: `py.test sgf_parsing_test.py`
+- Python 3.3+: `pytest sgf_parsing_test.py`
+
+Alternatively, you can tell Python to run the pytest module (allowing the same command to be used regardless of Python version):
+`python -m pytest sgf_parsing_test.py`
+
+### Common `pytest` options
+
+- `-v` : enable verbose output
+- `-x` : stop running tests on first failure
+- `--ff` : run failures from previous test before running other test cases
+
+For other options, see `python -m pytest -h`
+
+## Submitting Exercises
+
+Note that, when trying to submit an exercise, make sure the solution is in the `$EXERCISM_WORKSPACE/python/sgf-parsing` directory.
+
+You can find your Exercism workspace by running `exercism debug` and looking for the line that starts with `Workspace`.
+
+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/sgf-parsing/example.py

@@ -0,0 +1,100 @@
+class SgfTree(object):
+    def __init__(self, properties=None, children=None):
+        self.properties = properties or {}
+        self.children = children or []
+
+    def __eq__(self, other):
+        if not isinstance(other, SgfTree):
+            return False
+        for k, v in self.properties.items():
+            if k not in other.properties:
+                return False
+            if other.properties[k] != v:
+                return False
+        for k in other.properties.keys():
+            if k not in self.properties:
+                return False
+        if len(self.children) != len(other.children):
+            return False
+        for a, b in zip(self.children, other.children):
+            if not (a == b):
+                return False
+        return True
+
+    def __repr__(self):
+        """Ironically, encoding to SGF is much easier"""
+        rep = '(;'
+        for k, vs in self.properties.items():
+            rep += k
+            for v in vs:
+                rep += '[{}]'.format(v)
+        if self.children:
+            if len(self.children) > 1:
+                rep += '('
+            for c in self.children:
+                rep += repr(c)[1:-1]
+            if len(self.children) > 1:
+                rep += ')'
+        return rep + ')'
+
+
+def is_upper(s):
+    a, z = map(ord, 'AZ')
+    return all(
+        a <= o and o <= z
+        for o in map(ord, s)
+    )
+
+
+def parse(input_string):
+    root = None
+    current = None
+    stack = list(input_string)
+
+    def assert_that(condition):
+        if not condition:
+            raise ValueError(
+                'invalid format at {}:{}: {}'.format(
+                    repr(input_string),
+                    len(input_string) - len(stack),
+                    repr(''.join(stack))
+                )
+            )
+    assert_that(stack)
+
+    def pop():
+        if stack[0] == '\\':
+            stack.pop(0)
+        ch = stack.pop(0)
+        return ' ' if ch in '\n\t' else ch
+
+    def peek():
+        return stack[0]
+
+    def pop_until(ch):
+        v = ''
+        while peek() != ch:
+            v += pop()
+        return v
+    while stack:
+        assert_that(pop() == '(' and peek() == ';')
+        while pop() == ';':
+            properties = {}
+            while is_upper(peek()):
+                key = pop_until('[')
+                assert_that(is_upper(key))
+                values = []
+                while peek() == '[':
+                    pop()
+                    values.append(pop_until(']'))
+                    pop()
+                properties[key] = values
+            if root is None:
+                current = root = SgfTree(properties)
+            else:
+                current = SgfTree(properties)
+                root.children.append(current)
+            while peek() == '(':
+                child_input = pop() + pop_until(')') + pop()
+                current.children.append(parse(child_input))
+    return root

data/tracks/python/exercises/sgf-parsing/sgf_parsing.py

@@ -0,0 +1,26 @@
+class SgfTree(object):
+    def __init__(self, properties=None, children=None):
+        self.properties = properties or {}
+        self.children = children or []
+
+    def __eq__(self, other):
+        if not isinstance(other, SgfTree):
+            return False
+        for k, v in self.properties.items():
+            if k not in other.properties:
+                return False
+            if other.properties[k] != v:
+                return False
+        for k in other.properties.keys():
+            if k not in self.properties:
+                return False
+        if len(self.children) != len(other.children):
+            return False
+        for a, b in zip(self.children, other.children):
+            if a != b:
+                return False
+        return True
+
+
+def parse(input_string):
+    pass

data/tracks/python/exercises/sgf-parsing/sgf_parsing_test.py

@@ -0,0 +1,94 @@
+import unittest
+
+from sgf_parsing import parse, SgfTree
+
+
+class SgfParsingTest(unittest.TestCase):
+    def test_empty_input(self):
+        input_string = ''
+        with self.assertRaisesWithMessage(ValueError):
+            parse(input_string)
+
+    def test_tree_with_no_nodes(self):
+        input_string = '()'
+        with self.assertRaisesWithMessage(ValueError):
+            parse(input_string)
+
+    def test_node_without_tree(self):
+        input_string = ';'
+        with self.assertRaisesWithMessage(ValueError):
+            parse(input_string)
+
+    def test_node_without_properties(self):
+        input_string = '(;)'
+        expected = SgfTree()
+        self.assertEqual(parse(input_string), expected)
+
+    def test_single_node_tree(self):
+        input_string = '(;A[B])'
+        expected = SgfTree(properties={'A': ['B']})
+        self.assertEqual(parse(input_string), expected)
+
+    def test_properties_without_delimiter(self):
+        input_string = '(;a)'
+        with self.assertRaisesWithMessage(ValueError):
+            parse(input_string)
+
+    def test_all_lowercase_property(self):
+        input_string = '(;a[b])'
+        with self.assertRaisesWithMessage(ValueError):
+            parse(input_string)
+
+    def test_upper_and_lowercase_property(self):
+        input_string = '(;Aa[b])'
+        with self.assertRaisesWithMessage(ValueError):
+            parse(input_string)
+
+    def test_two_nodes(self):
+        input_string = '(;A[B];B[C])'
+        expected = SgfTree(
+            properties={'A': ['B']},
+            children=[
+                SgfTree({'B': ['C']})
+            ]
+        )
+        self.assertEqual(parse(input_string), expected)
+
+    def test_two_child_trees(self):
+        input_string = '(;A[B](;B[C])(;C[D]))'
+        expected = SgfTree(
+            properties={'A': ['B']},
+            children=[
+                SgfTree({'B': ['C']}),
+                SgfTree({'C': ['D']}),
+            ]
+        )
+        self.assertEqual(parse(input_string), expected)
+
+    def test_multiple_property_values(self):
+        input_string = '(;A[b][c][d])'
+        expected = SgfTree(
+            properties={'A': ['b', 'c', 'd']}
+        )
+        self.assertEqual(parse(input_string), expected)
+
+    def test_escaped_property(self):
+        input_string = '(;A[\]b\nc\nd\t\te \n\]])'
+        expected = SgfTree(
+            properties={'A': [']b c d  e  ]']}
+        )
+        self.assertEqual(parse(input_string), expected)
+
+    # Utility functions
+    def setUp(self):
+        try:
+            self.assertRaisesRegex
+        except AttributeError:
+            self.assertRaisesRegex = self.assertRaisesRegexp
+
+    def assertRaisesWithMessage(self, exception):
+        return self.assertRaisesRegex(exception, r".+")
+
+
+if __name__ == '__main__':
+    unittest.main()

data/tracks/typescript/config.json

@@ -142,7 +142,7 @@
         "searching",
         "strings"
       ],
-      "uuid": "a2c7abe7-b487-4cc2-a86a-d97cdd61709d"
+      "uuid": "721d9c74-cc16-4b32-8f0b-ffab75027539"
     },
     {
       "core": false,

data/tracks/typescript/exercises/pangram/pangram.example.ts

@@ -2,7 +2,7 @@ const aToZ =  [...Array<string>(26)].map( ( _ , index) => {
     return String.fromCharCode(index + 65)
  })
 
- class Panagram {
+ class Pangram {
      value: string
      constructor(input: string = "") {
          this.value = input
@@ -29,4 +29,4 @@ const aToZ =  [...Array<string>(26)].map( ( _ , index) => {
      }
 }
 
-export default Panagram
+export default Pangram

data/tracks/typescript/exercises/pangram/pangram.test.ts

@@ -1,7 +1,6 @@
 import Pangram from './pangram'
 
 describe('Pangram()', () => {
-
   it('empty sentence', () => {
     const pangram = new Pangram('')
     expect(pangram.isPangram()).toBe(false)
@@ -46,5 +45,4 @@ describe('Pangram()', () => {
     const pangram = new Pangram("Victor jagt zwölf Boxkämpfer quer über den großen Sylter Deich.")
     expect(pangram.isPangram()).toBe(true)
   })
-
 })

data/tracks/typescript/exercises/pangram/pangram.ts

@@ -1,11 +0,0 @@
-class Pangram {
-    constructor( /* Parameters go here */ ) {
-        // Your code here
-    }
-
-    isPangram() {
-        // Your code here
-    }
-}
-
-export default Pangram

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: trackler
 version: !ruby/object:Gem::Version
-  version: 2.2.1.127
+  version: 2.2.1.128
 platform: ruby
 authors:
 - Katrina Owen
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-04-02 00:00:00.000000000 Z
+date: 2018-04-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rubyzip
@@ -7916,7 +7916,7 @@ files:
 - tracks/java/exercises/pythagorean-triplet/build.gradle
 - tracks/java/exercises/pythagorean-triplet/src/main/java/.keep
 - tracks/java/exercises/pythagorean-triplet/src/test/java/PythagoreanTripletTest.java
-- tracks/java/exercises/queen-attack/.meta/src/reference/java/BoardCoordinate.java
+- tracks/java/exercises/queen-attack/.meta/src/reference/java/Queen.java
 - tracks/java/exercises/queen-attack/.meta/src/reference/java/QueenAttackCalculator.java
 - tracks/java/exercises/queen-attack/.meta/version
 - tracks/java/exercises/queen-attack/README.md
@@ -11549,6 +11549,10 @@ files:
 - tracks/python/exercises/atbash-cipher/atbash_cipher.py
 - tracks/python/exercises/atbash-cipher/atbash_cipher_test.py
 - tracks/python/exercises/atbash-cipher/example.py
+- tracks/python/exercises/bank-account/README.md
+- tracks/python/exercises/bank-account/bank_account.py
+- tracks/python/exercises/bank-account/bank_account_test.py
+- tracks/python/exercises/bank-account/example.py
 - tracks/python/exercises/beer-song/README.md
 - tracks/python/exercises/beer-song/beer_song.py
 - tracks/python/exercises/beer-song/beer_song_test.py
@@ -11892,6 +11896,10 @@ files:
 - tracks/python/exercises/series/example.py
 - tracks/python/exercises/series/series.py
 - tracks/python/exercises/series/series_test.py
+- tracks/python/exercises/sgf-parsing/README.md
+- tracks/python/exercises/sgf-parsing/example.py
+- tracks/python/exercises/sgf-parsing/sgf_parsing.py
+- tracks/python/exercises/sgf-parsing/sgf_parsing_test.py
 - tracks/python/exercises/sieve/README.md
 - tracks/python/exercises/sieve/example.py
 - tracks/python/exercises/sieve/sieve.py

data/tracks/java/exercises/queen-attack/.meta/src/reference/java/BoardCoordinate.java

@@ -1,39 +0,0 @@
-final class BoardCoordinate {
-
-    private final int row;
-
-    private final int column;
-
-    BoardCoordinate(final int row, final int column) throws IllegalArgumentException {
-        this.row = row;
-        this.column = column;
-
-        validateInputs();
-    }
-
-    int getRow() {
-        return row;
-    }
-
-    int getColumn() {
-        return column;
-    }
-
-    private void validateInputs() throws IllegalArgumentException {
-        validateCoordinateComponent(row, "row");
-        validateCoordinateComponent(column, "column");
-    }
-
-    private void validateCoordinateComponent(final int value, final String componentName)
-            throws IllegalArgumentException {
-
-        if (value < 0) {
-            throw new IllegalArgumentException("Coordinate must have positive " + componentName + ".");
-        }
-
-        if (value > 7) {
-            throw new IllegalArgumentException("Coordinate must have " + componentName + " <= 7.");
-        }
-    }
-
-}