trackler 2.2.1.65 → 2.2.1.66

data/tracks/perl6/exercises/all-your-base/example.yaml

@@ -1,73 +1,53 @@
 exercise: AllYourBase
-version: 2
+version: 3
 plan: 23
 imports: '&convert-base'
 tests: |-
-
-  for @($c-data<cases>) -> $case {
-    if $case<expected> ~~ Array:D { test }
-    else {
-      given $case<description> {
-        when 'empty list' { test [] }
-        when /base|digit/ { throws-like {call-convert-base}, Exception, $_ }
-        when /zero/ {
-          when 'leading zeros' { test [4,2] }
-          default { test [0] }
-        }
-        flunk "$_; not tested" if %*ENV<EXERCISM>; # To ensure that no canonical-data cases are missed.
-      }
+  for $c-data<cases>.values -> $case {
+    sub call-convert-base {
+      convert-base(
+        bases  => %(<from to> Z=> .<input_base output_base>),
+        digits => .<input_digits>,
+      ) given $case;
     }
 
-    sub test (Array:D $expected = $case<expected>) {
-      is-deeply call-convert-base, $expected, $case<description>
+    given $case {
+      if .<expected><error> {
+        throws-like {call-convert-base}, Exception, .<description>;
+      }
+      else {
+        cmp-ok call-convert-base, ‘~~’, |.<expected description>;
+      }
     }
-
-    sub call-convert-base { convert-base(|$case<input_base input_digits output_base>) }
   }
 
 unit: module
 example: |-
-  class X::AllYourBase::InvalidBase is Exception {
-    has $.payload;
-    method message {"$!payload is not a valid base."}
-  }
-
-  class X::AllYourBase::InvalidDigit is Exception {
-    has %.payload;
-    method message {"%!payload<digit> is not a valid digit for base %!payload<base>."}
-  }
-
-  sub convert-base (Int:D $input-base, @input-digits, Int:D $output-base --> Array:D) is export {
-    for $input-base, $output-base {
-      X::AllYourBase::InvalidBase.new(payload => $_).throw if $_ < 2;
-    }
-    from-decimal($output-base, (to-decimal $input-base, @input-digits));
+  sub convert-base (
+    :%bases! where all(.keys ~~ <from to>.Set, .values.all > 1),
+    :@digits! where %bases<from> > .all ~~ UInt:D,
+    --> Array[UInt:D]
+  ) is export {
+    from-decimal %bases<to>, to-decimal(%bases<from>, @digits);
   }
 
   sub to-decimal ($input-base, @input-digits) {
-    return [].Slip if !@input-digits;
     my $elems = @input-digits.elems;
-    for @input-digits {
-      if $_ == 0 { $elems-- }
-      else { last }
-    }
-    my $dec = 0;
-    loop (my $i = 0; $i < $elems; $i++) {
-      if @input-digits.reverse[$i] < 0 || @input-digits.reverse[$i] >= $input-base {
-        X::AllYourBase::InvalidDigit.new( :payload(base => $input-base, digit => @input-digits.reverse[$i]) ).throw;
-      }
-      $dec += @input-digits.reverse[$i] * $input-base ** $i;
-    }
-    return $dec;
+    $_ == 0 ?? $elems-- !! last for @input-digits;
+    (loop (my $i = 0; $i < $elems; $i++) {
+      @input-digits.reverse[$i] * $input-base ** $i;
+    }).sum;
   }
 
-  sub from-decimal ($output-base, $dec) {
-    my @output-digits;
-    my $num = $dec;
+  sub from-decimal ($output-base, $num is copy) {
+    my UInt:D @output-digits;
     while $num >= $output-base {
       unshift @output-digits, $num % $output-base;
       $num div= $output-base;
     }
-    unshift @output-digits, $num;
-    return @output-digits;
+    @output-digits.unshift: $num;
+  }
+
+stub: |-
+  sub convert-base (:%bases!, :@digits!) is export {
   }

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

@@ -1,6 +1,7 @@
-unit module Hamming:ver<1>;
+unit module Hamming:ver<2>;
 
-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
+sub hamming-distance (
+  +@strands where { .elems == 2 && [==] $_».chars } --> Int:D
+) is export {
+  sum [Zne] @strands».comb
 }

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

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

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

@@ -1,11 +1,11 @@
 exercise: Hamming
-version: 1
+version: 2
 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>;
+      throws-like {hamming-distance(|.<strand1 strand2>)}, Exception, .<description>;
     } else {
       is hamming-distance(|.<strand1 strand2>), |.<expected description>;
     }
@@ -13,9 +13,10 @@ tests: |-
 
 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
+  sub hamming-distance (
+    +@strands where { .elems == 2 && [==] $_».chars } --> Int:D
+  ) is export {
+    sum [Zne] @strands».comb
   }
 stub: |-
   sub hamming-distance ($strand1, $strand2) is export {

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

@@ -5,7 +5,7 @@ use lib my $dir = $?FILE.IO.dirname;
 use JSON::Fast;
 
 my Str:D $exercise := 'Hamming';
-my Version:D $version = v1;
+my Version:D $version = v2;
 my Str $module //= $exercise;
 plan 17;
 
@@ -24,7 +24,7 @@ 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>;
+    throws-like {hamming-distance(|.<strand1 strand2>)}, Exception, .<description>;
   } else {
     is hamming-distance(|.<strand1 strand2>), |.<expected description>;
   }

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

@@ -2,25 +2,29 @@
 
 Calculate the date of meetups.
 
-Typically meetups happen on the same day of the week.  In this exercise, you will take
-a description of a meetup date, and return the actual meetup date.
+Typically meetups happen on the same day of the week.  In this exercise, you
+will take a description of a meetup date, and return the actual meetup date.
 
 Examples of general descriptions are:
 
-- the first Monday of January 2017
-- the third Tuesday of January 2017
-- the Wednesteenth of January 2017
-- the last Thursday of January 2017
+- The first Monday of January 2017
+- The third Tuesday of January 2017
+- The wednesteenth of January 2017
+- The last Thursday of January 2017
 
-Note that "Monteenth", "Tuesteenth", etc are all made up words. There
-was a meetup whose members realized that there are exactly 7 numbered days in a month that
-end in '-teenth'. Therefore, one is guaranteed that each day of the week
+The descriptors you are expected to parse are:
+first, second, third, fourth, fifth, last, monteenth, tuesteenth, wednesteenth,
+thursteenth, friteenth, saturteenth, sunteenth
+
+Note that "monteenth", "tuesteenth", etc are all made up words. There was a
+meetup whose members realized that there are exactly 7 numbered days in a month
+that 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
-(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
+Given examples of a meetup dates, each containing a month, day, year, and
+descriptor calculate the date of the actual meetup.  For example, if given
+"The first Monday of January 2017", the correct meetup date is 2017/1/2.
 
 ## Resources
 

data/tracks/perl6/exercises/nucleotide-count/Example.pm6

@@ -0,0 +1,7 @@
+unit module NucleotideCount:ver<1>;
+
+sub nucleotide-count (
+  Str:D $_ where { .comb.Set ⊆ <A C G T> } --> Bag(Iterable:D)
+) is export {
+  .comb
+}

data/tracks/perl6/exercises/nucleotide-count/NucleotideCount.pm6

@@ -0,0 +1,4 @@
+unit module NucleotideCount:ver<1>;
+
+sub nucleotide-count ($strand) is export {
+}

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

@@ -0,0 +1,38 @@
+# Nucleotide Count
+
+Given a single stranded DNA string, compute how many times each nucleotide occurs in the string.
+
+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 as
+- legos are to lego houses as
+- words are to sentences as...
+
+## 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 DNA Nucleotides_problem at Rosalind [http://rosalind.info/problems/dna/](http://rosalind.info/problems/dna/)
+
+## 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/nucleotide-count/example.yaml

@@ -0,0 +1,24 @@
+exercise: NucleotideCount
+version: 1
+plan: 7
+imports: '&nucleotide-count'
+tests: |-
+  for $c-data<cases>».<cases>».Array.flat {
+    if .<expected><error> {
+      throws-like {nucleotide-count(.<strand>)}, Exception, .<description>;
+    }
+    else {
+      cmp-ok nucleotide-count(.<strand>), '~~', .<expected>.Bag, .<description>;
+    }
+  }
+
+unit: module
+example: |-
+  sub nucleotide-count (
+    Str:D $_ where { .comb.Set ⊆ <A C G T> } --> Bag(Iterable:D)
+  ) is export {
+    .comb
+  }
+stub: |-
+  sub nucleotide-count ($strand) is export {
+  }

data/tracks/perl6/exercises/nucleotide-count/nucleotide-count.t

@@ -0,0 +1,116 @@
+#!/usr/bin/env perl6
+use v6;
+use Test;
+use lib my $dir = $?FILE.IO.dirname;
+use JSON::Fast;
+
+my Str:D $exercise := 'NucleotideCount';
+my Version:D $version = v1;
+my Str $module //= $exercise;
+plan 7;
+
+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) <&nucleotide-count>;
+
+my $c-data = from-json $=pod.pop.contents;
+for $c-data<cases>».<cases>».Array.flat {
+  if .<expected><error> {
+    throws-like {nucleotide-count(.<strand>)}, Exception, .<description>;
+  }
+  else {
+    cmp-ok nucleotide-count(.<strand>), '~~', .<expected>.Bag, .<description>;
+  }
+}
+
+=head2 Canonical Data
+=begin code
+
+{
+  "exercise": "nucleotide-count",
+  "version": "1.2.0",
+  "cases": [
+    {
+      "description": "count all nucleotides in a strand",
+      "cases": [
+        {
+          "description": "empty strand",
+          "property": "nucleotideCounts",
+          "strand": "",
+          "expected": {
+            "A": 0,
+            "C": 0,
+            "G": 0,
+            "T": 0
+          }
+        },
+        {
+          "description": "can count one nucleotide in single-character input",
+          "property": "nucleotideCounts",
+          "strand": "G",
+          "expected": {
+            "A": 0,
+            "C": 0,
+            "G": 1,
+            "T": 0
+          }
+        },
+        {
+          "description": "strand with repeated nucleotide",
+          "property": "nucleotideCounts",
+          "strand": "GGGGGGG",
+          "expected": {
+            "A": 0,
+            "C": 0,
+            "G": 7,
+            "T": 0
+          }
+        },
+        {
+          "description": "strand with multiple nucleotides",
+          "property": "nucleotideCounts",
+          "strand": "AGCTTTTCATTCTGACTGCAACGGGCAATATGTCTCTGTGTGGATTAAAAAAAGAGTGTCTGATAGCAGC",
+          "expected": {
+            "A": 20,
+            "C": 12,
+            "G": 17,
+            "T": 21
+          }
+        },
+        {
+          "description": "strand with invalid nucleotides",
+          "property": "nucleotideCounts",
+          "strand": "AGXXACT",
+          "expected": {
+            "error": "Invalid nucleotide in strand"
+          }
+        }
+      ]
+    }
+  ]
+}
+
+=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/perfect-numbers/example.py

@@ -7,6 +7,17 @@ def divisor_generator(n):
                 yield n // i
 
 
-def is_perfect(n):
+def classify(n):
     ''' A perfect number equals the sum of its positive divisors. '''
-    return sum(divisor_generator(n)) + 1 == n
+    if n <= 0:
+        raise ValueError("Classification is only possible" +
+                         " for positive whole numbers.")
+
+    aliquot_sum = sum(divisor_generator(n)) + (1 if n > 1 else 0)
+
+    if aliquot_sum < n:
+        return "deficient"
+    elif aliquot_sum == n:
+        return "perfect"
+    else:
+        return "abundant"

data/tracks/python/exercises/perfect-numbers/perfect_numbers.py

@@ -1,6 +1,2 @@
-def divisor_generator(number):
-    pass
-
-
-def is_perfect(number):
+def classify(number):
     pass

data/tracks/python/exercises/perfect-numbers/perfect_numbers_test.py

@@ -1,42 +1,80 @@
 import unittest
 
-from perfect_numbers import is_perfect
+from perfect_numbers import classify
+
+# Tests adapted from `problem-specifications//canonical-data.json` @ v1.0.1
 
 
 class PerfectNumbersTest(unittest.TestCase):
+    def test_smallest_perfect_number(self):
+        self.assertIs(classify(6), "perfect")
 
-    def test_first_perfect_number(self):
-        self.assertIs(is_perfect(6), True)
+    def test_medium_perfect_number(self):
+        self.assertIs(classify(28), "perfect")
 
-    def test_no_perfect_number(self):
-        self.assertIs(is_perfect(8), False)
+    def test_large_perfect_number(self):
+        self.assertIs(classify(33550336), "perfect")
 
-    def test_second_perfect_number(self):
-        self.assertIs(is_perfect(28), True)
+    # Additional tests for this track
+    def test_third_perfect_number(self):
+        self.assertIs(classify(496), "perfect")
 
-    def test_abundant(self):
-        self.assertIs(is_perfect(20), False)
+    def test_fourth_perfect_number(self):
+        self.assertIs(classify(8128), "perfect")
 
-    def test_answer_to_the_ultimate_question_of_life(self):
-        self.assertIs(is_perfect(42), False)
+    def test_sixth_perfect_number(self):
+        self.assertIs(classify(8589869056), "perfect")
 
-    def test_third_perfect_number(self):
-        self.assertIs(is_perfect(496), True)
+    def test_seventh_perfect_number(self):
+        self.assertIs(classify(137438691328), "perfect")
+
+
+class AbundantNumbersTest(unittest.TestCase):
+    def test_smallest_abundant_number(self):
+        self.assertIs(classify(12), "abundant")
+
+    def test_medium_abundant_number(self):
+        self.assertIs(classify(30), "abundant")
+
+    def test_large_abundant_number(self):
+        self.assertIs(classify(33550335), "abundant")
+
+    # Additional tests for this track
+    def test_answer_to_the_ultimate_question_of_life(self):
+        self.assertIs(classify(42), "abundant")
 
     def test_odd_abundant(self):
-        self.assertIs(is_perfect(945), False)
+        self.assertIs(classify(945), "abundant")
 
-    def test_fourth_perfect_number(self):
-        self.assertIs(is_perfect(8128), True)
+    def test_even_abundant(self):
+        self.assertIs(classify(20), "abundant")
 
-    def test_fifth_perfect_number(self):
-        self.assertIs(is_perfect(33550336), True)
 
-    def test_sixth_perfect_number(self):
-        self.assertIs(is_perfect(8589869056), True)
+class DeficientNumbersTest(unittest.TestCase):
+    def test_smallest_prime_deficient_number(self):
+        self.assertIs(classify(2), "deficient")
 
-    def test_seventh_perfect_number(self):
-        self.assertIs(is_perfect(137438691328), True)
+    def test_smallest_nonprime_deficient_number(self):
+        self.assertIs(classify(4), "deficient")
+
+    def test_medium_deficient_number(self):
+        self.assertIs(classify(32), "deficient")
+
+    def test_large_deficient_number(self):
+        self.assertIs(classify(33550337), "deficient")
+
+    def test_edge_case(self):
+        self.assertIs(classify(1), "deficient")
+
+
+class InvalidInputsTest(unittest.TestCase):
+    def test_zero(self):
+        with self.assertRaises(ValueError):
+            classify(0)
+
+    def test_negative(self):
+        with self.assertRaises(ValueError):
+            classify(-1)
 
 
 if __name__ == '__main__':