trackler 2.2.1.60 → 2.2.1.61

data/tracks/python/exercises/react/README.md

@@ -0,0 +1,30 @@
+# React
+
+Implement a basic reactive system.
+
+Reactive programming is a programming paradigm that focuses on how values
+are computed in terms of each other to allow a change to one value to
+automatically propagate to other values, like in a spreadsheet.
+
+Implement a basic reactive system with cells with settable values ("input"
+cells) and cells with values computed in terms of other cells ("compute"
+cells). Implement updates so that when an input value is changed, values
+propagate to reach a new stable system state.
+
+In addition, compute cells should allow for registering change notification
+callbacks.  Call a cell’s callbacks when the cell’s value in a new stable
+state has changed from the previous stable state.
+
+## 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/react/example.py

@@ -0,0 +1,65 @@
+class Cell(object):
+    def __init__(self, reactor, value=0, dependencies=set(),
+                 updater=None):
+        self.reactor = reactor
+        self.index = len(reactor.cells)
+        reactor.cells.append(self)
+        self.value = value
+        self.dirty = False
+        self.dependencies = dependencies
+        self.dependents = set()
+        self.updater = updater
+        self.watchers = set()
+        if updater is not None:
+            self.update()
+            self.notify()
+
+    def add_watcher(self, watcher):
+        self.watchers.add(watcher)
+
+    def remove_watcher(self, watcher):
+        self.watchers.remove(watcher)
+
+    def set_value(self, value, top=True):
+        self.value = value
+        for d in self.dependents:
+            d.update()
+        if top:
+            self.reactor.notify()
+
+    def update(self):
+        if self.updater is not None:
+            values = [d.value for d in self.dependencies]
+            value = self.updater(values)
+            if self.value != value:
+                self.set_value(value, False)
+                self.dirty = True
+
+    def notify(self):
+        if self.dirty:
+            for watcher in self.watchers:
+                watcher(self, self.value)
+            self.dirty = False
+
+    def __hash__(self):
+        return self.index
+
+
+class Reactor(object):
+    def __init__(self):
+        self.cells = []
+
+    def create_input_cell(self, value):
+        return Cell(self, value=value)
+
+    def create_compute_cell(self, dependencies, updater):
+        cell = Cell(self,
+                    dependencies=dependencies,
+                    updater=updater)
+        for d in dependencies:
+            d.dependents.add(cell)
+        return cell
+
+    def notify(self):
+        for cell in self.cells:
+            cell.notify()

data/tracks/python/exercises/react/react.py

@@ -0,0 +1,17 @@
+class Cell(object):
+    def set_value(value):
+        pass
+
+    def add_watcher(self, watcher_callback):
+        pass
+
+    def remove_watcher(self, watcher_callback):
+        pass
+
+
+class Reactor(object):
+    def create_input_cell(self, value):
+        pass
+
+    def create_compute_cell(self, dependencies, updater_callback):
+        pass

data/tracks/python/exercises/react/react_test.py

@@ -0,0 +1,136 @@
+import unittest
+
+from react import Reactor
+
+
+class CallbackManager(object):
+    counter = 0
+    observed1 = []
+    observed2 = []
+
+    @staticmethod
+    def reset():
+        CallbackManager.counter = 0
+        CallbackManager.observed1 = []
+        CallbackManager.observed2 = []
+
+    @staticmethod
+    def count(sender, value):
+        CallbackManager.counter += 1
+
+    @staticmethod
+    def observe1(sender, value):
+        CallbackManager.observed1.append(value)
+
+    @staticmethod
+    def observe2(sender, value):
+        CallbackManager.observed2.append(value)
+
+
+def increment(values):
+    return values[0] + 1
+
+
+def decrement(values):
+    return values[0] - 1
+
+
+def product(values):
+    return values[0] * values[1]
+
+
+def minimum_of_2(values):
+    return values[0] + 1 if values[0] > 2 else 2
+
+
+class ReactTest(unittest.TestCase):
+    def test_setting_input_changes_value(self):
+        reactor = Reactor()
+        inputCell1 = reactor.create_input_cell(1)
+        self.assertEqual(inputCell1.value, 1)
+        inputCell1.set_value(2)
+        self.assertEqual(inputCell1.value, 2)
+
+    def test_computed_cell_determined_by_dependencies(self):
+        reactor = Reactor()
+        inputCell1 = reactor.create_input_cell(1)
+        computeCell1 = reactor.create_compute_cell({inputCell1}, increment)
+
+        self.assertEqual(computeCell1.value, 2)
+        inputCell1.set_value(2)
+        self.assertEqual(computeCell1.value, 3)
+
+    def test_compute_cells_determined_by_other_compute_cells(self):
+        reactor = Reactor()
+        inputCell1 = reactor.create_input_cell(1)
+        computeCell1 = reactor.create_compute_cell({inputCell1}, increment)
+        computeCell2 = reactor.create_compute_cell({inputCell1}, decrement)
+        computeCell3 = reactor.create_compute_cell({computeCell1,
+                                                    computeCell2},
+                                                   product)
+        self.assertEqual(computeCell3.value, 0)
+        inputCell1.set_value(3)
+        self.assertEqual(computeCell3.value, 8)
+
+    def test_compute_cells_can_have_callbacks(self):
+        reactor = Reactor()
+        inputCell1 = reactor.create_input_cell(1)
+        computeCell1 = reactor.create_compute_cell({inputCell1}, increment)
+        observed = []
+        computeCell1.add_watcher(lambda sender, value: observed.append(value))
+        self.assertEqual(observed, [])
+        inputCell1.set_value(2)
+        self.assertEqual(observed, [3])
+
+    def test_callbacks__only_trigger_on_change(self):
+        reactor = Reactor()
+        inputCell1 = reactor.create_input_cell(1)
+        computeCell1 = reactor.create_compute_cell({inputCell1}, minimum_of_2)
+
+        CallbackManager.reset()
+        computeCell1.add_watcher(CallbackManager.count)
+
+        inputCell1.set_value(1)
+        self.assertEqual(CallbackManager.counter, 0)
+        inputCell1.set_value(2)
+        self.assertEqual(CallbackManager.counter, 0)
+        inputCell1.set_value(3)
+        self.assertEqual(CallbackManager.counter, 1)
+
+    def test_callbacks_can_be_removed(self):
+        reactor = Reactor()
+        inputCell1 = reactor.create_input_cell(1)
+        computeCell1 = reactor.create_compute_cell({inputCell1}, increment)
+
+        CallbackManager.reset()
+        computeCell1.add_watcher(CallbackManager.observe1)
+        computeCell1.add_watcher(CallbackManager.observe2)
+
+        inputCell1.set_value(2)
+        self.assertEqual(CallbackManager.observed1, [3])
+        self.assertEqual(CallbackManager.observed2, [3])
+
+        computeCell1.remove_watcher(CallbackManager.observe1)
+        inputCell1.set_value(3)
+        self.assertEqual(CallbackManager.observed1, [3])
+        self.assertEqual(CallbackManager.observed2, [3, 4])
+
+    def test_callbacks_only_called_once(self):
+        reactor = Reactor()
+        inputCell1 = reactor.create_input_cell(1)
+        computeCell1 = reactor.create_compute_cell({inputCell1}, increment)
+        computeCell2 = reactor.create_compute_cell({inputCell1}, decrement)
+        computeCell3 = reactor.create_compute_cell({computeCell2}, decrement)
+        computeCell4 = reactor.create_compute_cell({computeCell1,
+                                                    computeCell3},
+                                                   product)
+
+        CallbackManager.reset()
+        computeCell4.add_watcher(CallbackManager.count)
+
+        inputCell1.set_value(3)
+        self.assertEqual(CallbackManager.counter, 1)
+
+
+if __name__ == '__main__':
+    unittest.main()

data/tracks/rust/exercises/pascals-triangle/Cargo.toml

@@ -1,3 +1,3 @@
 [package]
 name = "pascals-triangle"
-version = "1.0.0"
+version = "1.2.0"

data/tracks/rust/exercises/pascals-triangle/tests/pascals-triangle.rs

@@ -40,3 +40,59 @@ fn last_of_four_rows() {
     let expected: Vec<u32> = vec![1, 3, 3, 1];
     assert_eq!(Some(expected), pt.rows().pop());
 }
+
+#[test]
+#[ignore]
+fn five_rows() {
+    let pt = PascalsTriangle::new(5);
+    let expected: Vec<Vec<u32>> = vec![vec![1],
+                                       vec![1, 1],
+                                       vec![1, 2, 1],
+                                       vec![1, 3, 3, 1],
+                                       vec![1, 4, 6, 4, 1]];
+    assert_eq!(expected, pt.rows());
+}
+
+#[test]
+#[ignore]
+fn six_rows() {
+    let pt = PascalsTriangle::new(6);
+    let expected: Vec<Vec<u32>> = vec![vec![1],
+                                       vec![1, 1],
+                                       vec![1, 2, 1],
+                                       vec![1, 3, 3, 1],
+                                       vec![1, 4, 6, 4, 1],
+                                       vec![1, 5, 10, 10, 5, 1]];
+    assert_eq!(expected, pt.rows());
+}
+
+#[test]
+#[ignore]
+fn seven_rows() {
+    let pt = PascalsTriangle::new(7);
+    let expected: Vec<Vec<u32>> = vec![vec![1],
+                                       vec![1, 1],
+                                       vec![1, 2, 1],
+                                       vec![1, 3, 3, 1],
+                                       vec![1, 4, 6, 4, 1],
+                                       vec![1, 5, 10, 10, 5, 1],
+                                       vec![1, 6, 15, 20, 15, 6, 1]];
+    assert_eq!(expected, pt.rows());
+}
+
+#[test]
+#[ignore]
+fn ten_rows() {
+    let pt = PascalsTriangle::new(10);
+    let expected: Vec<Vec<u32>> = vec![vec![1],
+                                       vec![1, 1],
+                                       vec![1, 2, 1],
+                                       vec![1, 3, 3, 1],
+                                       vec![1, 4, 6, 4, 1],
+                                       vec![1, 5, 10, 10, 5, 1],
+                                       vec![1, 6, 15, 20, 15, 6, 1],
+                                       vec![1, 7, 21, 35, 35, 21, 7, 1],
+                                       vec![1, 8, 28, 56, 70, 56, 28, 8, 1],
+                                       vec![1, 9, 36, 84, 126, 126, 84, 36, 9, 1]];
+    assert_eq!(expected, pt.rows());
+}

data/tracks/swift/Package.swift

@@ -8,7 +8,7 @@ if
     let jsonData = try? Data(contentsOf: URL(fileURLWithPath: path), options: Data.ReadingOptions.mappedIfSafe) ,
     let json = try? JSONSerialization.jsonObject(with: jsonData, options: [])  ,
     let jsonDict = json as? [String: Any],
-    let exercisesDict = jsonDict["exercises"] as? [[String:Any]],
+    let exercisesDict = jsonDict["exercises"] as? [[String: Any]],
     let exercises = exercisesDict.map({ $0["slug"] }) as? [String],
     let deprecated = jsonDict["deprecated"] as? [String] {
 

data/tracks/swift/config.json

@@ -337,6 +337,17 @@
       "unlocked_by": null,
       "uuid": "ea9feed8-481a-4bd0-9af8-7ca44433c266"
     },
+    {
+      "core": false,
+      "difficulty": 3,
+      "slug": "collatz-conjecture",
+      "topics": [
+        "integers",
+        "mathematics"
+      ],
+      "unlocked_by": null,
+      "uuid": "899bd49a-0970-9a80-5e6b-2adf5bfd0bf79f480ba"
+    },
     {
       "core": false,
       "difficulty": 4,

data/tracks/swift/exercises/atbash-cipher/Sources/AtbashExample.swift

@@ -13,7 +13,7 @@ struct Atbash {
         return returnString
     }
 
-    static let cipherDictApply: [Character : Character] = ["a": "z", "b": "y", "c": "x", "d": "w", "e": "v", "f": "u", "g": "t", "h": "s", "i": "r", "j": "q", "k": "p", "l": "o", "m": "n", "n": "m", "o": "l", "p": "k", "q": "j", "r": "i", "s": "h", "t": "g", "u": "f", "v": "e", "w": "d", "x": "c", "y": "b", "z": "a"]
+    static let cipherDictApply: [Character: Character] = ["a": "z", "b": "y", "c": "x", "d": "w", "e": "v", "f": "u", "g": "t", "h": "s", "i": "r", "j": "q", "k": "p", "l": "o", "m": "n", "n": "m", "o": "l", "p": "k", "q": "j", "r": "i", "s": "h", "t": "g", "u": "f", "v": "e", "w": "d", "x": "c", "y": "b", "z": "a"]
 
     static func encode( _ valueIn: String) -> String {
         let value = stripWhiteSpaceAndPunctuations(valueIn.lowercased()  )

data/tracks/swift/exercises/bracket-push/Sources/BracketPushExample.swift

@@ -1,6 +1,6 @@
 struct BracketPush {
 
-    private static let brackets: [Character : Character] = [
+    private static let brackets: [Character: Character] = [
         ")": "(",
         "]": "[",
         "}": "{"

data/tracks/swift/exercises/collatz-conjecture/Package.swift

@@ -0,0 +1,5 @@
+import PackageDescription
+
+let package = Package(
+    name: "CollatzConjecture"
+)

data/tracks/swift/exercises/collatz-conjecture/README.md

@@ -0,0 +1,41 @@
+# Collatz Conjecture
+
+The Collatz Conjecture or 3x+1 problem can be summarized as follows:
+
+Take any positive integer n. If n is even, divide n by 2 to get n / 2. If n is
+odd, multiply n by 3 and add 1 to get 3n + 1. Repeat the process indefinitely.
+The conjecture states that no matter which number you start with, you will
+always reach 1 eventually.
+
+Given a number n, return the number of steps required to reach 1.
+
+## Examples
+
+Starting with n = 12, the steps would be as follows:
+
+0. 12
+1. 6
+2. 3
+3. 10
+4. 5
+5. 16
+6. 8
+7. 4
+8. 2
+9. 1
+
+Resulting in 9 steps. So for input n = 12, the return value would be 9.
+
+## Setup
+
+Go through the project setup instructions for Xcode using Swift:
+
+http://exercism.io/languages/swift
+
+## Source
+
+An unsolved problem in mathematics named after mathematician Lothar Collatz [https://en.wikipedia.org/wiki/3x_%2B_1_problem](https://en.wikipedia.org/wiki/3x_%2B_1_problem)
+
+## Submitting Incomplete Solutions
+
+It's possible to submit an incomplete solution so you can see how others have completed the exercise.

data/tracks/swift/exercises/collatz-conjecture/Sources/CollatzConjecture.swift

@@ -0,0 +1 @@
+//Solution goes in Sources

data/tracks/swift/exercises/collatz-conjecture/Sources/CollatzConjectureExample.swift

@@ -0,0 +1,27 @@
+enum CollatzConjectureError: Error {
+    case numberNotPositive
+}
+
+struct CollatzConjecture {
+
+    static func steps(_ number: Int) throws -> Int? {
+        guard number > 0 else {
+            throw CollatzConjectureError.numberNotPositive
+        }
+
+        var number = number
+        var steps = 0
+
+        while number > 1 {
+            steps += 1
+
+            if number % 2 == 0 {
+                number /= 2
+            } else {
+                number = number * 3 + 1
+            }
+        }
+
+        return steps
+    }
+}

data/tracks/swift/exercises/collatz-conjecture/Tests/CollatzConjectureTests/CollatzConjectureTests.swift

@@ -0,0 +1,40 @@
+import XCTest
+@testable import CollatzConjecture
+
+class CollatzConjectureTests: XCTestCase {
+
+    func testZeroStepsForOne() {
+        XCTAssertEqual(0, try CollatzConjecture.steps(1))
+    }
+
+    func testDivideIfEven() {
+        XCTAssertEqual(4, try CollatzConjecture.steps(16))
+    }
+
+    func testEvenAndOddSteps() {
+        XCTAssertEqual(9, try CollatzConjecture.steps(12))
+    }
+
+    func testLargeNumberOfEvenAndOddSteps() {
+        XCTAssertEqual(152, try CollatzConjecture.steps(1_000_000))
+    }
+
+    func testZeroIsAnError() {
+        XCTAssertThrowsError(try CollatzConjecture.steps(0))
+    }
+
+    func testNegativeValueIsAnError() {
+        XCTAssertThrowsError(try CollatzConjecture.steps(-15))
+    }
+
+    static var allTests: [(String, (CollatzConjectureTests) -> () throws -> Void)] {
+        return [
+            ("testZeroStepsForOne", testZeroStepsForOne),
+            ("testDivideIfEven", testDivideIfEven),
+            ("testEvenAndOddSteps", testEvenAndOddSteps),
+            ("testLargeNumberOfEvenAndOddSteps", testLargeNumberOfEvenAndOddSteps),
+            ("testZeroIsAnError", testZeroIsAnError),
+            ("testNegativeValueIsAnError", testNegativeValueIsAnError),
+        ]
+    }
+}

data/tracks/swift/exercises/collatz-conjecture/Tests/LinuxMain.swift

@@ -0,0 +1,6 @@
+import XCTest
+@testable import CollatzConjectureTests
+
+XCTMain([
+    testCase(CollatzConjectureTests.allTests),
+    ])

data/tracks/swift/exercises/dominoes/Sources/DominoesExample.swift

@@ -69,7 +69,7 @@ class Bone: CustomStringConvertible, Equatable {
     var available: Int?
     var connectedTo: Bone?
     var description: String {
-        return "\(value)|\(connected)|\(available) "
+        return "\(value)|\(connected)|\(String(describing: available)) "
     }
     @discardableResult
     func connect(_ input: Bone) -> Bool {
@@ -146,10 +146,10 @@ class Bone: CustomStringConvertible, Equatable {
 
         switch (connected, input.connected) {
         case (1, 0):
-            guard let _ = available else { return false }
+            guard available != nil else { return false }
             oneZero()
         case (0, 1):
-            guard let _ = input.available else { return false }
+            guard input.available != nil else { return false }
             zeroOne()
         case (1, 1):
             oneOne()

data/tracks/swift/exercises/grains/Tests/GrainsTests/GrainsTests.swift

@@ -8,7 +8,7 @@ class GrainsTests: XCTestCase {
             if case let Grains.GrainsError.inputTooHigh(message) = error {
                 XCTAssertTrue(message == "Input[65] invalid. Input should be between 1 and 64 (inclusive)")
             } else {
-                XCTFail()
+                XCTFail("Expected error not thrown")
             }
         }
     }
@@ -18,7 +18,7 @@ class GrainsTests: XCTestCase {
             if case let Grains.GrainsError.inputTooLow(message) = error {
                 XCTAssertTrue(message == "Input[0] invalid. Input should be between 1 and 64 (inclusive)")
             } else {
-                XCTFail()
+                XCTFail("Expected error not thrown")
             }
         }
     }
@@ -28,7 +28,7 @@ class GrainsTests: XCTestCase {
             if case let Grains.GrainsError.inputTooLow(message) = error {
                 XCTAssertTrue(message == "Input[-1] invalid. Input should be between 1 and 64 (inclusive)")
             } else {
-                XCTFail()
+                XCTFail("Expected error not thrown")
             }
         }
     }

data/tracks/swift/exercises/kindergarten-garden/Sources/KindergartenGardenExample.swift

@@ -10,7 +10,7 @@ enum Plant: String {
 struct Garden {
     static private let defaultChildren = ["Alice", "Bob", "Charlie", "David", "Eve", "Fred", "Ginny", "Harriet", "Ileana", "Joseph", "Kincaid", "Larry"]
 
-    private let pots: [String : [Plant]]
+    private let pots: [String: [Plant]]
 
     init(_ diagram: String, children: [String] = defaultChildren) {
         self.pots = Garden.parse(diagram, children: children)
@@ -23,7 +23,7 @@ struct Garden {
         return plants
     }
 
-    private static func parse(_ diagram: String, children: [String]) -> [String : [Plant]] {
+    private static func parse(_ diagram: String, children: [String]) -> [String: [Plant]] {
         let sortedChildren = children.sorted(by: <)
         let lines = diagram.components(separatedBy: CharacterSet.newlines)
         var result = [String: [Plant]]()

data/tracks/swift/exercises/meetup/Sources/MeetupExample.swift

@@ -58,7 +58,7 @@ struct Date {
 
 }
 
-extension Date:CustomStringConvertible {
+extension Date: CustomStringConvertible {
     private func addLeadingZero(_ input: Int32) -> String {
 
         if (0...9).contains(input) {

data/tracks/swift/exercises/nucleotide-count/Sources/NucleotideCountExample.swift

@@ -7,7 +7,7 @@ enum Nucleobase: Character {
 
 struct DNA {
 
-    var nucleotideCounts: [Nucleobase:Int] = [ .adenine: 0, .thymine: 0, .cytosine: 0, .guanine: 0 ]
+    var nucleotideCounts: [Nucleobase: Int] = [ .adenine: 0, .thymine: 0, .cytosine: 0, .guanine: 0 ]
 
     init?(strand: String) {
         let enumarated = strand.characters.enumerated()
@@ -26,7 +26,7 @@ struct DNA {
     }
 
     func counts() -> [String: Int] {
-        var nCounts: [String:Int] = [:]
+        var nCounts: [String: Int] = [:]
         for (k, v) in nucleotideCounts {
             nCounts[String(k.rawValue)] = v
         }