trackler 2.2.1.40 → 2.2.1.41

data/tracks/haskell/exercises/diamond/README.md

@@ -0,0 +1,113 @@
+# Diamond
+
+The diamond kata takes as its input a letter, and outputs it in a diamond
+shape. Given a letter, it prints a diamond starting with 'A', with the
+supplied letter at the widest point.
+
+## Requirements
+
+* The first row contains one 'A'.
+* The last row contains one 'A'.
+* All rows, except the first and last, have exactly two identical letters.
+* All rows have as many trailing spaces as leading spaces. (This might be 0).
+* The diamond is horizontally symmetric.
+* The diamond is vertically symmetric.
+* The diamond has a square shape (width equals height).
+* The letters form a diamond shape.
+* The top half has the letters in ascending order.
+* The bottom half has the letters in descending order.
+* The four corners (containing the spaces) are triangles.
+
+## Examples
+
+In the following examples, spaces are indicated by `·` characters.
+
+Diamond for letter 'A':
+
+```text
+A
+```
+
+Diamond for letter 'C':
+
+```text
+··A··
+·B·B·
+C···C
+·B·B·
+··A··
+```
+
+Diamond for letter 'E':
+
+```text
+····A····
+···B·B···
+··C···C··
+·D·····D·
+E·······E
+·D·····D·
+··C···C··
+···B·B···
+····A····
+```
+
+
+## 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
+
+Seb Rose [http://claysnow.co.uk/recycling-tests-in-tdd/](http://claysnow.co.uk/recycling-tests-in-tdd/)
+
+## 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/diamond/examples/success-standard/package.yaml

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

data/tracks/haskell/exercises/diamond/examples/success-standard/src/Diamond.hs

@@ -0,0 +1,16 @@
+module Diamond (diamond) where
+
+import Data.Char (ord, chr)
+
+pad :: Int -> String
+pad x = replicate x ' '
+
+oneRow :: Char -> (Int, Int) -> String
+oneRow c (0, y) = pad y ++ [c] ++ pad y
+oneRow c (x, y) = pad y ++ [c] ++ pad x ++ [c] ++ pad y
+
+diamond :: Char -> [String]
+diamond = (\x -> x ++ tail (reverse x)) . mkTop . subtract 64 . ord
+  where rows x = zip (0 : take (x-1) [1, 3..]) [x-1, x-2..0]
+        mkTop  = zipWith oneRow abc . rows
+        abc    = map chr [65..90]

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

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

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

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

data/tracks/haskell/exercises/diamond/stack.yaml

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

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

@@ -0,0 +1,109 @@
+{-# LANGUAGE RecordWildCards #-}
+
+import Data.Foldable     (for_)
+import Test.Hspec        (Spec, describe, it, shouldBe)
+import Test.Hspec.Runner (configFastFail, defaultConfig, hspecWith)
+import Diamond (diamond)
+
+main :: IO ()
+main = hspecWith defaultConfig {configFastFail = True} specs
+
+specs :: Spec
+specs = describe "diamond" $ for_ cases test
+  where
+
+    test Case{..} = it description assertion
+      where
+        assertion = diamond input `shouldBe` expected
+
+
+data Case = Case { description :: String
+                 , input       :: Char
+                 , expected    :: [String]
+                 }
+
+cases :: [Case]
+cases = [ Case { description = "Degenerate case with a single 'A' row"
+               , input       = 'A'
+               , expected    = ["A"]
+               }
+        , Case { description = "Degenerate case with no row containing 3 distinct groups of spaces"
+               , input       = 'B'
+               , expected    = [" A ",
+                                "B B",
+                                " A "]
+               }
+        , Case { description = "Smallest non-degenerate case with odd diamond side length"
+               , input       = 'C'
+               , expected    = ["  A  ",
+                                " B B ",
+                                "C   C",
+                                " B B ",
+                                "  A  "]
+               }
+        , Case { description = "Smallest non-degenerate case with even diamond side length"
+               , input       = 'D'
+               , expected    = ["   A   ",
+                                "  B B  ",
+                                " C   C ",
+                                "D     D",
+                                " C   C ",
+                                "  B B  ",
+                                "   A   "]
+               }
+        , Case { description = "Largest possible diamond"
+               , input       = 'Z'
+               , expected    = [
+                        "                         A                         ",
+                        "                        B B                        ",
+                        "                       C   C                       ",
+                        "                      D     D                      ",
+                        "                     E       E                     ",
+                        "                    F         F                    ",
+                        "                   G           G                   ",
+                        "                  H             H                  ",
+                        "                 I               I                 ",
+                        "                J                 J                ",
+                        "               K                   K               ",
+                        "              L                     L              ",
+                        "             M                       M             ",
+                        "            N                         N            ",
+                        "           O                           O           ",
+                        "          P                             P          ",
+                        "         Q                               Q         ",
+                        "        R                                 R        ",
+                        "       S                                   S       ",
+                        "      T                                     T      ",
+                        "     U                                       U     ",
+                        "    V                                         V    ",
+                        "   W                                           W   ",
+                        "  X                                             X  ",
+                        " Y                                               Y ",
+                        "Z                                                 Z",
+                        " Y                                               Y ",
+                        "  X                                             X  ",
+                        "   W                                           W   ",
+                        "    V                                         V    ",
+                        "     U                                       U     ",
+                        "      T                                     T      ",
+                        "       S                                   S       ",
+                        "        R                                 R        ",
+                        "         Q                               Q         ",
+                        "          P                             P          ",
+                        "           O                           O           ",
+                        "            N                         N            ",
+                        "             M                       M             ",
+                        "              L                     L              ",
+                        "               K                   K               ",
+                        "                J                 J                ",
+                        "                 I               I                 ",
+                        "                  H             H                  ",
+                        "                   G           G                   ",
+                        "                    F         F                    ",
+                        "                     E       E                     ",
+                        "                      D     D                      ",
+                        "                       C   C                       ",
+                        "                        B B                        ",
+                        "                         A                         "]
+               }
+        ]

data/tracks/haskell/exercises/etl/README.md

@@ -1,8 +1,9 @@
-# Etl
+# ETL
 
 We are going to do the `Transform` step of an Extract-Transform-Load.
 
 ### ETL
+
 Extract-Transform-Load (ETL) is a fancy way of saying, "We have some crufty, legacy data over in this system, and now we need it in this shiny new system over here, so
 we're going to migrate this."
 
@@ -11,6 +12,7 @@ once." That's then typically followed by much forehead slapping and
 moaning about how stupid we could possibly be.)
 
 ### The goal
+
 We're going to extract some scrabble scores from a legacy system.
 
 The old system stored a list of letters per score:

data/tracks/haskell/exercises/food-chain/README.md

@@ -10,7 +10,7 @@ This is a [cumulative song](http://en.wikipedia.org/wiki/Cumulative_song) of unk
 
 This is one of many common variants.
 
-```plain
+```text
 I know an old lady who swallowed a fly.
 I don't know why she swallowed the fly. Perhaps she'll die.
 

data/tracks/haskell/exercises/go-counting/README.md

@@ -16,7 +16,7 @@ only horizontal and vertical neighbours count. In the following diagram
 the stones which matter are marked "O" and the stones that don't are
 marked "I" (ignored).  Empty spaces represent empty intersections.
 
-```
+```text
 +----+
 |IOOI|
 |O  O|

data/tracks/haskell/exercises/grade-school/README.md

@@ -21,7 +21,6 @@ In the end, you should be able to:
 Note that all our students only have one name.  (It's a small town, what
 do you want?)
 
-
 ## For bonus points
 
 Did you get the tests passing and the code clean? If you want to, these

data/tracks/haskell/exercises/grains/README.md

@@ -15,7 +15,6 @@ Write code that shows:
 - how many grains were on each square, and
 - the total number of grains
 
-
 ## For bonus points
 
 Did you get the tests passing and the code clean? If you want to, these

data/tracks/haskell/exercises/house/README.md

@@ -11,10 +11,9 @@ Output the nursery rhyme 'This is the House that Jack Built'.
 
 - [papyr.com](http://papyr.com/hypertextbooks/grammar/ph_noun.htm)
 
-
 The nursery rhyme reads as follows:
 
-```plain
+```text
 This is the house that Jack built.
 
 This is the malt

data/tracks/haskell/exercises/isogram/README.md

@@ -2,13 +2,14 @@
 
 Determine if a word or phrase is an isogram.
 
-An isogram (also known as a "nonpattern word") is a word or phrase without a repeating letter.
+An isogram (also known as a "nonpattern word") is a word or phrase without a repeating letter, however spaces and hyphens are allowed to appear multiple times.
 
 Examples of isograms:
 
 - lumberjacks
 - background
 - downstream
+- six-year-old
 
 The word *isograms*, however, is not an isogram, because the s repeats.
 

data/tracks/haskell/exercises/kindergarten-garden/README.md

@@ -13,7 +13,7 @@ To this end, they've put little styrofoam cups along the window sills,
 and planted one type of plant in each cup, choosing randomly from the
 available types of seeds.
 
-```plain
+```text
 [window][window][window]
 ........................ # each dot represents a styrofoam cup
 ........................
@@ -30,7 +30,7 @@ cups in alphabetical order.
 
 The following diagram represents Alice's plants:
 
-```plain
+```text
 [window][window][window]
 VR......................
 RG......................
@@ -45,7 +45,7 @@ which plants belong to which students.
 
 For example, if it's told that the garden looks like so:
 
-```plain
+```text
 [window][window][window]
 VRCGVVRVCGGCCGVRGCVCGCGV
 VRCCCGCRRGVCGCRVVCVGCGCV

data/tracks/haskell/exercises/leap/README.md

@@ -4,7 +4,7 @@ Given a year, report if it is a leap year.
 
 The tricky thing here is that a leap year in the Gregorian calendar occurs:
 
-```plain
+```text
 on every year that is evenly divisible by 4
   except every year that is evenly divisible by 100
     unless the year is also evenly divisible by 400

data/tracks/haskell/exercises/linked-list/README.md

@@ -2,18 +2,18 @@
 
 Implement a doubly linked list.
 
-Like an array, a linked list is a simple linear data structure. Several 
-common data types can be implemented using linked lists, like queues, 
+Like an array, a linked list is a simple linear data structure. Several
+common data types can be implemented using linked lists, like queues,
 stacks, and associative arrays.
 
-A linked list is a collection of data elements called *nodes*. In a 
-*singly linked list* each node holds a value and a link to the next node. 
-In a *doubly linked list* each node also holds a link to the previous 
+A linked list is a collection of data elements called *nodes*. In a
+*singly linked list* each node holds a value and a link to the next node.
+In a *doubly linked list* each node also holds a link to the previous
 node.
 
-You will write an implementation of a doubly linked list. Implement a 
-Node to hold a value and pointers to the next and previous nodes. Then 
-implement a List which holds references to the first and last node and 
+You will write an implementation of a doubly linked list. Implement a
+Node to hold a value and pointers to the next and previous nodes. Then
+implement a List which holds references to the first and last node and
 offers an array-like interface for adding and removing items:
 
 * `push` (*insert value at back*);
@@ -21,8 +21,8 @@ offers an array-like interface for adding and removing items:
 * `shift` (*remove value at front*).
 * `unshift` (*insert value at front*);
 
-To keep your implementation simple, the tests will not cover error 
-conditions. Specifically: `pop` or `shift` will never be called on an 
+To keep your implementation simple, the tests will not cover error
+conditions. Specifically: `pop` or `shift` will never be called on an
 empty list.
 
 If you want to know more about linked lists, check [Wikipedia](https://en.wikipedia.org/wiki/Linked_list).

data/tracks/haskell/exercises/luhn/README.md

@@ -18,27 +18,27 @@ are disallowed.
 
 ## Example 1: valid credit card number
 
-```
+```text
 4539 1488 0343 6467
 ```
 
 The first step of the Luhn algorithm is to double every second digit,
 starting from the right. We will be doubling
 
-```
+```text
 4_3_ 1_8_ 0_4_ 6_6_
 ```
 
 If doubling the number results in a number greater than 9 then subtract 9
 from the product. The results of our doubling:
 
-```
+```text
 8569 2478 0383 3437
 ```
 
 Then sum all of the digits:
 
-```
+```text
 8+5+6+9+2+4+7+8+0+3+8+3+3+4+3+7 = 80
 ```
 
@@ -46,19 +46,19 @@ If the sum is evenly divisible by 10, then the number is valid. This number is v
 
 ## Example 2: invalid credit card number
 
-```
+```text
 8273 1232 7352 0569
 ```
 
 Double the second digits, starting from the right
 
-```
+```text
 7253 2262 5312 0539
 ```
 
 Sum the digits
 
-```
+```text
 7+2+5+3+2+2+6+2+5+3+1+2+0+5+3+9 = 57
 ```
 

data/tracks/haskell/exercises/matrix/README.md

@@ -5,13 +5,15 @@ that matrix.
 
 So given a string with embedded newlines like:
 
-> 9 8 7  
-> 5 3 2  
-> 6 6 7  
+```text
+9 8 7
+5 3 2
+6 6 7
+```
 
 representing this matrix:
 
-```plain
+```text
     0  1  2
   |---------
 0 | 9  8  7

data/tracks/haskell/exercises/meetup/README.md

@@ -18,10 +18,9 @@ end in '-teenth'. Therefore, one is guaranteed that each day of the week
 (Monday, Tuesday, ...) will have exactly one date that is named with '-teenth'
 in every month.
 
-Given examples of a meetup dates, each containing a month, day, year, and descriptor 
+Given examples of a meetup dates, each containing a month, day, year, and descriptor
 (first, second, teenth, etc), calculate the date of the actual meetup.
 For example, if given "First Monday of January 2017", the correct meetup date is 2017/1/2
- 
 
 ## Hints
 

data/tracks/haskell/exercises/nucleotide-count/README.md

@@ -1,30 +1,16 @@
 # Nucleotide Count
 
-Given a DNA string, compute how many times each nucleotide occurs in the string.
+Given a single stranded DNA string, compute how many times each nucleotide occurs in the string.
 
-DNA is represented by an alphabet of the following symbols: 'A', 'C',
-'G', and 'T'.
-
-Each symbol represents a nucleotide, which is a fancy name for the
-particular molecules that happen to make up a large part of DNA.
-
-Shortest intro to biochemistry EVAR:
+The genetic language of every living thing on the planet is DNA. 
+DNA is a large molecule that is built from an extremely long sequence of individual elements called nucleotides. 
+4 types exist in DNA and these differ only slightly and can be represented as the following symbols: 'A' for adenine, 'C' for cytosine, 'G' for guanine, and 'T' thymine.
 
+Here is an analogy:
 - twigs are to birds nests as
-- nucleotides are to DNA and RNA as
-- amino acids are to proteins as
-- sugar is to starch as
-- oh crap lipids
-
-I'm not going to talk about lipids because they're crazy complex.
-
-So back to nucleotides.
-
-DNA contains four types of them: adenine (`A`), cytosine (`C`), guanine
-(`G`), and thymine (`T`).
-
-RNA contains a slightly different set of nucleotides, but we don't care
-about that for now.
+- nucleotides are to DNA as
+- legos are to lego houses as
+- words are to sentences as...
 
 
 ## Getting Started

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

@@ -1,4 +1,4 @@
-# Ocr Numbers
+# OCR Numbers
 
 Given a 3 x 4 grid of pipes, underscores, and spaces, determine which number is
 represented, or whether it is garbled.
@@ -9,7 +9,7 @@ To begin with, convert a simple binary font to a string containing 0 or 1.
 
 The binary font uses pipes and underscores, four rows high and three columns wide.
 
-```
+```text
      _   #
     | |  # zero.
     |_|  #
@@ -18,7 +18,7 @@ The binary font uses pipes and underscores, four rows high and three columns wid
 
 Is converted to "0"
 
-```
+```text
          #
       |  # one.
       |  #
@@ -39,7 +39,7 @@ Update your program to recognize multi-character binary strings, replacing garbl
 
 Update your program to recognize all numbers 0 through 9, both individually and as part of a larger string.
 
-```
+```text
  _ 
  _|
 |_ 
@@ -48,7 +48,7 @@ Update your program to recognize all numbers 0 through 9, both individually and
 
 Is converted to "2"
 
-```
+```text
       _  _     _  _  _  _  _  _  #
     | _| _||_||_ |_   ||_||_|| | # decimal numbers.
     ||_  _|  | _||_|  ||_| _||_| #
@@ -61,7 +61,7 @@ Is converted to "1234567890"
 
 Update your program to handle multiple numbers, one per line. When converting several lines, join the lines with commas.
 
-```
+```text
     _  _ 
   | _| _|
   ||_  _|

data/tracks/haskell/exercises/octal/README.md

@@ -8,11 +8,13 @@ Implement octal to decimal conversion.  Given an octal input
 string, your program should produce a decimal output.
 
 ## Note
+
 - Implement the conversion yourself.
   Do not use something else to perform the conversion for you.
 - Treat invalid input as octal 0.
 
 ## About Octal (Base-8)
+
 Decimal is a base-10 system.
 
 A number 233 in base 10 notation can be understood
@@ -25,7 +27,8 @@ as a linear combination of powers of 10:
 - All these values are summed.
 
 So:
-```
+
+```text
    233 # decimal
  = 2*10^2 + 3*10^1 + 3*10^0
  = 2*100  + 3*10   + 3*1
@@ -34,7 +37,8 @@ So:
 Octal is similar, but uses powers of 8 rather than powers of 10.
 
 So:
-```
+
+```text
    233 # octal
  = 2*8^2 + 3*8^1 + 3*8^0
  = 2*64  + 3*8   + 3*1