trackler 2.2.1.72 → 2.2.1.73

data/tracks/perl6/exercises/clock/clock.t

@@ -24,29 +24,29 @@ subtest 'Class methods', {
 }
 
 my $c-data = from-json $=pod.pop.contents;
-for @($c-data<cases>) {
-  for @(.<cases>) -> $case {
-    given $case<property> {
-      when 'create' {
-        is ::($exercise).new(hour => $case<hour>, minute => $case<minute>).?time, |$case<expected description>;
-      }
-      when 'add' {
-        my $clock = ::($exercise).new(hour => $case<hour>, minute => $case<minute>);
-        $clock.?add-minutes($case<add>);
-        is $clock.?time, |$case<expected description>;
-      }
-      when 'equal' {
-        is ::($exercise).new(hour => $case<clock1><hour>, minute => $case<clock1><minute>).?time eq
-           ::($exercise).new(hour => $case<clock2><hour>, minute => $case<clock2><minute>).?time,
-           |$case<expected description>;
+for $c-data<cases>»<cases>».Array.flat -> %case {
+  given %case<property> {
+    when 'create' {
+      is ::($exercise).?new( |%(.<hour minute>:p) ).?time, |.<expected description> given %case;
+    }
+    when 'add' {
+      given %case {
+        my $clock = ::($exercise).?new: |%(.<hour minute>:p);
+        $clock.?add-minutes: .<add>;
+        is $clock.?time, |.<expected description>;
       }
-      when %*ENV<EXERCISM>.so { bail-out "no case for property '$case<property>'" }
     }
+    when 'equal' {
+      is-deeply ([eq] gather {
+        take ::($exercise).?new( |%(.<hour minute>:p) ).?time for %case<clock1 clock2>;
+      }), |%case<expected description>;
+    }
+    when %*ENV<EXERCISM>.so { bail-out "no case for property '%case<property>'" }
   }
 }
 
 todo 'optional test' unless %*ENV<EXERCISM>;
-is ::($exercise).new(:0hour,:0minute).?add-minutes(65).?time, '01:05', 'add-minutes method can be chained';
+is ::($exercise).?new(:0hour,:0minute).?add-minutes(65).?time, '01:05', 'add-minutes method can be chained';
 
 =head2 Canonical Data
 =begin code

data/tracks/perl6/exercises/clock/example.yaml

@@ -3,29 +3,29 @@ version: 1
 methods: time add-minutes
 plan: 54
 tests: |-
-  for @($c-data<cases>) {
-    for @(.<cases>) -> $case {
-      given $case<property> {
-        when 'create' {
-          is ::($exercise).new(hour => $case<hour>, minute => $case<minute>).?time, |$case<expected description>;
-        }
-        when 'add' {
-          my $clock = ::($exercise).new(hour => $case<hour>, minute => $case<minute>);
-          $clock.?add-minutes($case<add>);
-          is $clock.?time, |$case<expected description>;
-        }
-        when 'equal' {
-          is ::($exercise).new(hour => $case<clock1><hour>, minute => $case<clock1><minute>).?time eq
-             ::($exercise).new(hour => $case<clock2><hour>, minute => $case<clock2><minute>).?time,
-             |$case<expected description>;
+  for $c-data<cases>»<cases>».Array.flat -> %case {
+    given %case<property> {
+      when 'create' {
+        is ::($exercise).?new( |%(.<hour minute>:p) ).?time, |.<expected description> given %case;
+      }
+      when 'add' {
+        given %case {
+          my $clock = ::($exercise).?new: |%(.<hour minute>:p);
+          $clock.?add-minutes: .<add>;
+          is $clock.?time, |.<expected description>;
         }
-        when %*ENV<EXERCISM>.so { bail-out "no case for property '$case<property>'" }
       }
+      when 'equal' {
+        is-deeply ([eq] gather {
+          take ::($exercise).?new( |%(.<hour minute>:p) ).?time for %case<clock1 clock2>;
+        }), |%case<expected description>;
+      }
+      when %*ENV<EXERCISM>.so { bail-out "no case for property '%case<property>'" }
     }
   }
 
   todo 'optional test' unless %*ENV<EXERCISM>;
-  is ::($exercise).new(:0hour,:0minute).?add-minutes(65).?time, '01:05', 'add-minutes method can be chained';
+  is ::($exercise).?new(:0hour,:0minute).?add-minutes(65).?time, '01:05', 'add-minutes method can be chained';
 
 unit: class
 example: |-

data/tracks/perl6/exercises/roman-numerals/Example.pm6

@@ -0,0 +1,17 @@
+unit module RomanNumerals:ver<1>;
+
+
+my %table{Int} = <1000 900 500 400 100 90 50 40 10 9 5 4 1>
+                 Z=>
+                 <M CM D CD C XC L XL X IX V IV I>;
+
+sub to-roman ($number is copy) is export {
+  [~] gather {
+    for %table.keys.sort.reverse -> $k {
+      if (my $repeat = $number div $k) {
+        $number -= $k * $repeat;
+        take %table{$k} x $repeat;
+      }
+    }
+  }
+}

data/tracks/perl6/exercises/roman-numerals/RomanNumerals.pm6

@@ -0,0 +1,4 @@
+unit module RomanNumerals:ver<1>;
+
+sub to-roman ($number) is export {
+}

data/tracks/perl6/exercises/roman-numerals/example.yaml

@@ -0,0 +1,30 @@
+exercise: RomanNumerals
+version: 1
+plan: 20
+imports: '&to-roman'
+tests: |-
+  for $c-data<cases>.values {
+    is to-roman(.<number>), |.<expected description>;
+  }
+
+unit: module
+example: |-
+
+  my %table{Int} = <1000 900 500 400 100 90 50 40 10 9 5 4 1>
+                   Z=>
+                   <M CM D CD C XC L XL X IX V IV I>;
+
+  sub to-roman ($number is copy) is export {
+    [~] gather {
+      for %table.keys.sort.reverse -> $k {
+        if (my $repeat = $number div $k) {
+          $number -= $k * $repeat;
+          take %table{$k} x $repeat;
+        }
+      }
+    }
+  }
+
+stub: |-
+  sub to-roman ($number) is export {
+  }

data/tracks/perl6/exercises/roman-numerals/roman-numerals.t

@@ -0,0 +1,162 @@
+#!/usr/bin/env perl6
+use v6;
+use Test;
+use lib my $dir = $?FILE.IO.dirname;
+use JSON::Fast;
+
+my Str:D $exercise := 'RomanNumerals';
+my Version:D $version = v1;
+my Str $module //= $exercise;
+plan 20;
+
+use-ok $module or bail-out;
+require ::($module);
+
+if ::($exercise).^ver !~~ $version {
+  warn "\nExercise version mismatch. Further tests may fail!"
+    ~ "\n$exercise is $(::($exercise).^ver.gist). "
+    ~ "Test is $($version.gist).\n";
+  bail-out 'Example version must match test version.' if %*ENV<EXERCISM>;
+}
+
+require ::($module) <&to-roman>;
+
+my $c-data = from-json $=pod.pop.contents;
+for $c-data<cases>.values {
+  is to-roman(.<number>), |.<expected description>;
+}
+
+=head2 Canonical Data
+=begin code
+
+{
+  "exercise": "roman-numerals",
+  "version": "1.0.0",
+  "cases": [
+    {
+      "description": "1 is a single I",
+      "property": "roman",
+      "number": 1,
+      "expected": "I"
+    },
+    {
+      "description": "2 is two I's",
+      "property": "roman",
+      "number": 2,
+      "expected": "II"
+    },
+    {
+      "description": "3 is three I's",
+      "property": "roman",
+      "number": 3,
+      "expected": "III"
+    },
+    {
+      "description": "4, being 5 - 1, is IV",
+      "property": "roman",
+      "number": 4,
+      "expected": "IV"
+    },
+    {
+      "description": "5 is a single V",
+      "property": "roman",
+      "number": 5,
+      "expected": "V"
+    },
+    {
+      "description": "6, being 5 + 1, is VI",
+      "property": "roman",
+      "number": 6,
+      "expected": "VI"
+    },
+    {
+      "description": "9, being 10 - 1, is IX",
+      "property": "roman",
+      "number": 9,
+      "expected": "IX"
+    },
+    {
+      "description": "20 is two X's",
+      "property": "roman",
+      "number": 27,
+      "expected": "XXVII"
+    },
+    {
+      "description": "48 is not 50 - 2 but rather 40 + 8",
+      "property": "roman",
+      "number": 48,
+      "expected": "XLVIII"
+    },
+    {
+      "description": "50 is a single L",
+      "property": "roman",
+      "number": 59,
+      "expected": "LIX"
+    },
+    {
+      "description": "90, being 100 - 10, is XC",
+      "property": "roman",
+      "number": 93,
+      "expected": "XCIII"
+    },
+    {
+      "description": "100 is a single C",
+      "property": "roman",
+      "number": 141,
+      "expected": "CXLI"
+    },
+    {
+      "description": "60, being 50 + 10, is LX",
+      "property": "roman",
+      "number": 163,
+      "expected": "CLXIII"
+    },
+    {
+      "description": "400, being 500 - 100, is CD",
+      "property": "roman",
+      "number": 402,
+      "expected": "CDII"
+    },
+    {
+      "description": "500 is a single D",
+      "property": "roman",
+      "number": 575,
+      "expected": "DLXXV"
+    },
+    {
+      "description": "900, being 1000 - 100, is CM",
+      "property": "roman",
+      "number": 911,
+      "expected": "CMXI"
+    },
+    {
+      "description": "1000 is a single M",
+      "property": "roman",
+      "number": 1024,
+      "expected": "MXXIV"
+    },
+    {
+      "description": "3000 is three M's",
+      "property": "roman",
+      "number": 3000,
+      "expected": "MMM"
+    }
+  ]
+}
+
+=end code
+
+unless %*ENV<EXERCISM> {
+  skip-rest 'exercism tests';
+  exit;
+}
+
+subtest 'canonical-data' => {
+  (my $c-data-file = "$dir/../../problem-specifications/exercises/{
+    $dir.IO.resolve.basename
+  }/canonical-data.json".IO.resolve) ~~ :f ??
+    is-deeply $c-data, EVAL('from-json $c-data-file.slurp'), 'match problem-specifications' !!
+    flunk 'problem-specifications file not found';
+}
+
+INIT { $module = 'Example' if %*ENV<EXERCISM> }

data/tracks/python/exercises/book-store/book_store_test.py

@@ -3,7 +3,7 @@ import unittest
 from book_store import calculate_total
 
 
-# Tests adapted from `problem-specifications//canonical-data.json` @ v1.0.1
+# Tests adapted from `problem-specifications//canonical-data.json` @ v1.1.0
 
 class BookStoreTests(unittest.TestCase):
     def test_only_a_single_book(self):
@@ -67,6 +67,12 @@ class BookStoreTests(unittest.TestCase):
             75.20,
             places=2)
 
+    def test_four_groups_of_4_are_cheaper_than_2_groups_each_of_5_and_3(self):
+        self.assertAlmostEqual(
+            calculate_total([1, 1, 2, 2, 3, 3, 4, 5, 1, 1, 2, 2, 3, 3, 4, 5]),
+            102.40,
+            places=2)
+
 
 if __name__ == '__main__':
     unittest.main()

data/tracks/ruby/config.json

@@ -912,6 +912,17 @@
       "slug": "complex-numbers",
       "difficulty": 3,
       "topics": [ "Mathematics" ]
+    },
+    {
+      "uuid": "a0aac827-8f7a-4065-9d05-a57009f5668d",
+      "slug": "isbn-verifier",
+      "core": false,
+      "unlocked_by": null,
+      "difficulty": 2,
+      "topics": [
+        "strings",
+        "logic"
+      ]
     }
   ],
   "foregone": [

data/tracks/ruby/exercises/isbn-verifier/.meta/.version

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

data/tracks/ruby/exercises/isbn-verifier/.meta/generator/isbn_verifier_case.rb

@@ -0,0 +1,28 @@
+require 'generator/exercise_case'
+
+class IsbnVerifierCase < Generator::ExerciseCase
+
+  def workload
+    indent_lines(
+      [
+        "string = #{input.inspect}",
+        "#{assert} IsbnVerifier.valid?(string), #{failure_message}"
+      ], 4
+    )
+  end
+
+  private
+
+  def failure_message
+    %Q("Expected #{expected}, #{reason}")
+  end
+
+  def reason
+    "'\#{string}' #{is_or_not} a valid isbn"
+  end
+
+  def is_or_not
+    expected ? 'is' : 'is not'
+  end
+
+end

data/tracks/ruby/exercises/isbn-verifier/.meta/solutions/isbn_verifier.rb

@@ -0,0 +1,25 @@
+module BookKeeping
+  VERSION = 1
+end
+
+class IsbnVerifier
+  def self.valid?(str)
+    return false unless /\A\d-?\d{3}-?\d{5}-?[\dX]\z/.match(str)
+
+    result = str
+      .gsub("-", "")
+      .chars
+      .map { |char|
+        char.gsub("X","10")
+      }
+      .zip(10.downto(1))
+      .map { |number, index|
+        number.to_i * index
+      }
+      .reduce(0){ |sum, digit|
+        sum + digit
+      }
+
+    result % 11 == 0
+  end
+end

data/tracks/ruby/exercises/isbn-verifier/README.md

@@ -0,0 +1,73 @@
+# Isbn Verifier
+
+The [ISBN-10 verification process](https://en.wikipedia.org/wiki/International_Standard_Book_Number) is used to validate book identification
+numbers. These normally contain dashes and look like: `3-598-21508-8`
+
+## ISBN
+
+The ISBN-10 format is 9 digits (0 to 9) plus one check character (either a digit or an X only). In the case the check character is an X, this represents the value '10'. These may be communicated with or without hyphens, and can be checked for their validity by the following formula:
+
+```
+(x1 * 10 + x2 * 9 + x3 * 8 + x4 * 7 + x5 * 6 + x6 * 5 + x7 * 4 + x8 * 3 + x9 * 2 + x10 * 1) mod 11 == 0
+```
+
+If the result is 0, then it is a valid ISBN-10, otherwise it is invalid.
+
+## Example
+
+Let's take the ISBN-10 `3-598-21508-8`. We plug it in to the formula, and get:
+```
+(3 * 10 + 5 * 9 + 9 * 8 + 8 * 7 + 2 * 6 + 1 * 5 + 5 * 4 + 0 * 3 + 8 * 2 + 8 * 1) mod 11 == 0
+```
+
+Since the result is 0, this proves that our ISBN is valid.
+
+## Task
+
+Given a string the program should check if the provided string is a valid ISBN-10.
+Putting this into place requires some thinking about preprocessing/parsing of the string prior to calculating the check digit for the ISBN.
+
+The program should be able to verify ISBN-10 both with and without separating dashes.
+
+
+## Caveats
+
+Converting from strings to numbers can be tricky in certain languages.
+Now, it's even trickier since the check digit of an ISBN-10 may be 'X' (representing '10'). For instance `3-598-21507-X` is a valid ISBN-10.
+
+## Bonus tasks
+
+* Generate a valid ISBN-13 from the input ISBN-10 (and maybe verify it again with a derived verifier).
+
+* Generate valid ISBN, maybe even from a given starting ISBN.
+* * * *
+
+For installation and learning resources, refer to the
+[exercism help page](http://exercism.io/languages/ruby).
+
+For running the tests provided, you will need the Minitest gem. Open a
+terminal window and run the following command to install minitest:
+
+    gem install minitest
+
+If you would like color output, you can `require 'minitest/pride'` in
+the test file, or note the alternative instruction, below, for running
+the test file.
+
+In order to run the test, you can run the test file from the exercise
+directory. For example, if the test suite is called
+`hello_world_test.rb`, you can run the following command:
+
+    ruby hello_world_test.rb
+
+To include color from the command line:
+
+    ruby -r minitest/pride hello_world_test.rb
+
+
+## Source
+
+Converting a string into a number and some basic processing utilizing a relatable real world example. [https://en.wikipedia.org/wiki/International_Standard_Book_Number#ISBN-10_check_digit_calculation](https://en.wikipedia.org/wiki/International_Standard_Book_Number#ISBN-10_check_digit_calculation)
+
+## Submitting Incomplete Solutions
+It's possible to submit an incomplete solution so you can see how others have completed the exercise.