trackler 2.0.0.3 → 2.0.0.4

data/tracks/java/exercises/trinary/build.gradle

@@ -7,7 +7,7 @@ repositories {
 }
 
 dependencies {
-  testCompile "junit:junit:4.10"
+  testCompile "junit:junit:4.12"
 }
 test {
   testLogging {

data/tracks/java/exercises/word-count/build.gradle

@@ -7,7 +7,7 @@ repositories {
 }
 
 dependencies {
-  testCompile "junit:junit:4.10"
+  testCompile "junit:junit:4.12"
 }
 test {
   testLogging {

data/tracks/ocaml/.travis-ci.sh

@@ -2,7 +2,7 @@
 OPAM_DEPENDS="ocamlfind core ounit react"
 
 case "$OCAML_VERSION,$OPAM_VERSION" in
-    4.03.0,1.2.2) ppa=avsm/ocaml42+opam12 ;;
+    4.04.0,1.2.2) ppa=avsm/ocaml42+opam12 ;;
     *) echo Unknown $OCAML_VERSION,$OPAM_VERSION; exit 1 ;;
 esac
 

data/tracks/ocaml/.travis.yml

@@ -6,4 +6,4 @@ script:
   - bin/configlet .
 
 env:
-  - OCAML_VERSION=4.03.0 OPAM_VERSION=1.2.2
+  - OCAML_VERSION=4.04.0 OPAM_VERSION=1.2.2

data/tracks/ocaml/README.md

@@ -11,7 +11,7 @@ notes contain a few details specific to Ocaml.
 
 ## Prerequisites
 
-The OCaml track assumes installation of OCaml version 4.03.0, and installation of Core, OUnit, and React (for the Hangman exercise).
+The OCaml track assumes installation of OCaml version 4.04.0, and installation of Core, OUnit, and React (for the Hangman exercise).
 Assuming you have opam, these can be installed with
 ```bash
 opam install core ounit react

data/tracks/ocaml/exercises/hamming/hamming.mli

@@ -1,6 +1,4 @@
-(** Point-mutation exercise *)
-
 type nucleotide = A | C | G | T
 
-(** Compute the hammning distance between the two lists. *)
+(** Compute the hamming distance between the two lists. *)
 val hamming_distance : nucleotide list -> nucleotide list -> int option

data/tracks/ruby/exercises/leap/.version

@@ -1 +1 @@
-2
+2

data/tracks/ruby/exercises/leap/example.tt

@@ -7,7 +7,7 @@ require_relative 'leap'
 # <%= sha1 %>
 class Date
   def leap?
-    throw "Implement this yourself instead of using Ruby's implementation."
+    raise RuntimeError, "Implement this yourself instead of using Ruby's implementation."
   end
 
   alias gregorian_leap? leap?
@@ -15,8 +15,8 @@ class Date
 end
 
 class YearTest < Minitest::Test<% test_cases.each do |test_case| %>
-  def <%= test_case.name %><% if test_case.skipped? %>
-    skip<% end %><% if test_case.expected%>
+  def <%= test_case.name %>
+    <%= test_case.skip %><% if test_case.expected%>
     assert <%= test_case.do %>, "<%= test_case.failure_message%>"<% else %>
     refute <%= test_case.do %>, "<%= test_case.failure_message%>"<% end%>
   end

data/tracks/ruby/exercises/leap/leap_test.rb

@@ -4,10 +4,10 @@ require 'minitest/autorun'
 require_relative 'leap'
 
 # Test data version:
-# 9b8b80c
+# 7b0949e
 class Date
   def leap?
-    throw "Implement this yourself instead of using Ruby's implementation."
+    raise RuntimeError, "Implement this yourself instead of using Ruby's implementation."
   end
 
   alias gregorian_leap? leap?
@@ -16,6 +16,7 @@ end
 
 class YearTest < Minitest::Test
   def test_leap_year
+    # skip
     assert Year.leap?(1996), "Expected 'true', 1996 is a leap year."
   end
 
@@ -48,7 +49,6 @@ class YearTest < Minitest::Test
     skip
     assert Year.leap?(2000), "Expected 'true', 2000 is a leap year."
   end
-
   # Problems in exercism evolve over time, as we find better ways to ask
   # questions.
   # The version number refers to the version of the problem you solved,
@@ -65,7 +65,6 @@ class YearTest < Minitest::Test
   #
   # If you are curious, read more about constants on RubyDoc:
   # http://ruby-doc.org/docs/ruby-doc-bundle/UsersGuide/rg/constants.html
-
   def test_bookkeeping
     skip
     assert_equal 2, BookKeeping::VERSION

data/tracks/ruby/lib/leap_cases.rb

@@ -7,8 +7,8 @@ class LeapCase < OpenStruct
     "Year.leap?(#{input})"
   end
 
-  def skipped?
-    index > 0
+  def skip
+    index.zero? ? '# skip' : 'skip'
   end
 
   def failure_message

data/tracks/rust/exercises/bowling/tests/bowling.rs

@@ -286,6 +286,20 @@ fn you_can_not_roll_more_than_ten_pins_in_a_single_frame() {
     assert!(game.roll(6).is_err());
 }
 
+#[test]
+#[ignore]
+fn first_bonus_ball_after_a_final_strike_can_not_score_an_invalid_number_of_pins() {
+    let mut game = BowlingGame::new();
+
+    for _ in 0..18 {
+        let _ = game.roll(0);
+    }
+
+    let _ = game.roll(10);
+
+    assert!(game.roll(11).is_err());
+}
+
 #[test]
 #[ignore]
 fn the_two_balls_after_a_final_strike_can_not_score_an_invalid_number_of_pins() {
@@ -331,6 +345,21 @@ fn the_two_balls_after_a_final_strike_can_not_be_a_non_strike_followed_by_a_stri
     assert!(game.roll(10).is_err());
 }
 
+#[test]
+#[ignore]
+fn second_bonus_ball_after_a_final_strike_can_not_score_an_invalid_number_of_pins_even_if_first_is_strike() {
+    let mut game = BowlingGame::new();
+
+    for _ in 0..18 {
+        let _ = game.roll(0);
+    }
+
+    let _ = game.roll(10);
+
+    assert!(game.roll(10).is_ok());
+    assert!(game.roll(11).is_err());
+}
+
 #[test]
 #[ignore]
 fn if_the_last_frame_is_a_strike_you_can_not_score_before_the_extra_rolls_are_taken() {

data/tracks/swift/.gitignore

@@ -19,3 +19,4 @@ DerivedData
 *.hmap
 *.ipa
 *.xcuserstate
+.DS_Store

data/tracks/swift/.swift-version

@@ -0,0 +1 @@
+3.0

data/tracks/swift/exercises/bowling/BowlingExample.swift

@@ -78,7 +78,7 @@ struct Bowling {
         if isLastFrame {
             let lastRollWasStrike = scoreCard[currentFrame]?.last == 10
 
-            if lastRollWasStrike {
+            if lastRollWasStrike || isSpare() {
                 return true
             }
         }
@@ -94,7 +94,7 @@ struct Bowling {
 
     private func frameComplete() -> Bool {
         if isLastFrame {
-            return frameFilled(rolls: 3) || isOpenFrame() && frameFilled()
+            return isOpenFrame() && frameFilled() || frameFilled(rolls: 3)
         }
 
         return frameFilled() || isStrike()

data/tracks/swift/exercises/bowling/BowlingTest.swift

@@ -2,7 +2,6 @@
     import XCTest
 #endif
 
-// swiftlint:disable force_try
 class BowlingTest: XCTestCase {
 
     var game: Bowling!
@@ -11,170 +10,161 @@ class BowlingTest: XCTestCase {
         game = Bowling()
     }
 
-    func testOpenFrame() {
-        try! game.roll(pins: 3)
-        try! game.roll(pins: 4)
-        rollNTimes(rolls: 18, pins: 0)
-        XCTAssertEqual(try? game.score(), 7)
-    }
-
-    func testMultipleFrames() {
-        [3, 4, 2, 3, 5, 2].forEach {
-            try? game.roll(pins: $0)
+    func roll(_ seriesOfPins: [Int]) throws {
+        for pins in seriesOfPins {
+            try game.roll(pins: pins)
         }
-        rollNTimes(rolls: 14, pins: 0)
-        XCTAssertEqual(try? game.score(), 19)
     }
 
-    func testAllGutterballs() {
-        rollNTimes(rolls: 20, pins: 0)
+    func testAllZeros() {
+        try? roll([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])
+
         XCTAssertEqual(try? game.score(), 0)
     }
 
-    func testAllSinglePinRolls() {
-        rollNTimes(rolls: 20, pins: 1)
-        XCTAssertEqual(try? game.score(), 20)
-    }
+    func testNoStrikesOrSpares() {
+        try? roll([3, 6, 3, 6, 3, 6, 3, 6, 3, 6, 3, 6, 3, 6, 3, 6, 3, 6, 3, 6])
 
-    func testAllOpenFrames() {
-        rollNTimes(rolls: 10, pins: 3, 6)
         XCTAssertEqual(try? game.score(), 90)
     }
 
-    func testStrikeNotLastFrame() {
-        try? game.roll(pins: 10)
-        try? game.roll(pins: 5)
-        try? game.roll(pins: 3)
-        rollNTimes(rolls: 16, pins: 0)
+    func testSpareFollowedByZeros() {
+        try? roll([6, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])
 
-        XCTAssertEqual(try? game.score(), 26)
+        XCTAssertEqual(try? game.score(), 10)
     }
 
-    func testSpareNotLastFrame() {
-        try? game.roll(pins: 5)
-        try? game.roll(pins: 5)
-        try? game.roll(pins: 3)
-        try? game.roll(pins: 4)
-        rollNTimes(rolls: 16, pins: 0)
+    func testPointsScoredInRollAfterSpare() {
+        try? roll([6, 4, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])
 
-        XCTAssertEqual(try? game.score(), 20)
+        XCTAssertEqual(try? game.score(), 16)
     }
 
-    func testMultipleStrikesInARow() {
-        try? game.roll(pins: 10)
-        try? game.roll(pins: 10)
-        try? game.roll(pins: 10)
-        try? game.roll(pins: 5)
-        try? game.roll(pins: 3)
-        rollNTimes(rolls: 12, pins: 0)
+    func testConsecutiveSpares() {
+        try? roll([5, 5, 3, 7, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])
 
-        XCTAssertEqual(try? game.score(), 81)
+        XCTAssertEqual(try? game.score(), 31)
+    }
+
+    func testSpareInLastFrame() {
+        try? roll([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 3, 7])
+
+        XCTAssertEqual(try? game.score(), 17)
+    }
+
+    func testStrikeWithSingleRoll() {
+        try? roll([10, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])
+
+        XCTAssertEqual(try? game.score(), 10)
+    }
+
+    func testTwoRollsAfterAStrike() {
+        try? roll([10, 5, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])
+
+        XCTAssertEqual(try? game.score(), 26)
     }
 
-    func testMultipleSparesInARow() {
-        try? game.roll(pins: 5)
-        try? game.roll(pins: 5)
-        try? game.roll(pins: 3)
-        try? game.roll(pins: 7)
-        try? game.roll(pins: 4)
-        try? game.roll(pins: 1)
-        rollNTimes(rolls: 14, pins: 0)
+    func testConsecutiveStrikes() {
+        try? roll([10, 10, 10, 5, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])
 
-        XCTAssertEqual(try? game.score(), 32)
+        XCTAssertEqual(try? game.score(), 81)
     }
 
-    func testStrikeInFinalFrame() {
-        rollNTimes(rolls: 18, pins: 0)
-        try? game.roll(pins: 10)
-        try? game.roll(pins: 7)
-        try? game.roll(pins: 1)
+    func testStrikeInLastFrame() {
+        try? roll([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 7, 1])
 
         XCTAssertEqual(try? game.score(), 18)
     }
 
-    func testSpareInFinalFrame() {
-        rollNTimes(rolls: 18, pins: 0)
-        try? game.roll(pins: 9)
-        try? game.roll(pins: 1)
-        try? game.roll(pins: 7)
+    func testSpareWithTwoRollBonus() {
+        try? roll([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 7, 3])
 
-        XCTAssertEqual(try? game.score(), 17)
+        XCTAssertEqual(try? game.score(), 20)
     }
 
-    func testFillBallsStrikes() {
-        rollNTimes(rolls: 18, pins: 0)
-        try? game.roll(pins: 10)
-        try? game.roll(pins: 10)
-        try? game.roll(pins: 10)
+    func testStrikesWithTwoRollBonus() {
+        try? roll([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 10, 10])
 
         XCTAssertEqual(try? game.score(), 30)
     }
 
-    func testPerfectGame() {
-        rollNTimes(rolls: 12, pins: 10)
+    func testStrikeAfterSpareInLastFrame() {
+        try? roll([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 3, 10])
+
+        XCTAssertEqual(try? game.score(), 20)
+    }
+
+    func testAllStrikes() {
+        try? roll([10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10])
+
         XCTAssertEqual(try? game.score(), 300)
     }
 
-    func testNegativePins() {
-        XCTAssertThrowsError(try game.roll(pins: -1)) { error in
+    func testNegativePoints() {
+        XCTAssertThrowsError(try roll([-1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) { error in
             XCTAssertEqual(error as? Bowling.BowlingError, .invalidNumberOfPins)
         }
     }
 
-    func testRollsBetterThanStrike() {
-        XCTAssertThrowsError(try game.roll(pins: 11)) { error in
+    func testNoMoreThan10PinsPerRoll() {
+        XCTAssertThrowsError(try roll([11, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) { error in
             XCTAssertEqual(error as? Bowling.BowlingError, .invalidNumberOfPins)
         }
     }
 
-    func testTwoNormalRollsBetterThanStrike() {
-        try? game.roll(pins: 5)
-        XCTAssertThrowsError(try game.roll(pins: 6)) { error in
+    func testTwoRollsGreaterThan10() {
+        XCTAssertThrowsError(try roll([5, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) { error in
             XCTAssertEqual(error as? Bowling.BowlingError, .tooManyPinsInFrame)
         }
     }
 
-    func testTwoNormalRollsBetterThanStrikeInLastFrame() {
-        rollNTimes(rolls: 18, pins: 0)
-        try? game.roll(pins: 10)
-        try? game.roll(pins: 5)
-        XCTAssertThrowsError(try game.roll(pins: 6)) { error in
+    func testTwoBonusRollsAfterStrike() {
+        XCTAssertThrowsError(try roll([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 5, 6])) { error in
             XCTAssertEqual(error as? Bowling.BowlingError, .tooManyPinsInFrame)
         }
     }
 
-    func testTakeScoreAtBeginning() {
+    func testUnstartedGameCanNotBeScored() {
         XCTAssertThrowsError(try game.score()) { error in
             XCTAssertEqual(error as? Bowling.BowlingError, .gameInProgress)
         }
     }
 
-    func testTakeScoreBeforeGameHasEnded() {
-        rollNTimes(rolls: 19, pins: 5)
+    func testIncompleteGameCanNotBeScored() {
+        try? roll([0, 0])
+
         XCTAssertThrowsError(try game.score()) { error in
             XCTAssertEqual(error as? Bowling.BowlingError, .gameInProgress)
         }
     }
 
-    func testRollsAfterTheTenthFrame() {
-        rollNTimes(rolls: 20, pins: 0)
-        XCTAssertThrowsError(try game.roll(pins: 0)) { error in
+    func testMoreThanTenFrames() {
+        XCTAssertThrowsError(try roll([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) { error in
             XCTAssertEqual(error as? Bowling.BowlingError, .gameIsOver)
         }
     }
 
-    func testCalculateScoreBeforeFillBallsHaveBeenPlayed() {
-        rollNTimes(rolls: 10, pins: 10)
+    func testBonusRollsNotRolled() {
+        try? roll([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10])
+
         XCTAssertThrowsError(try game.score()) { error in
             XCTAssertEqual(error as? Bowling.BowlingError, .gameInProgress)
         }
     }
 
-    private func rollNTimes(rolls: Int, pins: Int...) {
-        for _ in 1...rolls {
-            pins.forEach {
-                try? game.roll(pins: $0)
-            }
+    func testSecondBonusRollNotRolled() {
+        try? roll([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 10])
+
+        XCTAssertThrowsError(try game.score()) { error in
+            XCTAssertEqual(error as? Bowling.BowlingError, .gameInProgress)
+        }
+    }
+
+    func testBonusRollForSpareNotRolled() {
+        try? roll([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 3])
+
+        XCTAssertThrowsError(try game.score()) { error in
+            XCTAssertEqual(error as? Bowling.BowlingError, .gameInProgress)
         }
     }
 

data/tracks/swift/exercises/palindrome-products/PalindromeProductsExample.swift

@@ -2,14 +2,10 @@ import Foundation
 
 private extension String {
 
-    var length: Int {return self.characters.count}
+    var length: Int { return self.characters.count }
 
     func reverse() -> String {
-        var result: String = ""
-        for char in self.characters {
-            result = "\(char)\(result)"
-        }
-        return result
+        return characters.reversed().map { String($0) }.joined()
     }
 }
 
@@ -19,8 +15,8 @@ struct PalindromeProducts {
     private let maxFactor: Int
     private let minFactor: Int
 
-    var largest: Palindrome {return calculate(.max)}
-    var smallest: Palindrome {return calculate(.min)}
+    var largest: Palindrome { return calculate(.max) }
+    var smallest: Palindrome { return calculate(.min) }
 
     init(maxFactor: Int, minFactor: Int = 1) {
         self.maxFactor = maxFactor
@@ -31,10 +27,11 @@ struct PalindromeProducts {
     private func calculate(_ upTo: Mode) -> Palindrome {
 
         let rangeOuter = minFactor...maxFactor
-        var multiplications = [Palindrome]()
 
         //Multithreaded code
         var results = [[Palindrome]](repeating: [Palindrome](), count: rangeOuter.count)
+        // use this queue to read and write from results
+        let resultsRWQueue = DispatchQueue.init(label: "exercism.resultsRWQueue")
 
         DispatchQueue.concurrentPerform(iterations: rangeOuter.count) {
             advanceByIndex in
@@ -49,19 +46,25 @@ struct PalindromeProducts {
                     multiplicationsTemp.append((multiplied, [each, eaInside]))
                 }
             }
-            results[advanceByIndex] = multiplicationsTemp
+            // prevent data race conditions
+            resultsRWQueue.async {
+                results[advanceByIndex] = multiplicationsTemp
+            }
+        }
+        var multiplications = [Palindrome]()
+        // prevent data race conditions
+        resultsRWQueue.sync {
+            multiplications = results.joined().sorted(by: { $0.value > $1.value })
         }
-        multiplications = results.joined().sorted(by: {$0.0 > $1.0})
-
         if let large = multiplications.first, let small = multiplications.last {
             switch upTo {
-            case .max : return large
-            case .min : return small
+            case .max: return large
+            case .min: return small
             }
         } else {
             switch upTo {
-            case .max : return (self.maxFactor, [self.maxFactor, 1])
-            case .min : return (self.minFactor, [self.minFactor, 1])
+            case .max: return (maxFactor, [maxFactor, 1])
+            case .min: return (minFactor, [minFactor, 1])
             }
         }
     }

data/tracks/tcl/README.md

@@ -16,3 +16,6 @@ The MIT License (MIT)
 
 Copyright (c) 2015 Katrina Owen, _@kytrinyx.com
 
+### Tcl icon
+The Tcl icon was created by [Fant0men at en.wikipedia](https://en.wikipedia.org/wiki/User:Fant0men) and released under the [Creative Commons Attribution-ShareAlike 3.0 Unported](https://creativecommons.org/licenses/by-sa/3.0/) license.
+We adapted the icon, creating a black, pink and white version of it to use on Exercism.

data/tracks/tcl/config.json

@@ -8,7 +8,8 @@
 
   ],
   "ignored": [
-    "bin"
+    "bin",
+    "img"
   ],
   "foregone": [