trackler 2.2.1.45 → 2.2.1.46

data/tracks/groovy/exercises/triangle/Triangle.groovy

@@ -0,0 +1,15 @@
+class Triangle {
+
+    static boolean isEquilateral(Number a, Number b, Number c) {
+        throw new UnsupportedOperationException('isEquilateral method not implemented.')
+    }
+
+    static boolean isIsosceles(Number a, Number b, Number c) {
+        throw new UnsupportedOperationException('isIsosceles method not implemented.')
+    }
+
+    static boolean isScalene(Number a, Number b, Number c) {
+        throw new UnsupportedOperationException('isScalene method not implemented.')
+    }
+
+}

data/tracks/groovy/exercises/triangle/TriangleSpec.groovy

@@ -0,0 +1,66 @@
+@Grab('org.spockframework:spock-core:1.0-groovy-2.4')
+import spock.lang.*
+
+class TriangleSpec extends Specification {
+
+    def 'returns true if the triangle is equilateral'() {
+        expect: 'true if all sides are equal'
+        Triangle.isEquilateral(2, 2, 2)
+
+        and: 'false if any side is unequal'
+        !Triangle.isEquilateral(2, 3, 2)
+
+        and: 'false if no sides are equal'
+        !Triangle.isEquilateral(5, 4, 6)
+        
+        and: 'all zero sides are illegal, so the triangle is not equilateral' 
+        !Triangle.isEquilateral(0, 0, 0)
+    } 
+
+    def 'returns true if the triangle is isosceles'() {
+        expect: 'true if last two sides are equal'
+        Triangle.isIsosceles(3, 4, 4)
+
+        and: 'true if first two sides are equal'
+        Triangle.isIsosceles(4, 4, 3)
+
+        and: 'true if first and last sides are equal'
+        Triangle.isIsosceles(4, 3, 4)
+
+        and: 'equilateral triangles are also isosceles'
+        Triangle.isIsosceles(4, 4, 4)
+
+        and: 'false if no sides are equal'
+        !Triangle.isIsosceles(2, 3, 4)
+
+        and: 'sides that violate triangle inequality are not isosceles, even if two sides are equal'
+        !Triangle.isIsosceles(1, 1, 3)
+    }
+
+    def 'returns true if the triangle is scalene'() {
+        expect: 'true if no sides are equal'
+        Triangle.isScalene(5, 4, 6)
+
+        and: 'false if all sides are equal'
+        !Triangle.isScalene(4, 4, 4)
+
+        and: 'false if two sides are equal'
+        !Triangle.isScalene(4, 4, 3)
+
+        and: 'sides that violate triangle inequality are not scalene, even if they are all different'
+        !Triangle.isScalene(7, 3, 2)
+    }
+
+    @Ignore
+    def 'sides may be non-integral'() {
+        expect: 'equilateral triangle sides may be non-integral'
+        Triangle.isEquilateral(0.5, 0.5, 0.5)
+
+        and: 'isosceles triangle sides may be non-integral'
+        Triangle.isIsosceles(0.5, 0.4, 0.5)
+
+        and: 'scalene triangle sides may be non-integral'
+        Triangle.isScalene(0.5, 0.4, 0.6)
+    }
+
+}

data/tracks/haskell/config.json

@@ -114,6 +114,15 @@
       "topics": [
       ]
     },
+    {
+      "uuid": "4e10e864-2fe4-4926-b908-f70645698999",
+      "slug": "complex-numbers",
+      "core": false,
+      "unlocked_by": null,
+      "difficulty": 2,
+      "topics": [
+      ]
+    },
     {
       "uuid": "197a543c-d9c7-41c3-814c-4b1ece3db568",
       "slug": "grains",

data/tracks/haskell/exercises/all-your-base/package.yaml

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

data/tracks/haskell/exercises/all-your-base/test/Tests.hs

@@ -102,6 +102,24 @@ cases = [ Case { description  = "single bit one to decimal"
                , outputBase   = 10
                , outputDigits = Just [4, 2]
                }
+        , Case { description  = "first base is one"
+               , inputBase    = 1
+               , inputDigits  = []
+               , outputBase   = 10
+               , outputDigits = Nothing
+               }
+        , Case { description  = "first base is zero"
+               , inputBase    = 0
+               , inputDigits  = []
+               , outputBase   = 10
+               , outputDigits = Nothing
+               }
+        , Case { description  = "first base is negative"
+               , inputBase    = -2
+               , inputDigits  = [1]
+               , outputBase   = 10
+               , outputDigits = Nothing
+               }
         , Case { description  = "negative digit"
                , inputBase    = 2
                , inputDigits  = [1, -1, 1, 0, 1, 0]
@@ -114,36 +132,18 @@ cases = [ Case { description  = "single bit one to decimal"
                , outputBase   = 10
                , outputDigits = Nothing
                }
-        , Case { description  = "first base is one"
-               , inputBase    = 1
-               , inputDigits  = []
-               , outputBase   = 10
-               , outputDigits = Nothing
-               }
         , Case { description  = "second base is one"
                , inputBase    = 2
                , inputDigits  = [1, 0, 1, 0, 1, 0]
                , outputBase   = 1
                , outputDigits = Nothing
                }
-        , Case { description  = "first base is zero"
-               , inputBase    = 0
-               , inputDigits  = []
-               , outputBase   = 10
-               , outputDigits = Nothing
-               }
         , Case { description  = "second base is zero"
                , inputBase    = 10
                , inputDigits  = [7]
                , outputBase   = 0
                , outputDigits = Nothing
                }
-        , Case { description  = "first base is negative"
-               , inputBase    = -2
-               , inputDigits  = [1]
-               , outputBase   = 10
-               , outputDigits = Nothing
-               }
         , Case { description  = "second base is negative"
                , inputBase    = 2
                , inputDigits  = [1]

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

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

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

@@ -80,23 +80,23 @@ cases = [ Case { description = "should be able to score a game with all zeros"
                , rolls       = [10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10]
                , expected    = Right 300
                }
-        , Case { description = "rolls can not score negative points"
+        , Case { description = "rolls cannot score negative points"
                , rolls       = [-1]
                , expected    = Left $ InvalidRoll 0 (-1)
                }
-        , Case { description = "a roll can not score more than 10 points"
+        , Case { description = "a roll cannot score more than 10 points"
                , rolls       = [11]
                , expected    = Left $ InvalidRoll 0 11
                }
-        , Case { description = "two rolls in a frame can not score more than 10 points"
+        , Case { description = "two rolls in a frame cannot score more than 10 points"
                , rolls       = [5, 6]
                , expected    = Left $ InvalidRoll 1 6
                }
-        , Case { description = "bonus roll after a strike in the last frame can not score more than 10 points"
+        , Case { description = "bonus roll after a strike in the last frame cannot score more than 10 points"
                , rolls       = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 11]
                , expected    = Left $ InvalidRoll 19 11
                }
-        , Case { description = "two bonus rolls after a strike in the last frame can not score more than 10 points"
+        , Case { description = "two bonus rolls after a strike in the last frame cannot score more than 10 points"
                , rolls       = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 5, 6]
                , expected    = Left $ InvalidRoll 20 6
                }
@@ -104,19 +104,19 @@ cases = [ Case { description = "should be able to score a game with all zeros"
                , rolls       = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 10, 6]
                , expected    = Right 26
                }
-        , Case { description = "the second bonus rolls after a strike in the last frame can not be a strike if the first one is not a strike"
+        , Case { description = "the second bonus rolls after a strike in the last frame cannot be a strike if the first one is not a strike"
                , rolls       = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 6, 10]
                , expected    = Left $ InvalidRoll 20 10
                }
-        , Case { description = "second bonus roll after a strike in the last frame can not score than 10 points"
+        , Case { description = "second bonus roll after a strike in the last frame cannot score more than 10 points"
                , rolls       = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 10, 11]
                , expected    = Left $ InvalidRoll 20 11
                }
-        , Case { description = "an unstarted game can not be scored"
+        , Case { description = "an unstarted game cannot be scored"
                , rolls       = []
                , expected    = Left IncompleteGame
                }
-        , Case { description = "an incomplete game can not be scored"
+        , Case { description = "an incomplete game cannot be scored"
                , rolls       = [0, 0]
                , expected    = Left IncompleteGame
                }

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

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

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

@@ -56,6 +56,11 @@ cases = [ Case { description = "single coin change"
                , target = 21
                , expected = Just [2, 2, 2, 5, 10]
             }
+        , Case { description = "possible change without unit coins available, must stop early on larger coin"
+               , coins = [4, 5]
+               , target = 27
+               , expected = Just [4, 4, 4, 5, 5, 5]
+             }
         , Case { description = "no coins make 0 change"
                , coins = [1, 5, 10, 21, 25]
                , target = 0

data/tracks/haskell/exercises/complex-numbers/README.md

@@ -0,0 +1,92 @@
+# Complex Numbers
+
+A complex number is a number in the form `a + b * i` where `a` and `b` are real and `i` satisfies `i^2 = -1`.
+
+`a` is called the real part and `b` is called the imaginary part of `z`.
+The conjugate of the number `a + b * i` is the number `a - b * i`.
+The absolute value of a complex number `z = a + b * i` is a real number `|z| = sqrt(a^2 + b^2)`. The square of the absolute value `|z|^2` is the result of multiplication of `z` by its complex conjugate.
+
+The sum/difference of two complex numbers involves adding/subtracting their real and imaginary parts separately:
+`(a + i * b) + (c + i * d) = (a + c) + (b + d) * i`,
+`(a + i * b) - (c + i * d) = (a - c) + (b - d) * i`.
+
+Multiplication result is by definition
+`(a + i * b) * (c + i * d) = (a * c - b * d) + (b * c + a * d) * i`.
+
+The reciprocal of a non-zero complex number is
+`1 / (a + i * b) = a/(a^2 + b^2) - b/(a^2 + b^2) * i`.
+
+Dividing a complex number `a + i * b` by another `c + i * d` gives:
+`(a + i * b) / (c + i * d) = (a * c + b * d)/(c^2 + d^2) + (b * c - a * d)/(c^2 + d^2) * i`.
+
+Exponent of a complex number can be expressed as
+`exp(a + i * b) = exp(a) * exp(i * b)`,
+and the last term is given by Euler's formula `exp(i * b) = cos(b) + i * sin(b)`.
+
+
+Implement the following operations:
+ - addition, subtraction, multiplication and division of two complex numbers,
+ - conjugate, absolute value, exponent of a given complex number.
+
+
+Assume the programming language you are using does not have an implementation of complex numbers.
+
+
+## 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
+
+Wikipedia [https://en.wikipedia.org/wiki/Complex_number](https://en.wikipedia.org/wiki/Complex_number)
+
+## 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/complex-numbers/examples/success-standard/package.yaml

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

data/tracks/haskell/exercises/complex-numbers/examples/success-standard/src/ComplexNumbers.hs

@@ -0,0 +1,50 @@
+module ComplexNumbers
+(Complex,
+ conjugate,
+ abs,
+ mul,
+ add,
+ sub,
+ div,
+ real,
+ imaginary,
+ complex) where
+
+import Prelude hiding (div, abs)
+
+-- Data definition -------------------------------------------------------------
+data Complex a = Complex a a deriving (Eq, Show)
+
+--------------------------------------------------------------------------------
+complex :: (a, a) -> Complex a
+complex = uncurry Complex
+
+exp2 :: Num a => a -> a
+exp2 x = x^(2 :: Integer)
+
+-- unary operators -------------------------------------------------------------
+real :: Num a => Complex a -> a
+real (Complex a _) = a
+
+imaginary :: Num a => Complex a -> a
+imaginary (Complex _ b) = b
+
+conjugate :: Num a => Complex a -> Complex a
+conjugate (Complex a b) = Complex a (-b)
+
+abs :: Floating a => Complex a -> a
+abs (Complex a b) = sqrt (exp2 a + exp2 b)
+
+-- binary operators ------------------------------------------------------------
+mul :: Num a => Complex a -> Complex a -> Complex a
+mul (Complex a b) (Complex c d) = Complex (a*c - b*d) (a*d + b*c)
+
+add :: Num a => Complex a -> Complex a -> Complex a
+add (Complex a b) (Complex c d) = Complex (a+c) (b+d)
+
+sub :: Num a => Complex a -> Complex a -> Complex a
+sub (Complex a b) (Complex c d) = Complex (a-c) (b-d)
+
+div :: Fractional a => Complex a -> Complex a -> Complex a
+div (Complex a b) (Complex c d) = Complex ((a*c + b*d)/(exp2 c + exp2 d))
+                                          ((b*c - a*d)/(exp2 c + exp2 d))

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

@@ -0,0 +1,20 @@
+name: complex-numbers
+version: 1.0.0.1
+
+dependencies:
+  - base
+
+library:
+  exposed-modules: ComplexNumbers
+  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:
+      - complex-numbers
+      - hspec

data/tracks/haskell/exercises/complex-numbers/src/ComplexNumbers.hs

@@ -0,0 +1,45 @@
+module ComplexNumbers
+(Complex,
+ conjugate,
+ abs,
+ real,
+ imaginary,
+ mul,
+ add,
+ sub,
+ div,
+ complex) where
+
+import Prelude hiding (div, abs)
+
+-- Data definition -------------------------------------------------------------
+data Complex a = Dummy deriving(Eq, Show)
+
+complex :: (a, a) -> Complex a
+complex = error "You need to implement this function"
+
+-- unary operators -------------------------------------------------------------
+conjugate :: Num a => Complex a -> Complex a
+conjugate = error "You need to implement this function"
+
+abs :: Floating a => Complex a -> a
+abs = error "You need to implement this function"
+
+real :: Num a => Complex a -> a
+real = error "You need to implement this function"
+
+imaginary :: Num a => Complex a -> a
+imaginary = error "You need to implement this function"
+
+-- binary operators ------------------------------------------------------------
+mul :: Num a => Complex a -> Complex a -> Complex a
+mul = error "You need to implement this function"
+
+add :: Num a => Complex a -> Complex a -> Complex a
+add = error "You need to implement this function"
+
+sub :: Num a => Complex a -> Complex a -> Complex a
+sub = error "You need to implement this function"
+
+div :: Fractional a => Complex a -> Complex a -> Complex a
+div = error "You need to implement this function"