trackler 2.2.1.117 → 2.2.1.118

data/tracks/haskell/exercises/largest-series-product/examples/success-standard/src/Series.hs

@@ -1,4 +1,4 @@
-module Series (largestProduct) where
+module Series (Error(..), largestProduct) where
 
 import Control.Monad    ((>=>))
 import Data.Char        (digitToInt, isDigit)
@@ -7,10 +7,16 @@ import Data.Maybe       (mapMaybe)
 import Safe             (maximumMay)
 import Safe.Exact       (takeExactMay)
 
-largestProduct :: (Integral a, Num b, Ord b) => a -> String -> Maybe b
-largestProduct n = traverse charToNum >=> maximumMay . products
+data Error = InvalidSpan | InvalidDigit Char deriving (Show, Eq)
+
+rightOr :: a -> Maybe b -> Either a b
+rightOr a Nothing = Left a
+rightOr _ (Just x) = Right x
+
+largestProduct :: (Integral a, Num b, Ord b) => a -> String -> Either Error b
+largestProduct n = traverse charToNum >=> rightOr InvalidSpan . maximumMay . products
   where
     products = mapMaybe (fmap product . takeExactMay (fromIntegral n)) . tails
     charToNum x
-        | isDigit x = Just . fromIntegral . digitToInt $ x
-        | otherwise = Nothing
+        | isDigit x = Right . fromIntegral . digitToInt $ x
+        | otherwise = Left (InvalidDigit x)

data/tracks/haskell/exercises/largest-series-product/src/Series.hs

@@ -1,4 +1,6 @@
-module Series (largestProduct) where
+module Series (Error(..), largestProduct) where
 
-largestProduct :: Int -> String -> Maybe Integer
+data Error = InvalidSpan | InvalidDigit Char deriving (Show, Eq)
+
+largestProduct :: Int -> String -> Either Error Integer
 largestProduct size digits = error "You need to implement this function."

data/tracks/haskell/exercises/largest-series-product/test/Tests.hs

@@ -3,7 +3,7 @@
 import Test.Hspec        (Spec, describe, it, shouldBe)
 import Test.Hspec.Runner (configFastFail, defaultConfig, hspecWith)
 
-import Series (largestProduct)
+import Series (Error(..), largestProduct)
 
 main :: IO ()
 main = hspecWith defaultConfig {configFastFail = True} specs
@@ -13,60 +13,60 @@ specs = describe "largestProduct" $ do
 
       it "finds the largest product if span equals length" $
         largestProduct 2 "29"
-        `shouldBe` Just 18
+        `shouldBe` Right 18
 
       it "can find the largest product of 2 with numbers in order" $
         largestProduct 2 "0123456789"
-        `shouldBe` Just 72
+        `shouldBe` Right 72
 
       it "can find the largest product of 2" $
         largestProduct 2 "576802143"
-        `shouldBe` Just 48
+        `shouldBe` Right 48
 
       it "can find the largest product of 3 with numbers in order" $
         largestProduct 3 "0123456789"
-        `shouldBe` Just 504
+        `shouldBe` Right 504
 
       it "can find the largest product of 3" $
         largestProduct 3 "1027839564"
-        `shouldBe` Just 270
+        `shouldBe` Right 270
 
       it "can find the largest product of 5 with numbers in order" $
         largestProduct 5 "0123456789"
-        `shouldBe` Just 15120
+        `shouldBe` Right 15120
 
       it "can get the largest product of a big number" $
         largestProduct 6 "73167176531330624919225119674426574742355349194934"
-        `shouldBe` Just 23520
+        `shouldBe` Right 23520
 
       it "reports zero if the only digits are zero" $
         largestProduct 2 "0000"
-        `shouldBe` Just 0
+        `shouldBe` Right 0
 
       it "reports zero if all spans include zero" $
         largestProduct 3 "99099"
-        `shouldBe` Just 0
+        `shouldBe` Right 0
 
       it "rejects span longer than string length" $
         largestProduct 4 "123"
-        `shouldBe` Nothing
+        `shouldBe` Left InvalidSpan
 
       it "reports 1 for empty string and empty product (0 span)" $
         largestProduct 0 ""
-        `shouldBe` Just 1
+        `shouldBe` Right 1
 
       it "reports 1 for nonempty string and empty product (0 span)" $
         largestProduct 0 "123"
-        `shouldBe` Just 1
+        `shouldBe` Right 1
 
       it "rejects empty string and nonzero span" $
         largestProduct 1 ""
-        `shouldBe` Nothing
+        `shouldBe` Left InvalidSpan
 
       it "rejects invalid character in digits" $
         largestProduct 2 "1234a5"
-        `shouldBe` Nothing
+        `shouldBe` Left (InvalidDigit 'a')
 
       it "rejects negative span" $
         largestProduct (-1) "12345"
-        `shouldBe` Nothing
+        `shouldBe` Left InvalidSpan

data/tracks/java/config.json

@@ -197,7 +197,7 @@
         "loops",
         "strings"
       ],
-      "unlocked_by": "rna-transcription",
+      "unlocked_by": "two-fer",
       "uuid": "331073b3-bd1a-4868-b767-a64ce9fd9d97"
     },
     {

data/tracks/java/exercises/bowling/.meta/version

@@ -1 +1 @@
-1.1.0
+1.2.0

data/tracks/java/exercises/bowling/src/test/java/BowlingTest.java

@@ -199,7 +199,7 @@ public class BowlingTest {
 
         game.score();
     }
-    
+
     @Ignore("Remove to run test")
     @Test
     public void twoBonusRollsAfterAStrikeInTheLastFrameCanNotScoreMoreThan10Points() {
@@ -222,7 +222,7 @@ public class BowlingTest {
 
         assertEquals(26, game.score());
     }
-    
+
     @Ignore("Remove to run test")
     @Test
     public void theSecondBonusRollsAfterAStrikeInTheLastFrameCanNotBeAStrikeIfTheFirstOneIsNotAStrike() {
@@ -235,7 +235,7 @@ public class BowlingTest {
 
         game.score();
     }
-    
+
     @Ignore("Remove to run test")
     @Test
     public void secondBonusRollAfterAStrikeInTheLastFrameCanNotScoreMoreThan10Points() {
@@ -248,7 +248,7 @@ public class BowlingTest {
 
         game.score();
     }
-    
+
     @Ignore("Remove to run test")
     @Test
     public void anUnstartedGameCanNotBeScored() {
@@ -327,4 +327,29 @@ public class BowlingTest {
         game.score();
     }
 
-}
+    @Ignore("Remove to run test")
+    @Test
+    public void canNotRollAfterBonusRollForSpare() {
+        int[] rolls = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 3, 2, 2};
+
+        playGame(rolls);
+
+        expectedException.expect(IllegalStateException.class);
+        expectedException.expectMessage("Cannot roll after game is over");
+
+        game.score();
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void canNotRollAfterBonusRollForStrike() {
+        int[] rolls = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 3, 2, 2};
+
+        playGame(rolls);
+
+        expectedException.expect(IllegalStateException.class);
+        expectedException.expectMessage("Cannot roll after game is over");
+
+        game.score();
+    }
+}

data/tracks/javascript/config.json

@@ -594,7 +594,7 @@
         "text-formatting",
         "transforming"
       ],
-      "unlocked_by": "atbash-cipher",
+      "unlocked_by": "simple-cipher",
       "uuid": "a98e3593-d5b4-4c2b-8569-ae3ae7e07dad"
     },
     {
@@ -805,7 +805,7 @@
         "control-flow-(loops)",
         "recursion"
       ],
-      "unlocked_by": "binary-search",
+      "unlocked_by": "linked-list",
       "uuid": "865806e0-950f-49a5-a6e5-26472b90ab85"
     },
     {
@@ -1130,7 +1130,7 @@
          "Algorithms",
          "Mathematics"
       ],
-      "unlocked_by": "null",
+      "unlocked_by": null,
       "uuid" : "fd435dad-311a-4c40-9868-70863455831e"
     },
     {
@@ -1213,7 +1213,7 @@
       "uuid": "b3dbc935-536e-4910-994d-4a519b511b6a",
       "slug": "forth",
       "core": false,
-      "unlocked_by": "saddle-points",
+      "unlocked_by": "matrix",
       "difficulty": 8,
       "topics": [
         "stacks",
@@ -1225,7 +1225,7 @@
       "uuid": "f82e470d-0bcc-4eba-b9b0-8a0c50a6fd19",
       "slug": "variable-length-quantity",
       "core": false,
-      "unlocked_by": "two-bucket",
+      "unlocked_by": "grade-school",
       "difficulty": 5,
       "topics": [
         "bitwise_operations",

data/tracks/ocaml/README.md

@@ -15,6 +15,7 @@ The OCaml track assumes installation of OCaml version 4.06.1, and installation o
 Assuming you have opam, these can be installed with
 ```bash
 opam install core_kernel ounit react
+```
 
 ## Notes on prerequisite libraries
 
@@ -24,14 +25,14 @@ an issue.
 OUnit is a unit testing library.
 React is a reactive library, just used in the hangman exercise.
 
-```
-
 ## Running Tests
 
 To run all the tests, type `make` from the top level ocaml directory.
 
 To run tests for an individual exercise, `make test-assignment ASSIGNMENT=luhn`
 
+The Makefile is a slim wrapper around [dune](https://github.com/ocaml/dune). Each exercise has a jbuild file which describes how to build it.
+
 ## Adding an Exercise
 
 The [contributing guide](https://github.com/exercism/docs/blob/master/contributing-to-language-tracks/README.md) provides guidance on

data/tracks/typescript/config.json

@@ -395,6 +395,34 @@
       "unlocked_by": "space-age",
       "uuid": "5a04b3f8-99b6-4aec-8afd-0d54930e4aff"
     },
+    {
+      "core": false,
+      "difficulty": 5,
+      "slug": "sieve",
+      "topics": [
+        "control_flow_conditionals",
+        "control_flow_loops",
+        "integers",
+        "mathematics",
+        "recursion"
+      ],
+      "unlocked_by": "prime-factors",
+      "uuid": "f3ad1525-c124-4b2f-b09f-4639eb4a6ad9"
+    },
+    {
+      "core": false,
+      "difficulty": 5,
+      "slug": "sublist",
+      "topics": [
+        "arrays",
+        "control_flow_conditionals",
+        "control_flow_loops",
+        "data_structures",
+        "lists"
+      ],
+      "unlocked_by": "linked-list",
+      "uuid": "c5ed4703-59cd-4e31-b109-ba5bfc48a578"
+    },
     {
       "core": true,
       "difficulty": 6,

data/tracks/typescript/exercises/sieve/README.md

@@ -0,0 +1,60 @@
+# Sieve
+
+Use the Sieve of Eratosthenes to find all the primes from 2 up to a given
+number.
+
+The Sieve of Eratosthenes is a simple, ancient algorithm for finding all
+prime numbers up to any given limit. It does so by iteratively marking as
+composite (i.e. not prime) the multiples of each prime,
+starting with the multiples of 2.
+
+Create your range, starting at two and continuing up to and including the given limit. (i.e. [2, limit])
+
+The algorithm consists of repeating the following over and over:
+
+- take the next available unmarked number in your list (it is prime)
+- mark all the multiples of that number (they are not prime)
+
+Repeat until you have processed each number in your range.
+
+When the algorithm terminates, all the numbers in the list that have not
+been marked are prime.
+
+The wikipedia article has a useful graphic that explains the algorithm:
+https://en.wikipedia.org/wiki/Sieve_of_Eratosthenes
+
+Notice that this is a very specific algorithm, and the tests don't check
+that you've implemented the algorithm, only that you've come up with the
+correct list of primes.
+
+## Setup
+
+Go through the setup instructions for TypeScript to
+install the necessary dependencies:
+
+http://exercism.io/languages/typescript
+
+## Requirements
+
+Install assignment dependencies:
+
+```bash
+$ yarn install
+```
+
+## Making the test suite pass
+
+Execute the tests with:
+
+```bash
+$ yarn test
+```
+
+
+
+## Source
+
+Sieve of Eratosthenes at Wikipedia [http://en.wikipedia.org/wiki/Sieve_of_Eratosthenes](http://en.wikipedia.org/wiki/Sieve_of_Eratosthenes)
+
+## Submitting Incomplete Solutions
+It's possible to submit an incomplete solution so you can see how others have completed the exercise.

data/tracks/typescript/exercises/sieve/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "xtypescript",
+  "version": "1.0.0",
+  "description": "Exercism exercises in Typescript.",
+  "author": "",
+  "private": true,
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/exercism/xtypescript"
+  },
+  "devDependencies": {},
+  "scripts": {
+    "test": "tsc --noEmit -p . && jest --no-cache",
+    "lint": "tsc --noEmit -p . && tslint \"*.ts?(x)\"",
+    "lintci": "tslint \"*.ts?(x)\" --force"
+  },
+  "dependencies": {
+    "@types/jest": "^21.1.5",
+    "@types/node": "^8.0.47",
+    "jest": "^21.2.1",
+    "ts-jest": "^21.1.3",
+    "tslint": "^5.8.0",
+    "typescript": "^2.5.3"
+  },
+  "jest": {
+    "transform": {
+      ".(ts|tsx)": "<rootDir>/node_modules/ts-jest/preprocessor.js"
+    },
+    "testRegex": "(/__tests__/.*|\\.(test|spec))\\.(ts|tsx|js)$",
+    "moduleFileExtensions": [
+      "ts",
+      "tsx",
+      "js"
+    ]
+  }
+}

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

@@ -0,0 +1,37 @@
+class Sieve {
+    static primes(limit: number): number[] {
+        if (limit === 2) {
+            return [limit]
+        }
+
+        const sieve: boolean[] = []
+        for (let i = 0; i < limit; i++) {
+            sieve[i] = true
+        }
+
+        const primes: number[] = []
+        const maxCandidate = Math.floor(Math.sqrt(limit))
+        for (let candidate = 2; candidate <= maxCandidate + 1; candidate++) {
+            if (!sieve[candidate - 1]) {
+                continue
+            }
+
+            primes.push(candidate)
+            let multiple = candidate * candidate
+            while (multiple <= limit) {
+                sieve[multiple - 1] = false
+                multiple += candidate
+            }
+        }
+
+        for (let i = maxCandidate + 1; i <= limit; i++) {
+            if (sieve[i - 1]) {
+                primes.push(i)
+            }
+        }
+
+        return primes
+    }
+}
+
+export default Sieve

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

@@ -0,0 +1,41 @@
+import Sieve from './sieve'
+
+describe('Sieve', () => {
+    it('no primes under two', () => {
+        const expected: number[] = []
+        expect(Sieve.primes(1)).toEqual(expected)
+    })
+
+    xit('find first prime', () => {
+        const expected = [2]
+        expect(Sieve.primes(2)).toEqual(expected)
+    })
+
+    xit('find primes up to 10', () => {
+        const expected = [2, 3, 5, 7]
+        expect(Sieve.primes(10)).toEqual(expected)
+    })
+
+    xit('limit is prime', () => {
+        const expected = [2, 3, 5, 7, 11, 13]
+        expect(Sieve.primes(13)).toEqual(expected)
+    })
+
+    xit('find primes up to 1000', () => {
+        const expected: number[] = [
+            2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43,
+            47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97, 101, 103, 107,
+            109, 113, 127, 131, 137, 139, 149, 151, 157, 163, 167, 173, 179, 181,
+            191, 193, 197, 199, 211, 223, 227, 229, 233, 239, 241, 251, 257, 263,
+            269, 271, 277, 281, 283, 293, 307, 311, 313, 317, 331, 337, 347, 349,
+            353, 359, 367, 373, 379, 383, 389, 397, 401, 409, 419, 421, 431, 433,
+            439, 443, 449, 457, 461, 463, 467, 479, 487, 491, 499, 503, 509, 521,
+            523, 541, 547, 557, 563, 569, 571, 577, 587, 593, 599, 601, 607, 613,
+            617, 619, 631, 641, 643, 647, 653, 659, 661, 673, 677, 683, 691, 701,
+            709, 719, 727, 733, 739, 743, 751, 757, 761, 769, 773, 787, 797, 809,
+            811, 821, 823, 827, 829, 839, 853, 857, 859, 863, 877, 881, 883, 887,
+            907, 911, 919, 929, 937, 941, 947, 953, 967, 971, 977, 983, 991, 997
+        ]
+        expect(Sieve.primes(1000)).toEqual(expected)
+    })
+})