trackler 2.0.8.54 → 2.0.8.55

data/tracks/pony/exercises/roman-numerals/example.pony

@@ -9,18 +9,18 @@ primitive RomanNumerals
     end
 
     let numerals: Array[(USize, String)] = [
-      (1000, "M"),
-      (900, "CM"),
-      (500, "D"),
-      (400, "CD"),
-      (100, "C"),
-      (90, "XC"),
-      (50, "L"),
-      (40, "XL"),
-      (10, "X"),
-      (9, "IX"),
-      (5, "V"),
-      (4, "IV"),
+      (1000, "M")
+      (900, "CM")
+      (500, "D")
+      (400, "CD")
+      (100, "C")
+      (90, "XC")
+      (50, "L")
+      (40, "XL")
+      (10, "X")
+      (9, "IX")
+      (5, "V")
+      (4, "IV")
       (1, "I")
     ]
 

data/tracks/pony/exercises/roman-numerals/test.pony

@@ -12,24 +12,24 @@ class iso _TestRomanNumerals is UnitTest
 
   fun apply(h: TestHelper) =>
     let tests: Array[(USize, String)] = [
-      (0, ""),
-      (1, "I"),
-      (2, "II"),
-      (3, "III"),
-      (4, "IV"),
-      (5, "V"),
-      (6, "VI"),
-      (9, "IX"),
-      (27, "XXVII"),
-      (48, "XLVIII"),
-      (59, "LIX"),
-      (93, "XCIII"),
-      (141, "CXLI"),
-      (163, "CLXIII"),
-      (402, "CDII"),
-      (575, "DLXXV"),
-      (911, "CMXI"),
-      (1024, "MXXIV"),
+      (0, "")
+      (1, "I")
+      (2, "II")
+      (3, "III")
+      (4, "IV")
+      (5, "V")
+      (6, "VI")
+      (9, "IX")
+      (27, "XXVII")
+      (48, "XLVIII")
+      (59, "LIX")
+      (93, "XCIII")
+      (141, "CXLI")
+      (163, "CLXIII")
+      (402, "CDII")
+      (575, "DLXXV")
+      (911, "CMXI")
+      (1024, "MXXIV")
       (3000, "MMM")
     ]
 

data/tracks/purescript/config.json

@@ -144,6 +144,21 @@
         "strings",
         "matrices"
       ]
+    },
+    {
+      "slug": "isogram",
+      "difficulty": 1,
+      "topics": [
+        "strings",
+        "maps"
+      ]
+    },
+    {
+      "slug": "etl",
+      "difficulty": 1,
+      "topics": [
+        "maps"
+      ]
     }
   ],
   "deprecated": [

data/tracks/purescript/exercises/etl/bower.json

@@ -0,0 +1,17 @@
+{
+  "name": "etl",
+  "ignore": [
+    "**/.*",
+    "node_modules",
+    "bower_components",
+    "output"
+  ],
+  "dependencies": {
+    "purescript-prelude": "^3.0.0",
+    "purescript-maps": "^3.0.0"
+  },
+  "devDependencies": {
+    "purescript-psci-support": "^3.0.0",
+    "purescript-test-unit": "^11.0.0"
+  }
+}

data/tracks/purescript/exercises/etl/examples/src/Etl.purs

@@ -0,0 +1,20 @@
+module Etl
+  ( transform
+  ) where
+
+import Prelude
+import Data.Array (foldl)
+import Data.Char (toLower)
+import Data.Map (Map, insert, empty, toUnfoldable)
+import Data.Tuple (Tuple(..))
+
+transform :: Map Int (Array Char) -> Map Char Int
+transform = toUnfoldable
+            >>> expand
+            >>> foldl add empty
+  where expand xs = do
+          Tuple k ys <- xs
+          y <- ys
+          pure $ Tuple k y
+        add m (Tuple k v) = insert (toLower v) k m
+

data/tracks/purescript/exercises/etl/src/Etl.purs

@@ -0,0 +1,3 @@
+module Etl
+  ( transform
+  ) where

data/tracks/purescript/exercises/etl/test/Main.purs

@@ -0,0 +1,99 @@
+module Test.Main where
+
+import Prelude
+import Control.Monad.Eff (Eff)
+import Data.Map (fromFoldable)
+import Data.Maybe (Maybe(..))
+import Data.Tuple (Tuple(..))
+import Test.Unit.Assert as Assert
+import Test.Unit (suite, test)
+import Test.Unit.Main (runTest)
+import Etl (transform)
+
+main :: Eff _ Unit
+main = runTest do
+  suite "Etl.transform" do
+    
+    test "a single letter" $
+      Assert.equal (fromFoldable
+                     [Tuple 'a' 1]
+                   )
+                   (transform
+                     (fromFoldable
+                       [Tuple 1 ['A']]
+                     )
+                   )
+     
+    test "single score with multiple letters" $
+      Assert.equal (fromFoldable
+                     [ Tuple 'a' 1
+                     , Tuple 'e' 1
+                     , Tuple 'i' 1
+                     , Tuple 'o' 1
+                     , Tuple 'u' 1
+                     ]
+                   )
+                   (transform
+                     (fromFoldable
+                       [Tuple 1 ['A','E','I','O','U']]
+                     )
+                   )
+    
+    test "multiple scores with multiple letters" $
+      Assert.equal (fromFoldable
+                     [ Tuple 'a' 1
+                     , Tuple 'd' 2
+                     , Tuple 'e' 1
+                     , Tuple 'g' 2
+                     ]
+                   )
+                   (transform
+                     (fromFoldable
+                       [ Tuple 1 ['A','E']
+                       , Tuple 2 ['D','G']
+                       ]
+                     )
+                   )
+    
+    test "multiple scores with differing numbers of letters" $
+      Assert.equal (fromFoldable
+                     [ Tuple 'a' 1
+                     , Tuple 'b' 3
+                     , Tuple 'c' 3
+                     , Tuple 'd' 2
+                     , Tuple 'e' 1
+                     , Tuple 'f' 4
+                     , Tuple 'g' 2
+                     , Tuple 'h' 4
+                     , Tuple 'i' 1
+                     , Tuple 'j' 8
+                     , Tuple 'k' 5
+                     , Tuple 'l' 1
+                     , Tuple 'm' 3
+                     , Tuple 'n' 1
+                     , Tuple 'o' 1
+                     , Tuple 'p' 3
+                     , Tuple 'q' 10
+                     , Tuple 'r' 1
+                     , Tuple 's' 1
+                     , Tuple 't' 1
+                     , Tuple 'u' 1
+                     , Tuple 'v' 4
+                     , Tuple 'w' 4
+                     , Tuple 'x' 8
+                     , Tuple 'y' 4
+                     , Tuple 'z' 10
+                     ]
+                   )
+                   (transform
+                     (fromFoldable
+                       [ Tuple 1 ['A','E','I','O','U','L','N','R','S','T']
+                       , Tuple 10 ['Q','Z']
+                       , Tuple 2 ['D','G']
+                       , Tuple 3 ['B','C','M','P']
+                       , Tuple 4 ['F','H','V','W','Y']
+                       , Tuple 5 ['K']
+                       , Tuple 8 ['J','X']
+                       ]
+                     )
+                   )

data/tracks/purescript/exercises/isogram/bower.json

@@ -0,0 +1,18 @@
+{
+  "name": "isogram",
+  "ignore": [
+    "**/.*",
+    "node_modules",
+    "bower_components",
+    "output"
+  ],
+  "dependencies": {
+    "purescript-prelude": "^3.0.0",
+    "purescript-maps": "^3.0.0",
+    "purescript-strings": "^3.0.0"
+  },
+  "devDependencies": {
+    "purescript-psci-support": "^3.0.0",
+    "purescript-test-unit": "^11.0.0"
+  }
+}

data/tracks/purescript/exercises/isogram/examples/src/Isogram.purs

@@ -0,0 +1,22 @@
+module Isogram
+  ( isIsogram
+  ) where
+
+import Prelude
+import Data.Array (filter, foldl)
+import Data.Map (alter, empty, values)
+import Data.Maybe (Maybe(..))
+import Data.String (toCharArray, toLower)
+import Data.Traversable (all)
+
+isIsogram :: String -> Boolean
+isIsogram = toLower
+            >>> toCharArray
+            >>> filter letter
+            >>> foldl toMap empty
+            >>> values
+            >>> all (_ <= 1)
+  where letter c = 'a' <= c && c <= 'z'
+        toMap m c = alter addChar c m
+        addChar Nothing  = Just 1
+        addChar (Just c) = Just $ c + 1

data/tracks/purescript/exercises/isogram/src/Isogram.purs

@@ -0,0 +1,4 @@
+module Isogram
+  ( isIsogram
+  ) where
+

data/tracks/purescript/exercises/isogram/test/Main.purs

@@ -0,0 +1,44 @@
+module Test.Main where
+
+import Prelude
+import Control.Monad.Eff (Eff)
+import Test.Unit.Assert as Assert
+import Test.Unit (suite, test)
+import Test.Unit.Main (runTest)
+import Isogram (isIsogram)
+
+main :: Eff _ Unit
+main = runTest do
+  suite "Isogram.transform" do
+
+    test "empty string" $
+      Assert.equal true
+                   (isIsogram "")
+
+    test "isogram with only lower case characters" $
+      Assert.equal true
+                   (isIsogram "isogram")
+
+    test "word with one duplicated character" $
+      Assert.equal false
+                   (isIsogram "eleven")
+
+    test "longest reported english isogram" $
+      Assert.equal true
+                   (isIsogram "subdermatoglyphic")
+
+    test "word with duplicated character in mixed case" $
+      Assert.equal false
+                   (isIsogram "Alphabet")
+
+    test "hypothetical isogrammic word with hyphen" $
+      Assert.equal true
+                   (isIsogram "thumbscrew-japingly")
+
+    test "isogram with duplicated non letter character" $
+      Assert.equal true
+                   (isIsogram "Hjelmqvist-Gryb-Zock-Pfund-Wax")
+
+    test "made-up name that is an isogram" $
+      Assert.equal true
+                   (isIsogram "Emily Jung Schwartzkopf")

data/tracks/ruby/README.md

@@ -137,12 +137,13 @@ The `lib/$PROBLEM_cases.rb` file should contain a small class that wraps the JSO
 require 'exercise_cases'
 
 class ProblemNameCase < OpenStruct
-  def test_name
+  def name
     'test_%s' % description.gsub(/[ -]/, '_')
   end
 
   def workload
-    # implement main logic of test here
+    # Example workload:
+    "assert #{expected.inspect}, Problem.call(#{input.inspect})"
   end
 
   def skipped
@@ -156,8 +157,8 @@ the generator script will infer the name of the class from the argument that is
 
 This class must implement the following methods:
 
-- `test_name` - Returns the name of the test (i.e `test_one_equals_one`)
-- `workload` - Returns the main syntax for the test.  This will vary depending on the test generator and its underlying implementation
+- `name` - Returns the name of the test (i.e `test_one_equals_one`)
+- `workload` - Returns the main syntax for the test. This includes the assertion and any setup required for the test.  This will vary depending on the test generator and its underlying implementation
 - `skipped` - Returns skip syntax (i.e. `skip` or `# skip`)
 
 Beyond that, you can implement any helper methods that you need.
@@ -183,14 +184,12 @@ loop through each of the cases in an inner loop:
 
 ```
 ProblemNameCases = proc do |data|
-  i = 0
   json = JSON.parse(data)
   cases = []
   %w(section1 section2 etc).each do |section|
     json[section]['cases'].each do |row|
-      row = row.merge(row.merge('index' => i, 'section' => section))
+      row = row.merge(row.merge('index' => cases.size, 'section' => section))
       cases << ProblemNameCase.new(row)
-      i += 1
     end
   end
   cases
@@ -208,11 +207,13 @@ require 'minitest/autorun'
 require_relative '$PROBLEM'
 
 # Common test data version: <%= abbreviated_commit_hash %>
-class ProblemNameTest < Minitest::Test<% test_cases.each do |test_case| %>
+class ProblemNameTest < Minitest::Test
+<% test_cases.each do |test_case| %>
   def <%= test_case.name %>
     <%= test_case.skipped %>
-    assert_equal <%= test_case.expected %>, <%= test_case.work_load %>
+    <%= test_case.workload %>
   end
+
 <% end %>
 <%= IO.read(XRUBY_LIB + '/bookkeeping.md') %>
   def test_bookkeeping

data/tracks/ruby/exercises/anagram/example.tt

@@ -7,7 +7,7 @@ require_relative 'anagram'
 class AnagramTest < Minitest::Test<% test_cases.each do |test_case| %>
   def <%= test_case.test_name %>
     <%= test_case.skipped %>
-    <%= test_case.work_load %>
+    <%= test_case.workload %>
   end
 <% end %>
 <%= IO.read(XRUBY_LIB + '/bookkeeping.md') %>

data/tracks/ruby/exercises/bowling/example.tt

@@ -16,7 +16,7 @@ class BowlingTest < Minitest::Test
 <% test_cases.each do |test_case| %>
   def <%= test_case.test_name %>
     <%= test_case.skipped %>
-    <%= test_case.work_load %>
+    <%= test_case.workload %>
   end
 
 <% end %>

data/tracks/ruby/exercises/hamming/example.tt

@@ -7,8 +7,8 @@ require_relative 'hamming'
 class HammingTest < Minitest::Test<% test_cases.each do |test_case| %>
   def <%= test_case.name %>
     <%= test_case.skipped %><% if test_case.raises_error? %>
-    assert_raises(ArgumentError) { <%= test_case.work_load %> }<% else %>
-    assert_equal <%= test_case.expected %>, <%= test_case.work_load %><% end %>
+    assert_raises(ArgumentError) { <%= test_case.workload %> }<% else %>
+    assert_equal <%= test_case.expected %>, <%= test_case.workload %><% end %>
   end
 <% end %>
 <%= IO.read(XRUBY_LIB + '/bookkeeping.md') %>

data/tracks/ruby/exercises/luhn/.meta/.version

@@ -0,0 +1 @@
+1

data/tracks/ruby/exercises/luhn/example.rb

@@ -1,35 +1,30 @@
 class Luhn
-  def self.create(number)
-    test_number = number * 10
-    luhn = Luhn.new(test_number)
-    return test_number if luhn.valid?
-    test_number + 10 - (luhn.checksum % 10)
-  end
+  DOUBLE = [0, 2, 4, 6, 8, 1, 3, 5, 7, 9]
+  DOUBLE.freeze
 
-  attr_reader :number
-  def initialize(number)
-    @number = number
+  def self.valid?(string)
+    Luhn.new(string).valid?
   end
 
-  def addends
-    numbers = []
-    number.to_s.reverse.split('').map(&:to_i).each_with_index do |n, i|
-      if i % 2 == 0
-        numbers << n
-      else
-        value = n * 2
-        value -= 9 if value > 9
-        numbers << value
-      end
-    end
-    numbers.reverse
+  def initialize(string)
+    @string = string.tr(' ', '')
   end
 
   def checksum
-    addends.inject(0, :+)
+    @string.
+      reverse.each_char.with_index.
+      reduce(0) {|sum, (c, i)| sum + (i.odd? ? DOUBLE[c.to_i] : c.to_i) }
   end
 
   def valid?
-    checksum % 10 == 0
+    clean? && (checksum % 10).zero?
+  end
+
+  def clean?
+    @string.match(/^\d{2,}$/)
   end
 end
+
+module BookKeeping
+  VERSION = 1
+end

data/tracks/ruby/exercises/luhn/example.tt

@@ -0,0 +1,18 @@
+#!/usr/bin/env ruby
+gem 'minitest', '>= 5.0.0'
+require 'minitest/autorun'
+require_relative 'luhn'
+
+# Common test data version: <%= abbreviated_commit_hash %>
+class LuhnTest < Minitest::Test<% test_cases.each do |test_case| %>
+  def <%= test_case.name %>
+    <%= test_case.skipped %>
+    <%= test_case.workload %>
+  end
+<% end %>
+<%= IO.read(XRUBY_LIB + '/bookkeeping.md') %>
+  def test_bookkeeping
+    skip
+    assert_equal <%= version %>, BookKeeping::VERSION
+  end
+end

data/tracks/ruby/exercises/luhn/luhn_test.rb

@@ -3,57 +3,90 @@ gem 'minitest', '>= 5.0.0'
 require 'minitest/autorun'
 require_relative 'luhn'
 
+# Common test data version: c826372
 class LuhnTest < Minitest::Test
-  def test_addends
-    luhn = Luhn.new(12_121)
-    assert_equal [1, 4, 1, 4, 1], luhn.addends
+  def test_single_digit_strings_can_not_be_valid
+    # skip
+    refute Luhn.valid?("1")
   end
 
-  def test_too_large_addend
+  def test_A_single_zero_is_invalid
     skip
-    luhn = Luhn.new(8631)
-    assert_equal [7, 6, 6, 1], luhn.addends
+    refute Luhn.valid?("0")
   end
 
-  def test_checksum
+  def test_a_simple_valid_SIN_that_remains_valid_if_reversed
     skip
-    luhn = Luhn.new(4913)
-    assert_equal 22, luhn.checksum
+    assert Luhn.valid?("059")
   end
 
-  def test_checksum_again
+  def test_a_simple_valid_SIN_that_becomes_invalid_if_reversed
     skip
-    luhn = Luhn.new(201_773)
-    assert_equal 21, luhn.checksum
+    assert Luhn.valid?("59")
   end
 
-  def test_invalid_number
+  def test_a_valid_Canadian_SIN
     skip
-    luhn = Luhn.new(738)
-    refute luhn.valid?
+    assert Luhn.valid?("055 444 285")
   end
 
-  def test_valid_number
+  def test_invalid_Canadian_SIN
     skip
-    luhn = Luhn.new(8_739_567)
-    assert luhn.valid?
+    refute Luhn.valid?("055 444 286")
   end
 
-  def test_create_valid_number
+  def test_invalid_credit_card
     skip
-    number = Luhn.create(123)
-    assert_equal 1230, number
+    refute Luhn.valid?("8273 1232 7352 0569")
   end
 
-  def test_create_other_valid_number
+  def test_valid_strings_with_a_non_digit_included_become_invalid
     skip
-    number = Luhn.create(873_956)
-    assert_equal 8_739_567, number
+    refute Luhn.valid?("055a 444 285")
   end
 
-  def test_create_yet_another_valid_number
+  def test_valid_strings_with_punctuation_included_become_invalid
     skip
-    number = Luhn.create(837_263_756)
-    assert_equal 8_372_637_564, number
+    refute Luhn.valid?("055-444-285")
+  end
+
+  def test_valid_strings_with_symbols_included_become_invalid
+    skip
+    refute Luhn.valid?("055£ 444$ 285")
+  end
+
+  def test_single_zero_with_space_is_invalid
+    skip
+    refute Luhn.valid?(" 0")
+  end
+
+  def test_more_than_a_single_zero_is_valid
+    skip
+    assert Luhn.valid?("0000 0")
+  end
+
+  def test_input_digit_9_is_correctly_converted_to_output_digit_9
+    skip
+    assert Luhn.valid?("091")
+  end
+  # Problems in exercism evolve over time, as we find better ways to ask
+  # questions.
+  # The version number refers to the version of the problem you solved,
+  # not your solution.
+  #
+  # Define a constant named VERSION inside of the top level BookKeeping
+  # module, which may be placed near the end of your file.
+  #
+  # In your file, it will look like this:
+  #
+  # module BookKeeping
+  #   VERSION = 1 # Where the version number matches the one in the test.
+  # end
+  #
+  # If you are curious, read more about constants on RubyDoc:
+  # http://ruby-doc.org/docs/ruby-doc-bundle/UsersGuide/rg/constants.html
+  def test_bookkeeping
+    skip
+    assert_equal 1, BookKeeping::VERSION
   end
 end

data/tracks/ruby/exercises/pig-latin/.meta/.version

@@ -0,0 +1 @@
+1

data/tracks/ruby/exercises/pig-latin/example.rb

@@ -27,3 +27,7 @@ class PigLatin
     word.scan(/\A([^aeiou]?qu|[^aeiou]+)(.*)/).first
   end
 end
+
+module BookKeeping
+  VERSION = 1
+end

data/tracks/ruby/exercises/pig-latin/example.tt

@@ -0,0 +1,21 @@
+#!/usr/bin/env ruby
+gem 'minitest', '>= 5.0.0'
+require 'minitest/autorun'
+require_relative 'pig_latin'
+
+# Common test data version: <%= abbreviated_commit_hash %>
+class PigLatinTest < Minitest::Test
+<% test_cases.each do |test_case| %>
+  def <%= test_case.name %>
+    <%= test_case.skipped %>
+    <%= test_case.workload %>
+  end
+
+<% end %>
+<%= IO.read(XRUBY_LIB + '/bookkeeping.md') %>
+
+  def test_bookkeeping
+    skip
+    assert_equal <%= version %>, BookKeeping::VERSION
+  end
+end