trackler 2.2.1.45 → 2.2.1.46

data/tracks/haskell/exercises/complex-numbers/stack.yaml

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

data/tracks/haskell/exercises/complex-numbers/test/Tests.hs

@@ -0,0 +1,194 @@
+{-# LANGUAGE RecordWildCards #-}
+
+import Prelude hiding    (abs, div)
+import Data.Foldable     (for_)
+import Test.Hspec        (Spec, describe, it, shouldBe)
+import Test.Hspec.Runner (configFastFail, defaultConfig, hspecWith)
+
+import ComplexNumbers
+
+main :: IO ()
+main = hspecWith defaultConfig {configFastFail = True} specs
+
+specs :: Spec
+specs = do
+          describe "real"      $ for_ realCases      $ testC real
+          describe "imaginary" $ for_ imaginaryCases $ testC imaginary
+          describe "conjugate" $ for_ conjugateCases $ testB conjugate
+          describe "abs"       $ for_ absCases       $ testC abs
+          describe "mul"       $ for_ mulCases       $ testA mul
+          describe "div"       $ for_ divCases       $ testA div
+          describe "add"       $ for_ addCases       $ testA add
+          describe "sub"       $ for_ subCases       $ testA sub
+ where
+  testA f CaseA{..} = it descriptionA $ f (complex number1A) (complex number2A)
+                                        `shouldBe` complex expectedA
+  testB f CaseB{..} = it descriptionB $ f (complex number1B)
+                                        `shouldBe` complex expectedB
+  testC f CaseC{..} = it descriptionC $ f (complex number1C)
+                                        `shouldBe` expectedC
+
+
+data CaseA = CaseA { descriptionA :: String
+                   , number1A     :: (Float, Float)
+                   , number2A     :: (Float, Float)
+                   , expectedA    :: (Float, Float)
+                   }
+
+data CaseB = CaseB { descriptionB :: String
+                   , number1B     :: (Float, Float)
+                   , expectedB    :: (Float, Float)
+                   }
+
+data CaseC = CaseC { descriptionC :: String
+                   , number1C     :: (Float, Float)
+                   , expectedC    :: Float
+                   }
+
+realCases :: [CaseC]
+realCases =
+    [ CaseC { descriptionC = "Real part of a purely real number"
+            , number1C     = (1, 0)
+            , expectedC    = 1
+            }
+    , CaseC { descriptionC = "Real part of a purely imaginary number"
+            , number1C     = (0, 1)
+            , expectedC    = 0
+            }
+    , CaseC { descriptionC = "Real part of a number with real and imaginary part"
+            , number1C     = (1, 2)
+            , expectedC    = 1
+            }
+    ]
+
+imaginaryCases :: [CaseC]
+imaginaryCases =
+    [ CaseC { descriptionC = "Imaginary part of a purely real number"
+            , number1C     = (1, 0)
+            , expectedC    = 0
+            }
+    , CaseC { descriptionC = "Imaginary part of a purely imaginary number"
+            , number1C     = (0, 1)
+            , expectedC    = 1
+            }
+    , CaseC { descriptionC = "Imaginary part of a number with real and imaginary part"
+            , number1C     = (1, 2)
+            , expectedC    = 2
+            }
+    ]
+
+conjugateCases :: [CaseB]
+conjugateCases =
+    [ CaseB { descriptionB = "Conjugate a purely real number"
+            , number1B     = (5, 0)
+            , expectedB    = (5, 0)
+            }
+    , CaseB { descriptionB = "Conjugate a purely imaginary number"
+            , number1B     = (0, 5)
+            , expectedB    = (0, -5)
+            }
+    , CaseB { descriptionB = "Conjugate a number with real and imaginary part"
+            , number1B     = (1, 1)
+            , expectedB    = (1, -1)
+            }
+    ]
+
+absCases :: [CaseC]
+absCases =
+    [ CaseC { descriptionC = "Absolute value of a positive purely real number"
+            , number1C     = (5, 0)
+            , expectedC    = 5
+            }
+    , CaseC { descriptionC = "Absolute value of a negative purely real number"
+            , number1C     = (-5, 0)
+            , expectedC    = 5
+            }
+    , CaseC { descriptionC = "Absolute value of a purely imaginary number with positive imaginary part"
+            , number1C     = (0, 5)
+            , expectedC    = 5
+            }
+    , CaseC { descriptionC = "Absolute value of a purely imaginary number with negative imaginary part"
+            , number1C     = (0, -5)
+            , expectedC    = 5
+            }
+    , CaseC { descriptionC = "Absolute value of a number with real and imaginary part"
+            , number1C     = (3, 4)
+            , expectedC    = 5
+            }
+    ]
+
+mulCases :: [CaseA]
+mulCases =
+    [ CaseA { descriptionA = "Multiply purely real numbers"
+            , number1A     = (1, 0)
+            , number2A     = (2, 0)
+            , expectedA    = (2, 0)
+            }
+    , CaseA { descriptionA = "Multiply purely imaginary numbers"
+            , number1A     = (0, 1)
+            , number2A     = (0, 2)
+            , expectedA    = (-2, 0)
+            }
+    , CaseA { descriptionA = "Multiply numbers with real and imaginary part"
+            , number1A     = (1, 2)
+            , number2A     = (3, 4)
+            , expectedA    = (-5, 10)
+            }
+    ]
+
+divCases :: [CaseA]
+divCases =
+    [ CaseA { descriptionA = "Divide purely real numbers"
+            , number1A     = (1, 0)
+            , number2A     = (2, 0)
+            , expectedA    = (0.5, 0)
+            }
+    , CaseA { descriptionA = "Divide purely imaginary numbers"
+            , number1A     = (0, 1)
+            , number2A     = (0, 2)
+            , expectedA    = (0.5, 0)
+            }
+    , CaseA { descriptionA = "Divide numbers with real and imaginary part"
+            , number1A     = (1, 2)
+            , number2A     = (3, 4)
+            , expectedA    = (0.44, 0.08)
+            }
+    ]
+
+addCases :: [CaseA]
+addCases =
+    [ CaseA { descriptionA = "Add purely real numbers"
+            , number1A     = (1, 0)
+            , number2A     = (2, 0)
+            , expectedA    = (3, 0)
+            }
+    , CaseA { descriptionA = "Add purely imaginary numbers"
+            , number1A     = (0, 1)
+            , number2A     = (0, 2)
+            , expectedA    = (0, 3)
+            }
+    , CaseA { descriptionA = "Add numbers with real and imaginary part"
+            , number1A     = (1, 2)
+            , number2A     = (3, 4)
+            , expectedA    = (4, 6)
+            }
+    ]
+
+subCases :: [CaseA]
+subCases =
+    [ CaseA { descriptionA = "Subtract purely real numbers"
+            , number1A     = (1, 0)
+            , number2A     = (2, 0)
+            , expectedA    = (-1, 0)
+            }
+    , CaseA { descriptionA = "Subtract purely imaginary numbers"
+            , number1A     = (0, 1)
+            , number2A     = (0, 2)
+            , expectedA    = (0, -1)
+            }
+    , CaseA { descriptionA = "Subtract numbers with real and imaginary part"
+            , number1A     = (1, 2)
+            , number2A     = (3, 4)
+            , expectedA    = (-2, -2)
+            }
+    ]

data/tracks/haskell/exercises/crypto-square/package.yaml

@@ -1,5 +1,5 @@
 name: crypto-square
-version: 0.1.0.2
+version: 3.0.0.3
 
 dependencies:
   - base

data/tracks/haskell/exercises/crypto-square/test/Tests.hs

@@ -31,20 +31,28 @@ data Case = Case { description :: String
                  }
 
 cases :: [Case]
-cases = [ Case { description = "perfect square, all lowercase with space"
-               , input       = "a dog"
-               , expected    = "ao dg"
+cases = [ Case { description = "Lowercase"
+               , input       = "A"
+               , expected    = "a"
                }
-        , Case { description = "perfect rectangle, mixed case"
-               , input       = "A camel"
-               , expected    = "am ce al"
+        , Case { description = "Remove spaces"
+               , input       = "  b "
+               , expected    = "b"
                }
-        , Case { description = "incomplete square with punctuation"
-               , input       = "Wait, fox!"
-               , expected    = "wtx af io"
+        , Case { description = "Remove punctuation"
+               , input       = "@1,%!"
+               , expected    = "1"
                }
-        , Case { description = "incomplete rectangle with symbols"
-               , input       = "cat | cut -d@ -f1 | sort | uniq"
-               , expected    = "ctoi adrq tft c1u usn"
+        , Case { description = "empty plaintext results in an empty ciphertext"
+               , input       = ""
+               , expected    = ""
+               }
+        , Case { description = "9 character plaintext results in 3 chunks of 3 characters"
+               , input       = "This is fun!"
+               , expected    = "tsf hiu isn"
+               }
+        , Case { description = "54 character plaintext results in 7 chunks, the last two padded with spaces"
+               , input       = "If man was meant to stay on the ground, god would have given us roots."
+               , expected    = "imtgdvs fearwer mayoogo anouuio ntnnlvt wttddes aohghn  sseoau "
                }
         ]

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

@@ -1,5 +1,5 @@
 name: dominoes
-version: 1.0.1.4
+version: 2.0.0.5
 
 dependencies:
   - base

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

@@ -1,5 +1,5 @@
 name: forth
-version: 1.0.0.3
+version: 1.2.0.4
 
 dependencies:
   - base

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

@@ -21,9 +21,6 @@ specs = do
       it "numbers just get pushed onto the stack" $
         runTexts ["1 2 3 4 5"] `shouldBe` Right [1, 2, 3, 4, 5]
 
-      it "all non-word characters are separators" $
-        runTexts ["1\NUL2\SOH3\n4\r5 6\t7"] `shouldBe` Right [1, 2, 3, 4, 5, 6, 7]
-
     describe "addition" $ do
       it "can add two numbers" $
         runTexts ["1 2 +"] `shouldBe` Right [3]
@@ -121,6 +118,10 @@ specs = do
         runTexts [ ": swap dup ;"
                  , "1 swap"       ] `shouldBe` Right [1, 1]
 
+      it "can override built-in operators" $
+        runTexts [ ": + * ;"
+                 , "3 4 +"   ] `shouldBe` Right [12]
+
       it "cannot redefine numbers" $
         runTexts [": 1 2 ;"] `shouldBe` Left InvalidWord
 

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

@@ -1,5 +1,5 @@
 name: hamming
-version: 1.0.0.3
+version: 2.0.0.4
 
 dependencies:
   - base

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

@@ -26,7 +26,12 @@ data Case = Case { description :: String
                  }
 
 cases :: [Case]
-cases = [ Case { description = "identical strands"
+cases = [ Case { description = "empty strands"
+               , strand1     = ""
+               , strand2     = ""
+               , expected    = Just 0
+               }
+        , Case { description = "identical strands"
                , strand1     = "A"
                , strand2     = "A"
                , expected    = Just 0
@@ -86,11 +91,6 @@ cases = [ Case { description = "identical strands"
                , strand2     = "AGGACGGATTCT"
                , expected    = Just 9
                }
-        , Case { description = "empty strands"
-               , strand1     = ""
-               , strand2     = ""
-               , expected    = Just 0
-               }
         , Case { description = "disallow first strand longer"
                , strand1     = "AATG"
                , strand2     = "AAA"

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

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

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

@@ -48,8 +48,8 @@ cases = [ Case { description = "empty string"
                , input       = "thumbscrew-japingly"
                , expected    = True
                }
-        , Case { description = "isogram with duplicated non letter character"
-               , input       = "Hjelmqvist-Gryb-Zock-Pfund-Wax"
+        , Case { description = "isogram with duplicated hyphen"
+               , input       = "six-year-old"
                , expected    = True
                }
         , Case { description = "made-up name that is an isogram"

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

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

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

@@ -30,7 +30,7 @@ cases = [ Case { description = "year not divisible by 4: common year"
                , expected    = False
                }
         , Case { description = "year divisible by 4, not divisible by 100: leap year"
-               , input       = 2016
+               , input       = 2020
                , expected    = True
                }
         , Case { description = "year divisible by 100, not divisible by 400: common year"

data/tracks/haskell/exercises/pascals-triangle/package.yaml

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

data/tracks/haskell/exercises/pig-latin/examples/success-standard/src/PigLatin.hs

@@ -10,6 +10,8 @@ consonantCluster = qu . break (`elem` "aeiou")
 translateWord :: String -> String
 translateWord xs@('y':'t':_) = xs ++ "ay" -- I'm not proud of this ugly hack,
 translateWord xs@('x':'r':_) = xs ++ "ay" -- but now it passes the tests.
+translateWord ('r':'h':xs)   = xs ++ "rhay"
+translateWord "my"           = "ymay"
 translateWord w0 = concat [before, w, cs, "ay", after]
   where
     (before, w1) = break isLetter w0

data/tracks/haskell/exercises/pig-latin/package.yaml

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

data/tracks/haskell/exercises/pig-latin/test/Tests.hs

@@ -36,5 +36,13 @@ specs = describe "translate" $ do
         it "word beginning with yt" $ translate "yttria" `shouldBe` "yttriaay"
         it "word beginning with xr" $ translate "xray"   `shouldBe` "xrayay"
 
+    describe "position of y in a word determines if it is a consonant or a vowel" $ do
+        it "y is treated like a consonant at the beginning of a word" $
+          translate "yellow" `shouldBe` "ellowyay"
+        it "y is treated like a vowel at the end of a consonant cluster" $
+          translate "rhythm" `shouldBe` "ythmrhay"
+        it "y as second letter in two letter word" $
+          translate "my" `shouldBe` "ymay"
+
     describe "phrases are translated" $
         it "a whole phrase" $ translate "quick fast run" `shouldBe` "ickquay astfay unray"

data/tracks/haskell/exercises/queen-attack/package.yaml

@@ -1,5 +1,5 @@
 name: queen-attack
-version: 1.0.0.3
+version: 2.0.0.4
 
 dependencies:
   - base

data/tracks/haskell/exercises/rna-transcription/package.yaml

@@ -1,5 +1,5 @@
 name: rna-transcription
-version: 1.0.0.3
+version: 1.0.1.4
 
 dependencies:
   - base

data/tracks/haskell/exercises/rna-transcription/test/Tests.hs

@@ -20,35 +20,35 @@ data Case = Case { description ::       String
                  }
 
 cases :: [Case]
-cases = [ Case { description = "rna complement of cytosine is guanine"
+cases = [ Case { description = "RNA complement of cytosine is guanine"
                , dna         =      "C"
                , expected    = Just "G"
                }
-        , Case { description = "rna complement of guanine is cytosine"
+        , Case { description = "RNA complement of guanine is cytosine"
                , dna         =      "G"
                , expected    = Just "C"
                }
-        , Case { description = "rna complement of thymine is adenine"
+        , Case { description = "RNA complement of thymine is adenine"
                , dna         =      "T"
                , expected    = Just "A"
                }
-        , Case { description = "rna complement of adenine is uracil"
+        , Case { description = "RNA complement of adenine is uracil"
                , dna         =      "A"
                , expected    = Just "U"
                }
-        , Case { description = "rna complement"
+        , Case { description = "RNA complement"
                , dna         =      "ACGTGGTCTTAA"
                , expected    = Just "UGCACCAGAAUU"
                }
-        , Case { description = "dna correctly handles invalid input"
+        , Case { description = "correctly handles invalid input (RNA instead of DNA)"
                , dna         = "U"
                , expected    = Nothing
                }
-        , Case { description = "dna correctly handles completely invalid input"
+        , Case { description = "correctly handles completely invalid DNA input"
                , dna         = "XXX"
                , expected    = Nothing
                }
-        , Case { description = "dna correctly handles partially invalid input"
+        , Case { description = "correctly handles partially invalid DNA input"
                , dna         = "ACGTXXXCTTAA"
                , expected    = Nothing
                }