trackler 2.2.0.3 → 2.2.0.4

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

@@ -0,0 +1,66 @@
+# Kindergarten Garden
+
+Given a diagram, determine which plants each child in the kindergarten class is
+responsible for.
+
+The kindergarten class is learning about growing plants. The teachers
+thought it would be a good idea to give them actual seeds, plant them in
+actual dirt, and grow actual plants.
+
+They've chosen to grow grass, clover, radishes, and violets.
+
+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
+[window][window][window]
+........................ # each dot represents a styrofoam cup
+........................
+```
+
+There are 12 children in the class:
+
+- Alice, Bob, Charlie, David,
+- Eve, Fred, Ginny, Harriet,
+- Ileana, Joseph, Kincaid, and Larry.
+
+Each child gets 4 cups, two on each row. The children are assigned to
+cups in alphabetical order.
+
+The following diagram represents Alice's plants:
+
+```plain
+[window][window][window]
+VR......................
+RG......................
+```
+
+So in the row nearest the window, she has a violet and a radish; in the
+row behind that, she has a radish and some grass.
+
+Your program will be given the plants from left-to-right starting with
+the row nearest the windows. From this, it should be able to determine
+which plants belong to which students.
+
+For example, if it's told that the garden looks like so:
+
+```plain
+[window][window][window]
+VRCGVVRVCGGCCGVRGCVCGCGV
+VRCCCGCRRGVCGCRVVCVGCGCV
+```
+
+Then if asked for Alice's plants, it should provide:
+
+- Violets, radishes, violets, radishes
+
+While asking for Bob's plants would yield:
+
+- Clover, grass, clover, clover
+## Source
+
+Random musings during airplane trip. [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/perl5/exercises/largest-series-product/README.md

@@ -0,0 +1,20 @@
+# Largest Series Product
+
+Given a string of digits, calculate the largest product for a contiguous
+substring of digits of length n.
+
+For example, for the input `'1027839564'`, the largest product for a
+series of 3 digits is 270 (9 * 5 * 6), and the largest product for a
+series of 5 digits is 7560 (7 * 8 * 3 * 9 * 5).
+
+Note that these series are only required to occupy *adjacent positions*
+in the input; the digits need not be *numerically consecutive*.
+
+For the input `'73167176531330624919225119674426574742355349194934'`,
+the largest product for a series of 6 digits is 23520.
+## Source
+
+A variation on Problem 8 at Project Euler [http://projecteuler.net/problem=8](http://projecteuler.net/problem=8)
+
+## Submitting Incomplete Solutions
+It's possible to submit an incomplete solution so you can see how others have completed the exercise.

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

@@ -0,0 +1,33 @@
+# Leap
+
+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
+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
+```
+
+For example, 1997 is not a leap year, but 1996 is.  1900 is not a leap
+year, but 2000 is.
+
+If your language provides a method in the standard library that does
+this look-up, pretend it doesn't exist and implement it yourself.
+
+## Notes
+
+Though our exercise adopts some very simple rules, there is more to
+learn!
+
+For a delightful, four minute explanation of the whole leap year
+phenomenon, go watch [this youtube video][video].
+
+[video]: http://www.youtube.com/watch?v=xX96xng7sAE
+## Source
+
+JavaRanch Cattle Drive, exercise 3 [http://www.javaranch.com/leap.jsp](http://www.javaranch.com/leap.jsp)
+
+## Submitting Incomplete Solutions
+It's possible to submit an incomplete solution so you can see how others have completed the exercise.

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

@@ -0,0 +1,34 @@
+# Linked List
+
+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, 
+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 
+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 
+offers an array-like interface for adding and removing items:
+
+* `push` (*insert value at back*);
+* `pop` (*remove value at back*);
+* `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 
+empty list.
+
+If you want to know more about linked lists, check [Wikipedia](https://en.wikipedia.org/wiki/Linked_list).
+## Source
+
+Classic computer science topic
+
+## Submitting Incomplete Solutions
+It's possible to submit an incomplete solution so you can see how others have completed the exercise.

data/tracks/perl5/exercises/list-ops/README.md

@@ -0,0 +1,10 @@
+# List Ops
+
+Implement basic list operations.
+
+In functional languages list operations like `length`, `map`, and
+`reduce` are very common. Implement a series of basic list operations,
+without using existing functions.
+
+## Submitting Incomplete Solutions
+It's possible to submit an incomplete solution so you can see how others have completed the exercise.

data/tracks/perl5/exercises/luhn/Example.pm

@@ -1,53 +1,31 @@
-package Example;
-
+package Luhn 2;
 use strict;
 use warnings;
 
-use List::Util 'sum';
-
-sub new {
-    my ($class, $number) = @_;
-
-    my $self = bless {} => $class;
-    $self->{number} = [ split '' => $number ];
+sub is_luhn_valid {
+  my ($input) = @_;
+  $input =~ s/\s+//g;
+  if (length $input < 2 || $input =~ /\D+/) {return 0}
 
-    return $self;
-}
+  my @num = split(//, $input);
+  unshift @num, 0 if scalar @num % 2;
 
-sub addends {
-    my $self = shift;
-    my $addends = $self->{number};
+  my $count = 1;
+  my $sum = 0;
 
-    foreach my $index (1..@{$addends}) {
-        if ($index  % 2 == 0 and $addends->[-$index] < 5) {
-            $addends->[-$index] = $addends->[-$index] * 2;
-        }
-        elsif ($index  % 2 == 0 and $addends->[-$index] >= 5) {
-            $addends->[-$index] = $addends->[-$index] * 2 - 9;
-        }
+  foreach (@num) {
+    if ($count % 2) {
+      $sum += $_ * 2;
+      $sum -= 9 if $_ * 2 > 9;
     }
-    return $self->{addends} = $addends;
-
-}
-
-sub checksum {
-    my $self = shift;
-    return sum @{ exists $self->{addends} ? $self->{addends} : $self->addends() };
-}
-
-sub is_valid {
-    my $self = shift;
-    return $self->checksum  % 10 == 0;
-}
-
-sub create {
-    my $self = shift;
-    my $number = join '' => @{$self->{number}};
+    else {
+      $sum += $_;
+    }
+    $count += 1;
+  }
 
-    # thank you /xpython
-    my $luhn = __PACKAGE__->new($number * 10);
-    my $diff = (10 - $luhn->checksum) % 10;
-    return 10 * $number + $diff;
+  if ($sum % 10) {return 0};
+  return 1;
 }
 
 1;

data/tracks/perl5/exercises/luhn/Luhn.pm

@@ -0,0 +1,9 @@
+package Luhn 2;
+use strict;
+use warnings;
+
+sub is_luhn_valid {
+  my ($input) = @_;
+}
+
+1;

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

@@ -0,0 +1,71 @@
+# Luhn
+
+Given a number determine whether or not it is valid per the Luhn formula.
+
+The [Luhn algorithm](https://en.wikipedia.org/wiki/Luhn_algorithm) is
+a simple checksum formula used to validate a variety of identification
+numbers, such as credit card numbers and Canadian Social Insurance
+Numbers.
+
+The task is to check if a given string is valid.
+
+Validating a Number
+------
+
+Strings of length 1 or less are not valid. Spaces are allowed in the input,
+but they should be stripped before checking. All other non-digit characters
+are disallowed.
+
+## Example 1: valid credit card number
+
+```
+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
+
+```
+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:
+
+```
+8569 2478 0383 3437
+```
+
+Then sum all of the digits:
+
+```
+8+5+6+9+2+4+7+8+0+3+8+3+3+4+3+7 = 80
+```
+
+If the sum is evenly divisible by 10, then the number is valid. This number is valid!
+
+## Example 2: invalid credit card number
+
+```
+8273 1232 7352 0569
+```
+
+Double the second digits, starting from the right
+
+```
+7253 2262 5312 0539
+```
+
+Sum the digits
+
+```
+7+2+5+3+2+2+6+2+5+3+1+2+0+5+3+9 = 57
+```
+
+57 is not evenly divisible by 10, so this number is not valid.
+## Source
+
+The Luhn Algorithm on Wikipedia [http://en.wikipedia.org/wiki/Luhn_algorithm](http://en.wikipedia.org/wiki/Luhn_algorithm)
+
+## Submitting Incomplete Solutions
+It's possible to submit an incomplete solution so you can see how others have completed the exercise.

data/tracks/perl5/exercises/luhn/example.yaml

@@ -0,0 +1,38 @@
+exercise: Luhn
+version: 2
+plan: 16
+subs: is_luhn_valid
+tests: |-
+  is $subs{is_luhn_valid}->($_->{input}), $_->{expected}, $_->{description} foreach @{$C_DATA->{cases}};
+
+example: |-
+  sub is_luhn_valid {
+    my ($input) = @_;
+    $input =~ s/\s+//g;
+    if (length $input < 2 || $input =~ /\D+/) {return 0}
+
+    my @num = split(//, $input);
+    unshift @num, 0 if scalar @num % 2;
+
+    my $count = 1;
+    my $sum = 0;
+
+    foreach (@num) {
+      if ($count % 2) {
+        $sum += $_ * 2;
+        $sum -= 9 if $_ * 2 > 9;
+      }
+      else {
+        $sum += $_;
+      }
+      $count += 1;
+    }
+
+    if ($sum % 10) {return 0};
+    return 1;
+  }
+
+stub: |-
+  sub is_luhn_valid {
+    my ($input) = @_;
+  }

data/tracks/perl5/exercises/luhn/luhn.t

@@ -1,31 +1,132 @@
 #!/usr/bin/env perl
 use strict;
 use warnings;
-
-use Test::More tests => 16;
 use FindBin;
 my $dir;
-BEGIN { $dir = $FindBin::Bin . '/' };
-use lib $dir;
-
-my $module = $ENV{EXERCISM} ? 'Example' : 'Luhn';
-
-ok -e "${dir}${module}.pm", "Missing $module.pm" or BAIL_OUT "You need to create file: $module.pm";
-eval "use $module";
-ok !$@, "Cannot load $module" or BAIL_OUT "Cannot load $module; Does it compile? Does it end with 1;?";
-
-can_ok $module, "new"      or BAIL_OUT "Missing package $module; or missing sub new()";
-can_ok $module, "addends"  or BAIL_OUT "Missing package $module; or missing sub addends()";
-can_ok $module, "checksum" or BAIL_OUT "Missing package $module; or missing sub checksum()";
-can_ok $module, "is_valid"    or BAIL_OUT "Missing package $module; or missing sub is_valid()";
-can_ok $module, "create"   or BAIL_OUT "Missing package $module; or missing sub create()";
-
-is_deeply $module->new(12121)->addends, [1, 4, 1, 4, 1],   "add 2 on addends" or diag explain $module->new(12121)->addends;
-is_deeply $module->new(8631)->addends,  [7, 6, 6, 1], "subtract 9 on addends" or diag explain $module->new(8631)->addends;
-is $module->new(4913)->checksum, 22, "add all addends";
-is $module->new(201773)->checksum, 21, "add all addends again";
-ok !$module->new(738)->is_valid, "not a Luhn number";
-ok  $module->new(8739567)->is_valid, "valid Luhn number";
-is $module->new(123)->create, 1230, "add digit to create a valid Luhn";
-is $module->new(873956)->create, 8739567, "create a longer Luhn";
-is $module->new(837263756)->create, 8372637564, "create an even longer Luhn";
+use lib $dir = $FindBin::Bin;
+use JSON::PP;
+
+my $exercise = 'Luhn';
+my $test_version = 2;
+my $module = $ENV{EXERCISM} ? 'Example' : $exercise;
+use Test::More tests => 16;
+
+use_ok $module or BAIL_OUT;
+
+my $exercise_version = $exercise->VERSION // 0;
+if ($exercise_version != $test_version) {
+  warn "\nExercise version mismatch. Further tests may fail!"
+    . "\n$exercise is v$exercise_version. "
+    . "Test is v$test_version.\n";
+  BAIL_OUT if $ENV{EXERCISM};
+}
+
+my %subs;
+foreach ( qw(is_luhn_valid) ) {
+  can_ok $exercise, $_;
+  $subs{$_} = $exercise->can($_);
+}
+
+my $C_DATA;
+is $subs{is_luhn_valid}->($_->{input}), $_->{expected}, $_->{description} foreach @{$C_DATA->{cases}};
+
+SKIP: {
+  skip '', 1 unless $ENV{EXERCISM};
+  is_deeply eval q{
+    use Path::Tiny;
+    decode_json path("$dir/../../problem-specifications/exercises/".path($dir)->basename.'/canonical-data.json')->realpath->slurp;
+  }, $C_DATA, 'canonical-data';
+}
+
+done_testing;
+
+INIT {
+$C_DATA = decode_json <<'EOF';
+
+{
+  "exercise": "luhn",
+  "version": "1.0.0",
+  "cases": [
+    {
+      "description": "single digit strings can not be valid",
+      "property": "valid",
+      "input": "1",
+      "expected": false
+    },
+    {
+      "description": "A single zero is invalid",
+      "property": "valid",
+      "input": "0",
+      "expected": false
+    },
+    {
+      "description": "a simple valid SIN that remains valid if reversed",
+      "property": "valid",
+      "input": "059",
+      "expected": true
+    },
+    {
+      "description": "a simple valid SIN that becomes invalid if reversed",
+      "property": "valid",
+      "input": "59",
+      "expected": true
+    },
+    {
+      "description": "a valid Canadian SIN",
+      "property": "valid",
+      "input": "055 444 285",
+      "expected": true
+    },
+    {
+      "description": "invalid Canadian SIN",
+      "property": "valid",
+      "input": "055 444 286",
+      "expected": false
+    },
+    {
+      "description": "invalid credit card",
+      "property": "valid",
+      "input": "8273 1232 7352 0569",
+      "expected": false
+    },
+    {
+      "description": "valid strings with a non-digit included become invalid",
+      "property": "valid",
+      "input": "055a 444 285",
+      "expected": false
+    },
+    {
+      "description": "valid strings with punctuation included become invalid",
+      "property": "valid",
+      "input": "055-444-285",
+      "expected": false
+    },
+    {
+      "description": "valid strings with symbols included become invalid",
+      "property": "valid",
+      "input": "055£ 444$ 285",
+      "expected": false
+    },
+    {
+      "description": "single zero with space is invalid",
+      "property": "valid",
+      "input": " 0",
+      "expected": false
+    },
+    {
+      "description": "more than a single zero is valid",
+      "property": "valid",
+      "input": "0000 0",
+      "expected": true
+    },
+    {
+      "description": "input digit 9 is correctly converted to output digit 9",
+      "property": "valid",
+      "input": "091",
+      "expected": true
+    }
+  ]
+}
+
+EOF
+}