trackler 2.0.6.28 → 2.0.6.29

data/tracks/haskell/config.json

@@ -146,7 +146,6 @@
       "slug": "secret-handshake",
       "difficulty": 3,
       "topics": [
-        "instance custom"
       ]
     },
     {

data/tracks/haskell/exercises/accumulate/examples/fail-reverse/package.yaml

@@ -0,0 +1,16 @@
+name: accumulate
+
+dependencies:
+  - base
+
+library:
+  exposed-modules: Accumulate
+  source-dirs: src
+
+tests:
+  test:
+    main: Tests.hs
+    source-dirs: test
+    dependencies:
+      - accumulate
+      - hspec

data/tracks/haskell/exercises/accumulate/examples/fail-reverse/src/Accumulate.hs

@@ -0,0 +1,7 @@
+module Accumulate (accumulate) where
+
+accumulate :: (a -> b) -> [a] -> [b]
+accumulate f = accumulate' []
+  where
+    accumulate' acc []     = reverse acc
+    accumulate' acc (x:xs) = accumulate' (f x : acc) xs

data/tracks/haskell/exercises/accumulate/examples/success-standard/src/Accumulate.hs

@@ -12,11 +12,4 @@ accumulate f = foldr ((:) . f) []
 
 accumulate f xs = [f x | x <- xs]
 
--- Commonly submitted inefficient solution (we test for this now):
-
-accumulate f = accumulate' []
-  where
-    accumulate' acc []     = reverse acc
-    accumulate' acc (x:xs) = accumulate' (f x : acc) xs
-
 -}

data/tracks/haskell/exercises/atbash-cipher/test/Tests.hs

@@ -16,7 +16,7 @@ specs = describe "atbash-cipher" $ do
   where
     test f Case{..} = it description $ f phrase `shouldBe` expected
 
--- Test cases adapted from `exercism/x-common/atbash-cipher.json` on 2016-08-02.
+-- Test cases adapted from `exercism/x-common/atbash-cipher.json` on 2017-02-01.
 
 data Case = Case { description :: String
                  , phrase      :: String
@@ -57,10 +57,6 @@ encodeCases =
            , phrase      = "The quick brown fox jumps over the lazy dog."
            , expected    = "gsvjf rxpyi ldmul cqfnk hlevi gsvoz abwlt"
            }
-    , Case { description = "encode ignores non ascii"
-           , phrase      = "non ascii éignored"
-           , expected    = "mlmzh xrrrt mlivw"
-           }
     ]
 
 decodeCases :: [Case]

data/tracks/haskell/exercises/forth/test/Tests.hs

@@ -12,7 +12,7 @@ main = hspecWith defaultConfig {configFastFail = True} specs
 specs :: Spec
 specs = describe "forth" $ do
 
-    -- Test cases adapted from `exercism/x-common/forth` on 2016-11-06.
+    -- Test cases adapted from `exercism/x-common/forth` on 2017-02-01.
 
     let runTexts = fmap toList . foldM (flip evalText) empty
 
@@ -123,9 +123,6 @@ specs = describe "forth" $ do
         runTexts [ ": swap dup ;"
                  , "1 swap"       ] `shouldBe` Right [1, 1]
 
-      it "can consist of arbitrary characters such as Unicode characters" $
-        runTexts [": € 220371 ; €"] `shouldBe` Right [220371]
-
       it "cannot redefine numbers" $
         runTexts [": 1 2 ;"] `shouldBe` Left InvalidWord
 

data/tracks/haskell/exercises/leap/examples/error-nosig/package.yaml

@@ -0,0 +1,16 @@
+name: leap
+
+dependencies:
+  - base
+
+library:
+  exposed-modules: LeapYear
+  source-dirs: src
+
+tests:
+  test:
+    main: Tests.hs
+    source-dirs: test
+    dependencies:
+      - leap
+      - hspec

data/tracks/haskell/exercises/leap/examples/error-nosig/src/LeapYear.hs

@@ -0,0 +1,4 @@
+module LeapYear (isLeapYear) where
+
+isLeapYear year = hasFactor 4 && (not (hasFactor 100) || hasFactor 400)
+  where hasFactor n = year `rem` n == 0

data/tracks/haskell/exercises/nucleotide-count/examples/success-standard/src/DNA.hs

@@ -1,9 +1,6 @@
-module DNA (count, nucleotideCounts) where
+module DNA (nucleotideCounts) where
 
-import Data.Map.Strict (Map, (!), fromDistinctAscList, fromListWith, findWithDefault)
-
-count :: Char -> String -> Either String Int
-count x xs = (!) <$> nucleotideCounts xs <*> valid x
+import Data.Map.Strict (Map, fromDistinctAscList, fromListWith, findWithDefault)
 
 nucleotideCounts :: String -> Either String (Map Char Int)
 nucleotideCounts xs = fromDistinctAscList <$> mapM count' "ACGT"

data/tracks/haskell/exercises/nucleotide-count/src/DNA.hs

@@ -1,9 +1,6 @@
-module DNA (count, nucleotideCounts) where
+module DNA (nucleotideCounts) where
 
 import Data.Map (Map)
 
-count :: Char -> String -> Either String Int
-count = error "You need to implement this function."
-
 nucleotideCounts :: String -> Either String (Map Char Int)
 nucleotideCounts = error "You need to implement this function."

data/tracks/haskell/exercises/nucleotide-count/test/Tests.hs

@@ -5,7 +5,7 @@ import Data.Map          (fromList)
 import Test.Hspec        (Spec, describe, it, shouldBe, shouldSatisfy)
 import Test.Hspec.Runner (configFastFail, defaultConfig, hspecWith)
 
-import DNA (count, nucleotideCounts)
+import DNA (nucleotideCounts)
 
 main :: IO ()
 main = hspecWith defaultConfig {configFastFail = True} specs
@@ -13,29 +13,10 @@ main = hspecWith defaultConfig {configFastFail = True} specs
 specs :: Spec
 specs = describe "nucleotide-count" $ do
 
-          -- As of 2016-07-27, there was no reference file
-          -- for the test cases in `exercism/x-common`.
+          -- Test cases adapted from `exercism/x-common/triangle.json` on 2017-01-31.
 
-          let x `matches`    y = x `shouldBe`  Right y
           let x `matchesMap` y = x `shouldBe` (Right . fromList) y
 
-          describe "count" $ do
-
-            it "empty dna strand has no adenosine" $
-              count 'A' "" `matches` 0
-
-            it "repetitive cytidine gets counted" $
-              count 'C' "CCCCC" `matches` 5
-
-            it "counts only thymidine" $
-              count 'T' "GGGGGTAACCCGG" `matches` 1
-
-            it "validates nucleotides" $
-              count 'X' "GACT" `shouldSatisfy` isLeft
-
-            it "validates strand" $
-              count 'G' "GACYT" `shouldSatisfy` isLeft
-
           describe "nucleotideCounts" $ do
 
             it "empty dna strand has no nucleotides" $
@@ -58,4 +39,4 @@ specs = describe "nucleotide-count" $ do
                            , ('T', 21) ]
 
             it "validates strand" $
-              nucleotideCounts "GPAC" `shouldSatisfy` isLeft
+              nucleotideCounts "AGXXACT" `shouldSatisfy` isLeft

data/tracks/haskell/exercises/prime-factors/test/Tests.hs

@@ -14,22 +14,16 @@ specs = describe "prime-factors" $
           describe "primeFactors" $ for_ cases test
   where
 
-    test (n, expected) = it explanation assertion
+    test (description, n, expected) = it description assertion
       where
-        explanation = show n
         assertion   = primeFactors n `shouldBe` expected
 
-    -- As of 2016-07-31, there was no reference file
-    -- for the test cases in `exercism/x-common`.
+    -- Test cases adapted from `exercism/x-common/prime-factors` on 2017-02-01.
 
-    cases = [ (          1,                 [] )
-            , (          2,                [2] )
-            , (          3,                [3] )
-            , (          4,             [2, 2] )
-            , (          6,             [2, 3] )
-            , (          8,          [2, 2, 2] )
-            , (          9,             [3, 3] )
-            , (         27,          [3, 3, 3] )
-            , (        625,       [5, 5, 5, 5] )
-            , (     901255,   [5, 17, 23, 461] )
-            , (93819012551, [11, 9539, 894119] ) ]
+    cases = [ ("no factors",                              1,                 [] )
+            , ("prime number",                            2,                [2] )
+            , ("square of a prime",                       9,             [3, 3] )
+            , ("cube of a prime",                         8,          [2, 2, 2] )
+            , ("product of primes and non-primes",       12,          [2, 2, 3] )
+            , ("product of primes",                  901255,   [5, 17, 23, 461] )
+            , ("factors include a large prime", 93819012551, [11, 9539, 894119] ) ]

data/tracks/haskell/exercises/scrabble-score/test/Tests.hs

@@ -23,7 +23,7 @@ specs = describe "scrabble-score" $ do
       where
         assertion = scoreWord input `shouldBe` fromIntegral expected
 
--- Test cases adapted from `exercism/x-common/scrabble-score.json` on 2017-01-31.
+-- Test cases adapted from `exercism/x-common/scrabble-score.json` on 2017-02-01.
 
 data Case = Case { description :: String
                  , input       :: String
@@ -67,10 +67,6 @@ cases = [ Case { description = "lowercase letter"
                , input       = "pinata"
                , expected    = 8
                }
-        , Case { description = "non-english letter is not scored"
-               , input       = "piñata"
-               , expected    = 7
-               }
         , Case { description = "empty input"
                , input       = ""
                , expected    = 0

data/tracks/haskell/exercises/secret-handshake/examples/success-standard/src/SecretHandshake.hs

@@ -1,6 +1,5 @@
 module SecretHandshake (handshake) where
 
-import Numeric (readInt)
 import Data.Bits (testBit)
 
 data Action = Wink
@@ -10,7 +9,7 @@ data Action = Wink
             | Reverse
             deriving (Show, Eq, Enum, Bounded)
 
-handshake :: Handshake a => a -> [String]
+handshake :: Int -> [String]
 handshake = foldr f [] . toActions
   where f Reverse acc = reverse acc
         f action acc = toString action:acc
@@ -21,22 +20,5 @@ handshake = foldr f [] . toActions
           Jump          -> "jump"
           Reverse       -> undefined
 
-class Handshake a where
-  toActions :: a -> [Action]
-
-instance Handshake Int where
-  toActions n = [act | act <- Reverse:[Wink .. Jump], n `testBit` fromEnum act]
-
-class BinParsable a where
-  listToInt :: [a] -> Int
-
-instance BinParsable Char where
-    listToInt s = case readInt 2 isBin parseBin s of
-      [(n, "")] -> n
-      _         -> 0
-      where isBin c = c == '0' || c == '1'
-            parseBin = fromEnum . ('1'==)
-
-
-instance BinParsable a => Handshake [a] where
-  toActions = toActions . listToInt
+toActions :: Int -> [Action]
+toActions n = [act | act <- Reverse:[Wink .. Jump], n `testBit` fromEnum act]

data/tracks/haskell/exercises/secret-handshake/src/SecretHandshake.hs

@@ -1,3 +1,4 @@
 module SecretHandshake (handshake) where
 
+handshake :: Int -> [String]
 handshake = error "You need to implement this function."

data/tracks/haskell/exercises/secret-handshake/test/Tests.hs

@@ -9,43 +9,40 @@ main = hspecWith defaultConfig {configFastFail = True} specs
 specs :: Spec
 specs = describe "secret-handshake" $ do
 
-    -- As of 2016-09-12, there was no reference file
-    -- for the test cases in `exercism/x-common`.
+    -- Test cases adapted from `exercism/x-common/secret-handshake` on 2017-01-31.
 
-    it "1 to wink" $ do
+    it "wink for 1" $
       handshake (1 :: Int) `shouldBe` ["wink"]
-      handshake "1"        `shouldBe` ["wink"]
 
-    it "10 to double blink" $ do
+    it "double blink for 10" $
       handshake (2 :: Int) `shouldBe` ["double blink"]
-      handshake "10"       `shouldBe` ["double blink"]
 
-    it "100 to close your eyes" $ do
+    it "close your eyes for 100" $
       handshake (4 :: Int) `shouldBe` ["close your eyes"]
-      handshake "100"      `shouldBe` ["close your eyes"]
 
-    it "1000 to jump" $ do
+    it "jump for 1000" $
       handshake (8 :: Int) `shouldBe` ["jump"]
-      handshake "1000"     `shouldBe` ["jump"]
 
-    it "11 to wink and double blink" $ do
+    it "combine two actions" $
       handshake (3 :: Int) `shouldBe` ["wink", "double blink"]
-      handshake "11"       `shouldBe` ["wink", "double blink"]
 
-    it "10011 to double blink and wink" $ do
+    it "reverse two actions" $
       handshake (19 :: Int) `shouldBe` ["double blink", "wink"]
-      handshake "10011"     `shouldBe` ["double blink", "wink"]
 
-    it "11111 to jump, close your eyes, double blink, and wink" $ do
+    it "reversing one action gives the same action" $
+      handshake (24 :: Int) `shouldBe` ["jump"]
+
+    it "reversing no actions still gives no actions" $
+      handshake (16 :: Int) `shouldBe` []
+
+    it "all possible actions" $
+      handshake (15 :: Int) `shouldBe` ["wink", "double blink", "close your eyes", "jump"]
+
+    it "reverse all possible actions" $
       handshake (31 :: Int) `shouldBe` ["jump", "close your eyes", "double blink", "wink"]
-      handshake "11111"     `shouldBe` ["jump", "close your eyes", "double blink", "wink"]
 
-    it "zero" $ do
+    it "do nothing for zero" $
       handshake (0 :: Int) `shouldBe` []
-      handshake "0"        `shouldBe` []
-
-    it "gibberish" $
-      handshake "piggies" `shouldBe` []
 
-    it "partial gibberish" $
-      handshake "1piggies" `shouldBe` []
+    it "do nothing if lower 5 bits not set" $
+      handshake (32 :: Int) `shouldBe` []

data/tracks/haskell/exercises/strain/examples/fail-reverse/package.yaml

@@ -0,0 +1,16 @@
+name: strain
+
+dependencies:
+  - base
+
+library:
+  exposed-modules: Strain
+  source-dirs: src
+
+tests:
+  test:
+    main: Tests.hs
+    source-dirs: test
+    dependencies:
+      - strain
+      - hspec

data/tracks/haskell/exercises/strain/examples/fail-reverse/src/Strain.hs

@@ -0,0 +1,9 @@
+module Strain (keep, discard) where
+
+keep, discard :: (a -> Bool) -> [a] -> [a]
+
+keep p = keep' []
+  where keep' acc [] = reverse acc
+        keep' acc (x:xs) = keep' (if p x then x:acc else acc) xs
+
+discard = keep . (not .)

data/tracks/haskell/exercises/triangle/test/Tests.hs

@@ -25,7 +25,8 @@ specs = describe "triangle" $
       where
         assertion = triangleType a b c `shouldBe` expected
 
-    -- Test cases adapted from `exercism/x-common/triangle.json` on 2016-08-03.
+    -- Test cases created from old version of `x-common` tests on 2017-01-31,
+    -- diverging from `exercism/x-common/triangle`.
 
     cases = [ ( "equilateral triangle has all sides equal"
               , (2, 2, 2)
@@ -55,6 +56,10 @@ specs = describe "triangle" $
               , (3, 4, 5)
               , Scalene
               )
+            , ( "2a == b+c looks like equilateral, but isn't always"
+              , (5, 4, 6)
+              , Scalene
+              )
             , ( "larger scalene triangle"
               , (10, 11, 12)
               , Scalene

data/tracks/julia/config.json

@@ -53,8 +53,17 @@
       "difficulty": 1,
       "topics": [
         "control-flow (conditionals)",
-				"integers",
-				"mathematics"
+        "integers",
+		"mathematics"
+      ]
+    },
+    {
+      "slug": "raindrops",
+      "difficulty": 1,
+      "topics": [
+        "control-flow (loops)",
+        "arrays",
+        "strings"
       ]
     },
     {
@@ -96,6 +105,15 @@
         "integers",
         "mathematics"
       ]
+    },
+    {
+      "slug": "secret-handshake",
+      "difficulty": 2,
+      "topics": [
+        "arrays",
+        "filtering",
+        "mathematics"
+      ]
     }
   ],
   "deprecated": [

data/tracks/julia/exercises/raindrops/example.jl

@@ -0,0 +1,16 @@
+# If the number has 3 as a factor, output 'Pling'.
+# If the number has 5 as a factor, output 'Plang'.
+# If the number has 7 as a factor, output 'Plong'.
+# If the number does not have 3, 5, or 7 as a factor, just pass the number's digits straight through.
+
+function raindrops(number::Int)
+  drops = []
+  number % 3 == 0 && push!(drops, "Pling")
+  number % 5 == 0 && push!(drops, "Plang")
+  number % 7 == 0 && push!(drops, "Plong")
+  if size(drops, 1) == 0
+    repr(number)
+  else
+    join(drops)
+  end
+end