trackler 2.2.1.56 → 2.2.1.57

data/tracks/perl6/exercises/etl/ETL.pm6

@@ -0,0 +1,6 @@
+unit module ETL:ver<1>;
+
+no precompilation;
+
+sub transform (%input) is export {
+}

data/tracks/perl6/exercises/etl/Example.pm6

@@ -0,0 +1,7 @@
+unit module ETL:ver<1>;
+
+no precompilation;
+
+sub transform ( Hash[Array[Str:D], Int:D] $_ --> Hash[Int:D, Str:D] ) is export {
+  Hash[Int:D, Str:D].new: .invert».&{ .key.lc => .value }
+}

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

@@ -0,0 +1,72 @@
+# 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."
+
+(Typically, this is followed by, "We're only going to need to run this
+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:
+
+- 1 point: "A", "E", "I", "O", "U", "L", "N", "R", "S", "T",
+- 2 points: "D", "G",
+- 3 points: "B", "C", "M", "P",
+- 4 points: "F", "H", "V", "W", "Y",
+- 5 points: "K",
+- 8 points: "J", "X",
+- 10 points: "Q", "Z",
+
+The shiny new scrabble system instead stores the score per letter, which
+makes it much faster and easier to calculate the score for a word. It
+also stores the letters in lower-case regardless of the case of the
+input letters:
+
+- "a" is worth 1 point.
+- "b" is worth 3 points.
+- "c" is worth 3 points.
+- "d" is worth 2 points.
+- Etc.
+
+Your mission, should you choose to accept it, is to transform the legacy data
+format to the shiny new format.
+
+### Notes
+
+A final note about scoring, Scrabble is played around the world in a
+variety of languages, each with its own unique scoring table. For
+example, an "E" is scored at 2 in the Māori-language version of the
+game while being scored at 4 in the Hawaiian-language version.
+
+## Resources
+
+Remember to check out the Perl 6 [documentation](https://docs.perl6.org/) and
+[resources](https://perl6.org/resources/) pages for information, tips, and
+examples if you get stuck.
+
+## Running the tests
+
+There is a test suite and module included with the exercise.
+The test suite (a file with the extension `.t`) will attempt to run routines
+from the module (a file with the extension `.pm6`).
+Add/modify routines in the module so that the tests will pass! You can view the
+test data by executing the command `perl6 --doc *.t` (\* being the name of the
+test suite), and run the test suite for the exercise by executing the command
+`prove . --exec=perl6` in the exercise directory.
+You can also add the `-v` flag e.g. `prove . --exec=perl6 -v` to display all
+tests, including any optional tests marked as 'TODO'.
+
+## Source
+
+The Jumpstart Lab team [http://jumpstartlab.com](http://jumpstartlab.com)
+
+## Submitting Incomplete Solutions
+It's possible to submit an incomplete solution so you can see how others have completed the exercise.

data/tracks/perl6/exercises/etl/etl.t

@@ -0,0 +1,139 @@
+#!/usr/bin/env perl6
+use v6;
+use Test;
+use lib my $dir = $?FILE.IO.dirname;
+use JSON::Fast;
+
+my Str:D $exercise := 'ETL';
+my Version:D $version = v1;
+my Str $module //= $exercise;
+plan 6;
+
+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) <&transform>;
+
+my $c-data = from-json $=pod.pop.contents;
+=head2 Notes
+=begin para
+The test expects your returned C<Hash> to have
+L<type constraints|https://docs.perl6.org/type/Hash#Constraint_value_types>.
+Defined C<Str>s for the values, and defined C<Int>s for the keys.
+=end para
+for $c-data<cases>.values -> %case-set {
+  is-deeply(
+    transform(Hash[Array[Str:D], Int:D].new(
+      .<input>.pairs».&{
+        .key.Int => Array[Str:D](.value.Slip)
+      }
+    )),
+    Hash[Int:D, Str:D].new(.<expected>.pairs),
+    .<description>
+  ) for %case-set<cases>.values;
+}
+
+=head2 Canonical Data
+=begin code
+
+{
+  "exercise": "etl",
+  "version": "1.0.0",
+  "cases": [
+    {
+      "comments": [
+        "Note:  The expected input data for these tests should have",
+        "integer keys (not stringified numbers as shown in the JSON below",
+        "Unless the language prohibits that, please implement these tests",
+        "such that keys are integers. e.g. in JavaScript, it might look ",
+        "like `transform( { 1: ['A'] } );`"
+      ],
+      "description": "transforms the a set of scrabble data previously indexed by the tile score to a set of data indexed by the tile letter",
+      "cases": [
+        {
+          "description": "a single letter",
+          "property": "transform",
+          "input": {
+            "1": ["A"]
+          },
+          "expected": {
+            "a": 1
+          }
+        },
+        {
+          "description": "single score with multiple letters",
+          "property": "transform",
+          "input": {
+            "1": ["A", "E", "I", "O", "U"]
+          },
+          "expected": {
+            "a": 1,
+            "e": 1,
+            "i": 1,
+            "o": 1,
+            "u": 1
+          }
+        },
+        {
+          "description": "multiple scores with multiple letters",
+          "property": "transform",
+          "input": {
+            "1": ["A", "E"],
+            "2": ["D", "G"]
+          },
+          "expected": {
+            "a": 1,
+            "d": 2,
+            "e": 1,
+            "g": 2
+          }
+        },
+        {
+          "description": "multiple scores with differing numbers of letters",
+          "property": "transform",
+          "input": {
+             "1": ["A", "E", "I", "O", "U", "L", "N", "R", "S", "T"],
+             "2": ["D", "G"],
+             "3": ["B", "C", "M", "P"],
+             "4": ["F", "H", "V", "W", "Y"],
+             "5": ["K"],
+             "8": ["J", "X"],
+            "10": ["Q", "Z"]
+          },
+          "expected": {
+            "a":  1, "b":  3, "c": 3, "d": 2, "e": 1,
+            "f":  4, "g":  2, "h": 4, "i": 1, "j": 8,
+            "k":  5, "l":  1, "m": 3, "n": 1, "o": 1,
+            "p":  3, "q": 10, "r": 1, "s": 1, "t": 1,
+            "u":  1, "v":  4, "w": 4, "x": 8, "y": 4,
+            "z": 10
+          }
+        }
+      ]
+    }
+  ]
+}
+
+=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/perl6/exercises/etl/example.yaml

@@ -0,0 +1,35 @@
+exercise: ETL
+version: 1
+plan: 6
+imports: '&transform'
+tests: |-
+  =head2 Notes
+  =begin para
+  The test expects your returned C<Hash> to have
+  L<type constraints|https://docs.perl6.org/type/Hash#Constraint_value_types>.
+  Defined C<Str>s for the values, and defined C<Int>s for the keys.
+  =end para
+  for $c-data<cases>.values -> %case-set {
+    is-deeply(
+      transform(Hash[Array[Str:D], Int:D].new(
+        .<input>.pairs».&{
+          .key.Int => Array[Str:D](.value.Slip)
+        }
+      )),
+      Hash[Int:D, Str:D].new(.<expected>.pairs),
+      .<description>
+    ) for %case-set<cases>.values;
+  }
+
+unit: module
+example: |-
+  no precompilation;
+
+  sub transform ( Hash[Array[Str:D], Int:D] $_ --> Hash[Int:D, Str:D] ) is export {
+    Hash[Int:D, Str:D].new: .invert».&{ .key.lc => .value }
+  }
+stub: |-
+  no precompilation;
+
+  sub transform (%input) is export {
+  }

data/tracks/perl6/exercises/hamming/Example.pm6

@@ -0,0 +1,6 @@
+unit module Hamming:ver<1>;
+
+sub hamming-distance ( Str:D $strand1, Str:D $strand2 --> Int:D ) is export {
+  die ‘left and right strands must be of equal length’ if $strand1.chars ≠ $strand2.chars;
+  ($strand1.comb Zne $strand2.comb).sum
+}

data/tracks/perl6/exercises/hamming/Hamming.pm6

@@ -0,0 +1,4 @@
+unit module Hamming:ver<1>;
+
+sub hamming-distance ($strand1, $strand2) is export {
+}

data/tracks/perl6/exercises/hamming/README.md

@@ -0,0 +1,61 @@
+# Hamming
+
+Calculate the Hamming difference between two DNA strands.
+
+A mutation is simply a mistake that occurs during the creation or
+copying of a nucleic acid, in particular DNA. Because nucleic acids are
+vital to cellular functions, mutations tend to cause a ripple effect
+throughout the cell. Although mutations are technically mistakes, a very
+rare mutation may equip the cell with a beneficial attribute. In fact,
+the macro effects of evolution are attributable by the accumulated
+result of beneficial microscopic mutations over many generations.
+
+The simplest and most common type of nucleic acid mutation is a point
+mutation, which replaces one base with another at a single nucleotide.
+
+By counting the number of differences between two homologous DNA strands
+taken from different genomes with a common ancestor, we get a measure of
+the minimum number of point mutations that could have occurred on the
+evolutionary path between the two strands.
+
+This is called the 'Hamming distance'.
+
+It is found by comparing two DNA strands and counting how many of the
+nucleotides are different from their equivalent in the other string.
+
+    GAGCCTACTAACGGGAT
+    CATCGTAATGACGGCCT
+    ^ ^ ^  ^ ^    ^^
+
+The Hamming distance between these two DNA strands is 7.
+
+# Implementation notes
+
+The Hamming distance is only defined for sequences of equal length. This means
+that based on the definition, each language could deal with getting sequences
+of equal length differently.
+
+## Resources
+
+Remember to check out the Perl 6 [documentation](https://docs.perl6.org/) and
+[resources](https://perl6.org/resources/) pages for information, tips, and
+examples if you get stuck.
+
+## Running the tests
+
+There is a test suite and module included with the exercise.
+The test suite (a file with the extension `.t`) will attempt to run routines
+from the module (a file with the extension `.pm6`).
+Add/modify routines in the module so that the tests will pass! You can view the
+test data by executing the command `perl6 --doc *.t` (\* being the name of the
+test suite), and run the test suite for the exercise by executing the command
+`prove . --exec=perl6` in the exercise directory.
+You can also add the `-v` flag e.g. `prove . --exec=perl6 -v` to display all
+tests, including any optional tests marked as 'TODO'.
+
+## Source
+
+The Calculating Point Mutations problem at Rosalind [http://rosalind.info/problems/hamm/](http://rosalind.info/problems/hamm/)
+
+## Submitting Incomplete Solutions
+It's possible to submit an incomplete solution so you can see how others have completed the exercise.

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

@@ -0,0 +1,22 @@
+exercise: Hamming
+version: 1
+plan: 17
+imports: '&hamming-distance'
+tests: |-
+  for $c-data<cases>.values {
+    if .<expected><error> {
+      throws-like {hamming-distance(|.<strand1 strand2>)}, Exception, .<description>, message => .<expected><error>;
+    } else {
+      is hamming-distance(|.<strand1 strand2>), |.<expected description>;
+    }
+  }
+
+unit: module
+example: |-
+  sub hamming-distance ( Str:D $strand1, Str:D $strand2 --> Int:D ) is export {
+    die ‘left and right strands must be of equal length’ if $strand1.chars ≠ $strand2.chars;
+    ($strand1.comb Zne $strand2.comb).sum
+  }
+stub: |-
+  sub hamming-distance ($strand1, $strand2) is export {
+  }

data/tracks/perl6/exercises/hamming/hamming.t

@@ -0,0 +1,175 @@
+#!/usr/bin/env perl6
+use v6;
+use Test;
+use lib my $dir = $?FILE.IO.dirname;
+use JSON::Fast;
+
+my Str:D $exercise := 'Hamming';
+my Version:D $version = v1;
+my Str $module //= $exercise;
+plan 17;
+
+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) <&hamming-distance>;
+
+my $c-data = from-json $=pod.pop.contents;
+for $c-data<cases>.values {
+  if .<expected><error> {
+    throws-like {hamming-distance(|.<strand1 strand2>)}, Exception, .<description>, message => .<expected><error>;
+  } else {
+    is hamming-distance(|.<strand1 strand2>), |.<expected description>;
+  }
+}
+
+=head2 Canonical Data
+=begin code
+
+{
+"exercise": "hamming",
+"version": "2.0.1",
+  "comments": [
+    "Language implementations vary on the issue of unequal length strands.",
+    "A language may elect to simplify this task by only presenting equal",
+    "length test cases.  For languages handling unequal length strands as",
+    "error condition, unequal length test cases are included here and are",
+    "indicated with an expected value of -1.  Note however that -1 is",
+    "simply an indication here in the JSON.  Actually returning -1 from",
+    "a hamming distance function may or may not be idiomatic in a language.",
+    "Language idioms of errors or exceptions should be followed.",
+    "Alternative interpretations such as ignoring excess length at the end",
+    "are not represented here."
+  ],
+  "cases": [
+    {
+      "description": "empty strands",
+      "property": "distance",
+      "strand1": "",
+      "strand2": "",
+      "expected": 0
+    },
+    {
+      "description": "identical strands",
+      "property": "distance",
+      "strand1": "A",
+      "strand2": "A",
+      "expected": 0
+    },
+    {
+      "description": "long identical strands",
+      "property": "distance",
+      "strand1": "GGACTGA",
+      "strand2": "GGACTGA",
+      "expected": 0
+    },
+    {
+      "description": "complete distance in single nucleotide strands",
+      "property": "distance",
+      "strand1": "A",
+      "strand2": "G",
+      "expected": 1
+    },
+    {
+      "description": "complete distance in small strands",
+      "property": "distance",
+      "strand1": "AG",
+      "strand2": "CT",
+      "expected": 2
+    },
+    {
+      "description": "small distance in small strands",
+      "property": "distance",
+      "strand1": "AT",
+      "strand2": "CT",
+      "expected": 1
+    },
+    {
+      "description": "small distance",
+      "property": "distance",
+      "strand1": "GGACG",
+      "strand2": "GGTCG",
+      "expected": 1
+    },
+    {
+      "description": "small distance in long strands",
+      "property": "distance",
+      "strand1": "ACCAGGG",
+      "strand2": "ACTATGG",
+      "expected": 2
+    },
+    {
+      "description": "non-unique character in first strand",
+      "property": "distance",
+      "strand1": "AAG",
+      "strand2": "AAA",
+      "expected": 1
+    },
+    {
+      "description": "non-unique character in second strand",
+      "property": "distance",
+      "strand1": "AAA",
+      "strand2": "AAG",
+      "expected": 1
+    },
+    {
+      "description": "same nucleotides in different positions",
+      "property": "distance",
+      "strand1": "TAG",
+      "strand2": "GAT",
+      "expected": 2
+    },
+    {
+      "description": "large distance",
+      "property": "distance",
+      "strand1": "GATACA",
+      "strand2": "GCATAA",
+      "expected": 4
+    },
+    {
+      "description": "large distance in off-by-one strand",
+      "property": "distance",
+      "strand1":  "GGACGGATTCTG",
+      "strand2": "AGGACGGATTCT",
+      "expected": 9
+    },
+    {
+      "description": "disallow first strand longer",
+      "property": "distance",
+      "strand1": "AATG",
+      "strand2": "AAA",
+      "expected": {"error": "left and right strands must be of equal length"}
+    },
+    {
+      "description": "disallow second strand longer",
+      "property": "distance",
+      "strand1": "ATA",
+      "strand2": "AGTG",
+      "expected": {"error": "left and right strands must be of equal length"}
+    }
+  ]
+}
+
+=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> }