trackler 2.2.1.105 → 2.2.1.106

data/tracks/haskell/exercises/diamond/src/Diamond.hs

@@ -1,4 +1,4 @@
 module Diamond (diamond) where
 
-diamond :: Char -> [String]
+diamond :: Char -> Maybe [String]
 diamond = error "You need to implement this function"

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

@@ -14,7 +14,7 @@ specs = describe "diamond" $ for_ cases test
 
     test Case{..} = it description assertion
       where
-        assertion = diamond input `shouldBe` expected
+        assertion = diamond input `shouldBe` Just expected
 
 
 data Case = Case { description :: String

data/tracks/haskell/exercises/forth/package.yaml

@@ -1,5 +1,5 @@
 name: forth
-version: 1.4.0.6
+version: 1.5.0.7
 
 dependencies:
   - base

data/tracks/haskell/exercises/grains/package.yaml

@@ -1,5 +1,5 @@
 name: grains
-version: 1.0.0.3
+version: 1.1.0.4
 
 dependencies:
   - base

data/tracks/haskell/exercises/isogram/package.yaml

@@ -1,5 +1,5 @@
 name: isogram
-version: 1.2.0.2
+version: 1.3.0.3
 
 dependencies:
   - base

data/tracks/haskell/exercises/list-ops/package.yaml

@@ -1,5 +1,5 @@
 name: list-ops
-version: 0.1.0.2
+version: 2.2.0.4
 
 dependencies:
   - base

data/tracks/haskell/exercises/list-ops/test/Tests.hs

@@ -1,7 +1,7 @@
 {-# LANGUAGE DeriveAnyClass #-}
 
 import Control.Exception (Exception, throw, evaluate)
-import Test.Hspec        (Spec, it, shouldBe, shouldThrow)
+import Test.Hspec        (Spec, describe, it, shouldBe, shouldThrow)
 import Test.Hspec.Runner (configFastFail, defaultConfig, hspecWith)
 
 import Prelude hiding
@@ -35,78 +35,83 @@ specs = do
 
     let big = 100000 :: Int
 
-    it "length of empty list" $
-      length ([] :: [Int]) `shouldBe` 0
-
-    it "length of non-empty list" $
-      length [1 .. 4 :: Int] `shouldBe` 4
-
-    it "length of large list" $
-      length [1 .. big :: Int] `shouldBe` big
-
-    it "reverse of empty list" $
-      reverse ([] :: [Int]) `shouldBe` []
-
-    it "reverse of non-empty list" $
-      reverse [1 .. 100 :: Int] `shouldBe` [100 , 99 .. 1]
-
-    it "map of empty list" $
-      map (+1) ([] :: [Int]) `shouldBe` []
-
-    it "map of non-empty list" $
-      map (+1) [1, 3 .. 7 :: Int] `shouldBe` [2, 4 .. 8]
-
-    it "filter of empty list" $
-      filter undefined ([] :: [Int]) `shouldBe` []
-
-    it "filter of normal list" $
-      filter odd [1 .. 4 :: Int] `shouldBe` [1, 3]
-
-    it "foldl' of empty list" $
-      foldl' (+) (0 :: Int) [] `shouldBe` 0
-
-    it "foldl' of non-empty list" $
-      foldl' (+) (-3) [1 .. 4 :: Int] `shouldBe` 7
-
-    it "foldl' of huge list" $
-      foldl' (+) 0 [1 .. big] `shouldBe` big * (big + 1) `div` 2
-
-    it "foldl' with non-commutative function" $
-      foldl' (-) 10 [1 .. 4 :: Int] `shouldBe` 0
-
-    it "foldl' is not just foldr . flip" $
-      foldl' (flip (:)) [] "asdf" `shouldBe` "fdsa"
-
-    it "foldl' is accumulator-strict (use seq or BangPatterns)" $
-      evaluate (foldl' (flip const) () [throw StrictException, ()])
-      `shouldThrow` (== StrictException)
-
-    it "foldr as id" $
-      foldr (:) [] [1 .. big] `shouldBe` [1 .. big]
-
-    it "foldr as append" $
-      foldr (:) [100 .. big] [1 .. 99] `shouldBe` [1 .. big]
-
-    it "++ of empty lists" $
-      [] ++ ([] :: [Int]) `shouldBe` []
-
-    it "++ of empty and non-empty lists" $
-      [] ++ [1 .. 4 :: Int] `shouldBe` [1 .. 4]
-
-    it "++ of non-empty and empty lists" $
-      [1 .. 4 :: Int] ++ [] `shouldBe` [1 .. 4]
-
-    it "++ of non-empty lists" $
-      [1 .. 3] ++ [4, 5 :: Int] `shouldBe` [1 .. 5]
-
-    it "++ of large lists" $
-      [1 .. big `div` 2] ++ [1 + big `div` 2 .. big] `shouldBe` [1 .. big]
-
-    it "concat of no lists" $
-      concat ([] :: [[Int]]) `shouldBe` []
-
-    it "concat of list of lists" $
-      concat [[1, 2], [3], [], [4, 5, 6 :: Int]] `shouldBe` [1 .. 6]
-
-    it "concat of large list of small lists" $
-      concat (map (:[]) [1 .. big]) `shouldBe` [1 .. big]
+    describe "length" $ do
+      it "of empty list" $
+        length ([] :: [Int]) `shouldBe` 0
+      it "of non-empty list" $
+        length [1 .. 4 :: Int] `shouldBe` 4
+      -- Track-specific test
+      it "of large list" $
+        length [1 .. big :: Int] `shouldBe` big
+
+    describe "reverse" $ do
+      it "of empty list" $
+        reverse ([] :: [Int]) `shouldBe` []
+      it "of non-empty list" $
+        reverse [1 .. 100 :: Int] `shouldBe` [100 , 99 .. 1]
+
+    describe "map" $ do
+      it "of empty list" $
+        map (+1) ([] :: [Int]) `shouldBe` []
+      it "of non-empty list" $
+        map (+1) [1, 3 .. 7 :: Int] `shouldBe` [2, 4 .. 8]
+
+    describe "filter" $ do
+      it "of empty list" $
+        filter undefined ([] :: [Int]) `shouldBe` []
+      it "of normal list" $
+        filter odd [1 .. 4 :: Int] `shouldBe` [1, 3]
+
+    describe "foldl'" $ do
+      it "of empty list" $
+        foldl' (+) (0 :: Int) [] `shouldBe` 0
+      it "of non-empty list" $
+        foldl' (+) (-3) [1 .. 4 :: Int] `shouldBe` 7
+      -- Track-specific test
+      it "of huge list" $
+        foldl' (+) 0 [1 .. big] `shouldBe` big * (big + 1) `div` 2
+      it "with non-commutative function" $
+        foldl' (-) 10 [1 .. 4 :: Int] `shouldBe` 0
+      -- Track-specific test
+      it "is not just foldr . flip" $
+        foldl' (flip (:)) [] "asdf" `shouldBe` "fdsa"
+      -- Track-specific test
+      it "is accumulator-strict (use seq or BangPatterns)" $
+        evaluate (foldl' (flip const) () [throw StrictException, ()])
+        `shouldThrow` (== StrictException)
+
+    describe "foldr" $ do
+      it "of empty list" $
+        foldr (*) (2 :: Int) [] `shouldBe` 2
+      it "of non-empty list" $
+        foldr (+) 5 [1 .. 4 :: Int] `shouldBe` 15
+      it "with non-commutative function" $
+        foldr div 5 [2, 5 :: Int] `shouldBe` 2
+      -- Track-specific test
+      it "as id" $
+        foldr (:) [] [1 .. big] `shouldBe` [1 .. big]
+      -- Track-specific test
+      it "as append" $
+        foldr (:) [100 .. big] [1 .. 99] `shouldBe` [1 .. big]
+
+    describe "++" $ do
+      it "of empty lists" $
+        [] ++ ([] :: [Int]) `shouldBe` []
+      it "of empty and non-empty lists" $
+        [] ++ [1 .. 4 :: Int] `shouldBe` [1 .. 4]
+      it "of non-empty and empty lists" $
+        [1 .. 4 :: Int] ++ [] `shouldBe` [1 .. 4]
+      it "of non-empty lists" $
+        [1 .. 3] ++ [4, 5 :: Int] `shouldBe` [1 .. 5]
+      -- Track-specific test
+      it "of large lists" $
+        [1 .. big `div` 2] ++ [1 + big `div` 2 .. big] `shouldBe` [1 .. big]
+
+    describe "concat" $ do
+      it "of no lists" $
+        concat ([] :: [[Int]]) `shouldBe` []
+      it "of list of lists" $
+        concat [[1, 2], [3], [], [4, 5, 6 :: Int]] `shouldBe` [1 .. 6]
+      -- Track-specific test
+      it "of large list of small lists" $
+        concat (map (:[]) [1 .. big]) `shouldBe` [1 .. big]

data/tracks/haskell/exercises/pov/package.yaml

@@ -1,5 +1,5 @@
 name: pov
-version: 1.1.1.4
+version: 1.2.0.5
 
 dependencies:
   - base

data/tracks/haskell/exercises/protein-translation/README.md

@@ -0,0 +1,102 @@
+# Protein Translation
+
+Translate RNA sequences into proteins.
+
+RNA can be broken into three nucleotide sequences called codons, and then translated to a polypeptide like so:
+
+RNA: `"AUGUUUUCU"` => translates to
+
+Codons: `"AUG", "UUU", "UCU"`
+=> which become a polypeptide with the following sequence =>
+
+Protein: `"Methionine", "Phenylalanine", "Serine"`
+
+There are 64 codons which in turn correspond to 20 amino acids; however, all of the codon sequences and resulting amino acids are not important in this exercise.  If it works for one codon, the program should work for all of them.
+However, feel free to expand the list in the test suite to include them all.
+
+There are also three terminating codons (also known as 'STOP' codons); if any of these codons are encountered (by the ribosome), all translation ends and the protein is terminated.
+
+All subsequent codons after are ignored, like this:
+
+RNA: `"AUGUUUUCUUAAAUG"` =>
+
+Codons: `"AUG", "UUU", "UCU", "UAA", "AUG"` =>
+
+Protein: `"Methionine", "Phenylalanine", "Serine"`
+
+Note the stop codon `"UAA"` terminates the translation and the final methionine is not translated into the protein sequence.
+
+Below are the codons and resulting Amino Acids needed for the exercise.
+
+Codon                 | Protein
+:---                  | :---
+AUG                   | Methionine
+UUU, UUC              | Phenylalanine
+UUA, UUG              | Leucine
+UCU, UCC, UCA, UCG    | Serine
+UAU, UAC              | Tyrosine
+UGU, UGC              | Cysteine
+UGG                   | Tryptophan
+UAA, UAG, UGA         | STOP
+
+Learn more about [protein translation on Wikipedia](http://en.wikipedia.org/wiki/Translation_(biology))
+
+
+## Getting Started
+
+For installation and learning resources, refer to the
+[exercism help page](http://exercism.io/languages/haskell).
+
+## Running the tests
+
+To run the test suite, execute the following command:
+
+```bash
+stack test
+```
+
+#### If you get an error message like this...
+
+```
+No .cabal file found in directory
+```
+
+You are probably running an old stack version and need
+to upgrade it.
+
+#### Otherwise, if you get an error message like this...
+
+```
+No compiler found, expected minor version match with...
+Try running "stack setup" to install the correct GHC...
+```
+
+Just do as it says and it will download and install
+the correct compiler version:
+
+```bash
+stack setup
+```
+
+## Running *GHCi*
+
+If you want to play with your solution in GHCi, just run the command:
+
+```bash
+stack ghci
+```
+
+## Feedback, Issues, Pull Requests
+
+The [exercism/haskell](https://github.com/exercism/haskell) repository on
+GitHub is the home for all of the Haskell exercises.
+
+If you have feedback about an exercise, or want to help implementing a new
+one, head over there and create an issue.  We'll do our best to help you!
+
+## Source
+
+Tyler Long
+
+## Submitting Incomplete Solutions
+It's possible to submit an incomplete solution so you can see how others have completed the exercise.

data/tracks/haskell/exercises/protein-translation/examples/success-standard/package.yaml

@@ -0,0 +1,17 @@
+name: protein-translation
+
+dependencies:
+  - base
+
+library:
+  exposed-modules: ProteinTranslation
+  source-dirs: src
+  dependencies: split
+
+tests:
+  test:
+    main: Tests.hs
+    source-dirs: test
+    dependencies:
+      - protein-translation
+      - hspec

data/tracks/haskell/exercises/protein-translation/examples/success-standard/src/ProteinTranslation.hs

@@ -0,0 +1,24 @@
+module ProteinTranslation(proteins) where
+
+import Data.List.Split (chunksOf)
+
+validCodon :: String -> Bool
+validCodon x = x `elem` ["AUG","UUU","UUC","UUA","UUG","UCU","UCC","UCA","UCG",
+                         "UAU","UAC","UGU","UGC","UGG","UAA","UAG","UGA"]
+
+proteins' :: String -> String
+proteins' x | x == "AUG"                         = "Methionine"
+            | x == "UGG"                         = "Tryptophan"
+            | x `elem` ["UUU","UUC"]             = "Phenylalanine"
+            | x `elem` ["UUA","UUG"]             = "Leucine"
+            | x `elem` ["UCU","UCC","UCA","UCG"] = "Serine"
+            | x `elem` ["UAU","UAC"]             = "Tyrosine"
+            | x `elem` ["UGU","UGC"]             = "Cysteine"
+            | otherwise                          = "STOP"
+
+proteins :: String -> Maybe [String]
+proteins xs = if length xs `mod` 3 == 0 && all validCodon codons
+                then Just (takeWhile (/= "STOP") (map proteins' codons))
+                else Nothing
+  where
+    codons = chunksOf 3 xs

data/tracks/haskell/exercises/protein-translation/package.yaml

@@ -0,0 +1,20 @@
+name: protein-translation
+version: 1.1.0.1
+
+dependencies:
+  - base
+
+library:
+  exposed-modules: ProteinTranslation
+  source-dirs: src
+  dependencies:
+  # - foo       # List here the packages you
+  # - bar       # want to use in your solution.
+
+tests:
+  test:
+    main: Tests.hs
+    source-dirs: test
+    dependencies:
+      - protein-translation
+      - hspec

data/tracks/haskell/exercises/protein-translation/src/ProteinTranslation.hs

@@ -0,0 +1,4 @@
+module ProteinTranslation(proteins) where
+
+proteins :: String -> Maybe [String]
+proteins = error "You need to implement this function!"

data/tracks/haskell/exercises/protein-translation/stack.yaml

@@ -0,0 +1 @@
+resolver: lts-10.2

data/tracks/haskell/exercises/protein-translation/test/Tests.hs

@@ -0,0 +1,119 @@
+{-# LANGUAGE RecordWildCards #-}
+
+import Data.Foldable     (for_)
+import Test.Hspec        (Spec, describe, it, shouldBe)
+import Test.Hspec.Runner (configFastFail, defaultConfig, hspecWith)
+
+import ProteinTranslation (proteins)
+
+main :: IO ()
+main = hspecWith defaultConfig {configFastFail = True} specs
+
+specs :: Spec
+specs = describe "proteins" $ for_ cases test
+  where
+
+    test Case{..} = it description assertion
+      where
+        assertion = proteins input `shouldBe` expected
+
+
+data Case = Case { description :: String
+                 , input       :: String
+                 , expected    :: Maybe [String]
+                 }
+
+cases :: [Case]
+cases = [ Case { description = "Methionine RNA sequence"
+               , input       = "AUG"
+               , expected    = Just ["Methionine"]
+               }
+        , Case { description = "Phenylalanine RNA sequence 1"
+               , input       = "UUU"
+               , expected    = Just ["Phenylalanine"]
+               }
+        , Case { description = "Phenylalanine RNA sequence 2"
+               , input       = "UUC"
+               , expected    = Just ["Phenylalanine"]
+               }
+        , Case { description = "Leucine RNA sequence 1"
+               , input       = "UUA"
+               , expected    = Just ["Leucine"]
+               }
+        , Case { description = "Leucine RNA sequence 2"
+               , input       = "UUG"
+               , expected    = Just ["Leucine"]
+               }
+        , Case { description = "Serine RNA sequence 1"
+               , input       = "UCU"
+               , expected    = Just ["Serine"]
+               }
+        , Case { description = "Serine RNA sequence 2"
+               , input       = "UCC"
+               , expected    = Just ["Serine"]
+               }
+        , Case { description = "Serine RNA sequence 3"
+               , input       = "UCA"
+               , expected    = Just ["Serine"]
+               }
+        , Case { description = "Serine RNA sequence 4"
+               , input       = "UCG"
+               , expected    = Just ["Serine"]
+               }
+        , Case { description = "Tyrosine RNA sequence 1"
+               , input       = "UAU"
+               , expected    = Just ["Tyrosine"]
+               }
+        , Case { description = "Tyrosine RNA sequence 2"
+               , input       = "UAC"
+               , expected    = Just ["Tyrosine"]
+               }
+        , Case { description = "Cysteine RNA sequence 1"
+               , input       = "UGU"
+               , expected    = Just ["Cysteine"]
+               }
+        , Case { description = "Cysteine RNA sequence 2"
+               , input       = "UGC"
+               , expected    = Just ["Cysteine"]
+               }
+        , Case { description = "Tryptophan RNA sequence"
+               , input       = "UGG"
+               , expected    = Just ["Tryptophan"]
+               }
+        , Case { description = "STOP codon RNA sequence 1"
+               , input       = "UAA"
+               , expected    = Just []
+               }
+        , Case { description = "STOP codon RNA sequence 2"
+               , input       = "UAG"
+               , expected    = Just []
+               }
+        , Case { description = "STOP codon RNA sequence 3"
+               , input       = "UGA"
+               , expected    = Just []
+               }
+        , Case { description = "Translate RNA strand into correct protein list"
+               , input       = "AUGUUUUGG"
+               , expected    = Just ["Methionine","Phenylalanine","Tryptophan"]
+               }
+        , Case { description = "Translation stops if STOP codon at beginning of sequence"
+               , input       = "UAGUGG"
+               , expected    = Just []
+               }
+        , Case { description = "Translation stops if STOP codon at end of two-codon sequence"
+               , input       = "UGGUAG"
+               , expected    = Just ["Tryptophan"]
+               }
+        , Case { description = "Translation stops if STOP codon at end of three-codon sequence"
+               , input       = "AUGUUUUAA"
+               , expected    = Just ["Methionine","Phenylalanine"]
+               }
+        , Case { description = "Translation stops if STOP codon in middle of three-codon sequence"
+               , input       = "UGGUAGUGG"
+               , expected    = Just ["Tryptophan"]
+               }
+        , Case { description = "Translation stops if STOP codon in middle of six-codon sequence"
+               , input       = "UGGUGUUAUUAAUGGUUU"
+               , expected    = Just ["Tryptophan","Cysteine","Tyrosine"]
+               }
+        ]

data/tracks/haskell/exercises/zipper/package.yaml

@@ -1,5 +1,5 @@
 name: zipper
-version: 1.0.0.3
+version: 1.1.0.4
 
 dependencies:
   - base

data/tracks/java/.github/PULL_REQUEST_TEMPLATE.md

@@ -7,4 +7,4 @@
 
 Reviewer Resources:
 
-[Track Policies](https://github.com/exercism/xjava/blob/master/POLICIES.md#event-checklist)
+[Track Policies](https://github.com/exercism/java/blob/master/POLICIES.md#event-checklist)

data/tracks/java/config.json

@@ -612,6 +612,19 @@
       "unlocked_by": "rotational-cipher",
       "uuid": "d36ce010-210f-4e9a-9d6c-cb933e0a59af"
     },
+    {
+      "core": false,
+      "difficulty": 5,
+      "slug": "two-bucket",
+      "topics": [
+        "algorithms",
+        "loops",
+        "conditionals",
+        "mathematics"
+      ],
+      "unlocked_by": "triangle",
+      "uuid": "210bf628-b385-443b-8329-3483cc6e8d7e"
+    },
     {
       "core": false,
       "difficulty": 6,