trackler 2.2.1.127 → 2.2.1.128

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

@@ -1,14 +1,13 @@
 final class QueenAttackCalculator {
 
-    private final BoardCoordinate whiteQueenCoordinate;
+    private final Queen whiteQueen;
 
-    private final BoardCoordinate blackQueenCoordinate;
+    private final Queen blackQueen;
 
-    QueenAttackCalculator(final BoardCoordinate whiteQueenCoordinate, final BoardCoordinate blackQueenCoordinate)
-            throws IllegalArgumentException {
+    QueenAttackCalculator(final Queen whiteQueen, final Queen blackQueen) {
 
-        this.whiteQueenCoordinate = whiteQueenCoordinate;
-        this.blackQueenCoordinate = blackQueenCoordinate;
+        this.whiteQueen = whiteQueen;
+        this.blackQueen = blackQueen;
 
         validateInputs();
     }
@@ -17,13 +16,13 @@ final class QueenAttackCalculator {
         return queensShareColumn() || queensShareRow() || queensShareDiagonal();
     }
 
-    private void validateInputs() throws IllegalArgumentException {
-        if (whiteQueenCoordinate == null || blackQueenCoordinate == null) {
-            throw new IllegalArgumentException("You must supply valid board coordinates for both Queens.");
+    private void validateInputs() {
+        if (whiteQueen == null || blackQueen == null) {
+            throw new IllegalArgumentException("You must supply valid positions for both Queens.");
         }
 
         if (queensShareBoardCoordinate()) {
-            throw new IllegalArgumentException("Queens may not occupy the same board coordinate.");
+            throw new IllegalArgumentException("Queens cannot occupy the same position.");
         }
     }
 
@@ -44,11 +43,11 @@ final class QueenAttackCalculator {
     }
 
     private int differenceBetweenRows() {
-        return Math.abs(whiteQueenCoordinate.getRow() - blackQueenCoordinate.getRow());
+        return Math.abs(whiteQueen.getRow() - blackQueen.getRow());
     }
 
     private int differenceBetweenColumns() {
-        return Math.abs(whiteQueenCoordinate.getColumn() - blackQueenCoordinate.getColumn());
+        return Math.abs(whiteQueen.getColumn() - blackQueen.getColumn());
     }
 
 }

data/tracks/java/exercises/queen-attack/.meta/version

@@ -1 +1 @@
-2.0.0
+2.1.0

data/tracks/java/exercises/queen-attack/src/test/java/QueenAttackCalculatorTest.java

@@ -12,119 +12,125 @@ public class QueenAttackCalculatorTest {
     public ExpectedException expectedException = ExpectedException.none();
 
     @Test
-    public void testQueensThatDoNotShareRowColumnOrDiagonalCannotAttack() {
-        final QueenAttackCalculator calculator
-                = new QueenAttackCalculator(new BoardCoordinate(2, 4), new BoardCoordinate(6, 6));
+    public void testCreateQueenWithAValidPosition() {
+        new Queen(2, 2);
+    }
 
-        assertFalse(calculator.canQueensAttackOneAnother());
+    @Ignore("Remove to run test")
+    @Test
+    public void testCreateQueenMustHavePositiveRow() {
+        expectedException.expect(IllegalArgumentException.class);
+        expectedException.expectMessage("Queen position must have positive row.");
+
+        new Queen(-2, 2);
     }
 
     @Ignore("Remove to run test")
     @Test
-    public void testQueensCanAttackOnTheSameRow() {
-        final QueenAttackCalculator calculator
-                = new QueenAttackCalculator(new BoardCoordinate(2, 4), new BoardCoordinate(2, 6));
+    public void testCreateQueenMustHaveRowOnBoard() {
+        expectedException.expect(IllegalArgumentException.class);
+        expectedException.expectMessage("Queen position must have row <= 7.");
 
-        assertTrue(calculator.canQueensAttackOneAnother());
+        new Queen(8, 4);
     }
 
     @Ignore("Remove to run test")
     @Test
-    public void testQueensCanAttackOnTheSameColumn() {
-        final QueenAttackCalculator calculator
-                = new QueenAttackCalculator(new BoardCoordinate(4, 5), new BoardCoordinate(2, 5));
+    public void testCreateQueenMustHavePositiveColumn() {
+        expectedException.expect(IllegalArgumentException.class);
+        expectedException.expectMessage("Queen position must have positive column.");
 
-        assertTrue(calculator.canQueensAttackOneAnother());
+        new Queen(2, -2);
     }
 
     @Ignore("Remove to run test")
     @Test
-    public void testQueensCanAttackOnFirstDiagonal() {
-        final QueenAttackCalculator calculator
-                = new QueenAttackCalculator(new BoardCoordinate(2, 2), new BoardCoordinate(0, 4));
+    public void testCreateQueenMustHaveColumnOnBoard() {
+        expectedException.expect(IllegalArgumentException.class);
+        expectedException.expectMessage("Queen position must have column <= 7.");
 
-        assertTrue(calculator.canQueensAttackOneAnother());
+        new Queen(4, 8);
     }
 
     @Ignore("Remove to run test")
     @Test
-    public void testQueensCanAttackOnSecondDiagonal() {
+    public void testQueensCannotAttack() {
         final QueenAttackCalculator calculator
-                = new QueenAttackCalculator(new BoardCoordinate(2, 2), new BoardCoordinate(3, 1));
+                = new QueenAttackCalculator(new Queen(2, 4), new Queen(6, 6));
 
-        assertTrue(calculator.canQueensAttackOneAnother());
+        assertFalse(calculator.canQueensAttackOneAnother());
     }
 
     @Ignore("Remove to run test")
     @Test
-    public void testQueensCanAttackOnThirdDiagonal() {
+    public void testQueensCanAttackOnTheSameRow() {
         final QueenAttackCalculator calculator
-                = new QueenAttackCalculator(new BoardCoordinate(2, 2), new BoardCoordinate(1, 1));
+                = new QueenAttackCalculator(new Queen(2, 4), new Queen(2, 6));
 
         assertTrue(calculator.canQueensAttackOneAnother());
     }
 
     @Ignore("Remove to run test")
     @Test
-    public void testQueensCanAttackOnFourthDiagonal() {
+    public void testQueensCanAttackOnTheSameColumn() {
         final QueenAttackCalculator calculator
-                = new QueenAttackCalculator(new BoardCoordinate(2, 2), new BoardCoordinate(5, 5));
+                = new QueenAttackCalculator(new Queen(4, 5), new Queen(2, 5));
 
         assertTrue(calculator.canQueensAttackOneAnother());
     }
 
     @Ignore("Remove to run test")
     @Test
-    public void testCoordinateWithNegativeRowNotAllowed() {
-        expectedException.expect(IllegalArgumentException.class);
-        expectedException.expectMessage("Coordinate must have positive row.");
+    public void testQueensCanAttackOnFirstDiagonal() {
+        final QueenAttackCalculator calculator
+                = new QueenAttackCalculator(new Queen(2, 2), new Queen(0, 4));
 
-        new BoardCoordinate(-2, 2);
+        assertTrue(calculator.canQueensAttackOneAnother());
     }
 
     @Ignore("Remove to run test")
     @Test
-    public void testCoordinateWithRowGreaterThan7NotAllowed() {
-        expectedException.expect(IllegalArgumentException.class);
-        expectedException.expectMessage("Coordinate must have row <= 7.");
+    public void testQueensCanAttackOnSecondDiagonal() {
+        final QueenAttackCalculator calculator
+                = new QueenAttackCalculator(new Queen(2, 2), new Queen(3, 1));
 
-        new BoardCoordinate(8, 4);
+        assertTrue(calculator.canQueensAttackOneAnother());
     }
 
     @Ignore("Remove to run test")
     @Test
-    public void testCoordinateWithNegativeColumnNotAllowed() {
-        expectedException.expect(IllegalArgumentException.class);
-        expectedException.expectMessage("Coordinate must have positive column.");
+    public void testQueensCanAttackOnThirdDiagonal() {
+        final QueenAttackCalculator calculator
+                = new QueenAttackCalculator(new Queen(2, 2), new Queen(1, 1));
 
-        new BoardCoordinate(2, -2);
+        assertTrue(calculator.canQueensAttackOneAnother());
     }
 
     @Ignore("Remove to run test")
     @Test
-    public void testCoordinateWithColumnGreaterThan7NotAllowed() {
-        expectedException.expect(IllegalArgumentException.class);
-        expectedException.expectMessage("Coordinate must have column <= 7.");
+    public void testQueensCanAttackOnFourthDiagonal() {
+        final QueenAttackCalculator calculator
+                = new QueenAttackCalculator(new Queen(2, 2), new Queen(5, 5));
 
-        new BoardCoordinate(4, 8);
+        assertTrue(calculator.canQueensAttackOneAnother());
     }
 
     @Ignore("Remove to run test")
     @Test
-    public void testNullCoordinateNotAllowed() {
+    public void testNullPositionsNotAllowed() {
         expectedException.expect(IllegalArgumentException.class);
-        expectedException.expectMessage("You must supply valid board coordinates for both Queens.");
+        expectedException.expectMessage("You must supply valid positions for both Queens.");
 
-        new QueenAttackCalculator(null, new BoardCoordinate(0, 7));
+        new QueenAttackCalculator(null, new Queen(0, 7));
     }
 
     @Ignore("Remove to run test")
     @Test
     public void testQueensMustNotOccupyTheSameSquare() {
         expectedException.expect(IllegalArgumentException.class);
-        expectedException.expectMessage("Queens may not occupy the same board coordinate.");
+        expectedException.expectMessage("Queens cannot occupy the same position.");
 
-        new QueenAttackCalculator(new BoardCoordinate(2, 2), new BoardCoordinate(2, 2));
+        new QueenAttackCalculator(new Queen(2, 2), new Queen(2, 2));
     }
 
 }

data/tracks/python/config.json

@@ -666,6 +666,18 @@
         "transforming"
       ]
     },
+    {
+      "uuid": "83a3ff95-c043-401c-bc2c-547d52344b02",
+      "slug": "bank-account",
+      "core": false,
+      "unlocked_by": null,
+      "difficulty": 4,
+      "topics": [
+        "classes",
+        "concurrency",
+        "conditionals"
+      ]
+    },
     {
       "uuid": "d41238ce-359c-4a9a-81ea-ca5d2c4bb50d",
       "slug": "twelve-days",
@@ -1305,6 +1317,17 @@
             "lists"
         ]
     },
+    {
+        "uuid": "0d6325d1-c0a3-456e-9a92-cea0559e82ed",
+        "slug": "sgf-parsing",
+        "core": false,
+        "unlocked_by": null,
+        "difficulty": 7,
+        "topics": [
+          "parsing",
+          "trees"
+        ]
+    },
     {
       "uuid": "e7351e8e-d3ff-4621-b818-cd55cf05bffd",
       "slug": "accumulate",
@@ -1365,5 +1388,8 @@
       "slug": "parallel-letter-frequency",
       "deprecated": true
     }
+  ],
+  "foregone": [
+    "lens-person"
   ]
 }

data/tracks/python/exercises/bank-account/README.md

@@ -0,0 +1,53 @@
+# Bank Account
+
+Simulate a bank account supporting opening/closing, withdrawals, and deposits
+of money. Watch out for concurrent transactions!
+
+A bank account can be accessed in multiple ways. Clients can make
+deposits and withdrawals using the internet, mobile phones, etc. Shops
+can charge against the account.
+
+Create an account that can be accessed from multiple threads/processes
+(terminology depends on your programming language).
+
+It should be possible to close an account; operations against a closed
+account must fail.
+
+## Instructions
+
+Run the test file, and fix each of the errors in turn. When you get the
+first test to pass, go to the first pending or skipped test, and make
+that pass as well. When all of the tests are passing, feel free to
+submit.
+
+Remember that passing code is just the first step. The goal is to work
+towards a solution that is as readable and expressive as you can make
+it.
+
+Have fun!
+
+## 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 shold write:
+
+```python
+raise Exception("Meaningful message indicating the source of the error")
+```
+
+## Submitting Exercises
+
+Note that, when trying to submit an exercise, make sure the solution is in the `$EXERCISM_WORKSPACE/python/bank-account` 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/bank-account/bank_account.py

@@ -0,0 +1,18 @@
+class BankAccount(object):
+    def __init__(self):
+        pass
+
+    def get_balance(self):
+        pass
+
+    def open(self):
+        pass
+
+    def deposit(self, amount):
+        pass
+
+    def withdraw(self, amount):
+        pass
+
+    def close(self):
+        pass

data/tracks/python/exercises/bank-account/bank_account_test.py

@@ -0,0 +1,120 @@
+import sys
+import threading
+import time
+import unittest
+
+from bank_account import BankAccount
+
+
+class BankAccountTests(unittest.TestCase):
+
+    def setUp(self):
+        self.account = BankAccount()
+
+    def test_newly_opened_account_has_zero_balance(self):
+        self.account.open()
+        self.assertEqual(self.account.get_balance(), 0)
+
+    def test_can_deposit_money(self):
+        self.account.open()
+        self.account.deposit(100)
+        self.assertEqual(self.account.get_balance(), 100)
+
+    def test_can_deposit_money_sequentially(self):
+        self.account.open()
+        self.account.deposit(100)
+        self.account.deposit(50)
+
+        self.assertEqual(self.account.get_balance(), 150)
+
+    def test_can_withdraw_money(self):
+        self.account.open()
+        self.account.deposit(100)
+        self.account.withdraw(50)
+
+        self.assertEqual(self.account.get_balance(), 50)
+
+    def test_can_withdraw_money_sequentially(self):
+        self.account.open()
+        self.account.deposit(100)
+        self.account.withdraw(20)
+        self.account.withdraw(80)
+
+        self.assertEqual(self.account.get_balance(), 0)
+
+    def test_checking_balance_of_closed_account_throws_error(self):
+        self.account.open()
+        self.account.close()
+
+        with self.assertRaises(ValueError):
+            self.account.get_balance()
+
+    def test_deposit_into_closed_account(self):
+        self.account.open()
+        self.account.close()
+
+        with self.assertRaises(ValueError):
+            self.account.deposit(50)
+
+    def test_withdraw_from_closed_account(self):
+        self.account.open()
+        self.account.close()
+
+        with self.assertRaises(ValueError):
+            self.account.withdraw(50)
+
+    def test_cannot_withdraw_more_than_deposited(self):
+        self.account.open()
+        self.account.deposit(25)
+
+        with self.assertRaises(ValueError):
+            self.account.withdraw(50)
+
+    def test_cannot_withdraw_negative(self):
+        self.account.open()
+        self.account.deposit(100)
+
+        with self.assertRaises(ValueError):
+            self.account.withdraw(-50)
+
+    def test_cannot_deposit_negative(self):
+        self.account.open()
+
+        with self.assertRaises(ValueError):
+            self.account.deposit(-50)
+
+    def test_can_handle_concurrent_transactions(self):
+        self.account.open()
+        self.account.deposit(1000)
+
+        for _ in range(10):
+            self.adjust_balance_concurrently()
+
+    def adjust_balance_concurrently(self):
+        def transact():
+            self.account.deposit(5)
+            time.sleep(0.001)
+            self.account.withdraw(5)
+
+        # Greatly improve the chance of an operation being interrupted
+        # by thread switch, thus testing synchronization effectively
+        try:
+            sys.setswitchinterval(1e-12)
+        except AttributeError:
+            # For Python 2 compatibility
+            sys.setcheckinterval(1)
+
+        threads = []
+        for _ in range(1000):
+            t = threading.Thread(target=transact)
+            threads.append(t)
+            t.start()
+
+        for thread in threads:
+            thread.join()
+
+        self.assertEqual(self.account.get_balance(), 1000)
+
+
+if __name__ == '__main__':
+    unittest.main()

data/tracks/python/exercises/bank-account/example.py

@@ -0,0 +1,35 @@
+import threading
+
+
+class BankAccount(object):
+    def __init__(self):
+        self.is_open = False
+        self.balance = 0
+        self.lock = threading.Lock()
+
+    def get_balance(self):
+        with self.lock:
+            if self.is_open:
+                return self.balance
+            else:
+                raise ValueError
+
+    def open(self):
+        self.is_open = True
+
+    def deposit(self, amount):
+        with self.lock:
+            if self.is_open and amount > 0:
+                self.balance += amount
+            else:
+                raise ValueError
+
+    def withdraw(self, amount):
+        with self.lock:
+            if self.is_open and 0 < amount <= self.balance:
+                self.balance -= amount
+            else:
+                raise ValueError
+
+    def close(self):
+        self.is_open = False

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

@@ -8,7 +8,7 @@ DIRECTIONS = [(0, 1), (0, -1), (1, 0), (-1, 0)]
 
 class Board:
     def __init__(self, board):
-        self.board = board.splitlines()
+        self.board = board
         self.width = len(self.board[0])
         self.height = len(self.board)
 
@@ -35,10 +35,10 @@ class Board:
 
         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:
+    def territory(self, x, y):
+        if not self.valid(x, y):
+            raise ValueError('invalid coordinate')
+        if self.board[y][x] in STONES:
             return (NONE, set())
 
         visited_territory, visited_stones = self.walk(x, y)
@@ -55,7 +55,7 @@ class Board:
         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))
+                    owner, owned_territories = self.territory(x, y)
                     result[owner].update(owned_territories)
                     visited.update(owned_territories)
 

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

@@ -9,12 +9,13 @@ class Board:
     def __init__(self, board):
         pass
 
-    def territoryFor(self, coord):
+    def territory(self, x, y):
         """Find the owner and the territories given a coordinate on
            the board
 
         Args:
-            coord ((int,int)): Coordinate on the board
+            x (int): Column on the board
+            y (int): Row on the board
 
         Returns:
             (str, set): A tuple, the first element being the owner