- Added solutions by Colin Crain.

15 files changed, 2065 insertions, 1429 deletions

diff --git a/challenge-053/colin-crain/perl/ch-1.pl b/challenge-053/colin-crain/perl/ch-1.pl
new file mode 100644
index 0000000000..e371066cd3
--- /dev/null
+++ b/challenge-053/colin-crain/perl/ch-1.pl
@@ -0,0 +1,163 @@
+#! /opt/local/bin/perl
+#
+#     rotator.pl
+#
+#     TASK #1
+#     Rotate Matrix
+#         Write a script to rotate the followin matrix by given 90/180/270 degrees clockwise.
+#
+#             [ 1, 2, 3 ]
+#             [ 4, 5, 6 ]
+#             [ 7, 8, 9 ]
+#
+#         For example, if you rotate by 90 degrees then expected result should be like below
+#
+#             [ 7, 4, 1 ]
+#             [ 8, 5, 2 ]
+#             [ 9, 6, 3 ]
+#
+#     method: The are two basic ways to proceed with this challenge, to either
+#         write three routines to perform each of the three actions, or write one
+#         routine to rotate the matrix 90° clockwise and apply it one, two or
+#         three times.
+#
+#         As both require a routine to rotate 90° clockwise, I started there. As
+#         we are given a 3x3 matrix written in brackets, we could just encode
+#         the matrix as an array with 9 elements and use a fixed mapping of the
+#         indices to indicate where to move each element into a new output list
+#         in a single pass over the data. This method would be quite fast if we
+#         need to do this transform many times or over a large matrix. For a 3x3
+#         it seems a bit like cheating, so I chose to use loops to read and
+#         rewrite the data in a structured way.
+#
+#         It appears that the matrix is given as an array of arrays, so we'll
+#         use that. What we need to do resembles a zip routine, taking first the
+#         first element of each array, then the second, etc, and rewriting each
+#         set to a new row. Pushing the data onto a new row results in an
+#         incorrect, reversed mapping, but if we use unshift instead, we write
+#         the new rows from the end first and the elements end up in the right
+#         order.
+#
+#         This code is clean and tight, but is it wasteful to both loop through
+#         each element of each sub array and then repeat this again and possibly
+#         a third time depending on how far we wish to rotate? Unable to resolve
+#         this existential crisis I have decided to impliment both methods, and
+#         see what the differences are in the routines.
+#
+#         To rotate 270°, or 90° CCW, it turns out we need to write the rows
+#         using push, but build the array of completed rows from the end, using
+#         unshift. Thus the rows are forward, but the columns reversed.
+#
+#         To rotate 180°, we don't need the zip behavior, and only need to
+#         reverse each row as is and unshift these rows onto the output, which
+#         reverses the columns.
+#
+#         As now the work is done it seems there's no harm in keeping all three
+#         routines around to perform exactly the transformations we require.
+#
+#
+#       2020 colin crain
+## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ##
+
+
+
+use warnings;
+use strict;
+use feature ":5.26";
+
+
+## ## ## ## ## MAIN:
+
+my $matrix = [  [ 1, 2, 3 ],
+                [ 4, 5, 6 ],
+                [ 7, 8, 9 ]   ];
+
+## do a variety of transformation options
+my $once     = rotate90( $matrix );
+my $twice    = rotate90(rotate90($matrix));
+my $thrice   = rotate90(rotate90(rotate90($matrix)));
+
+my $oneeight = rotate180( $matrix );
+my $twoseven = rotate270( $matrix );
+
+## some overtly, perhaps overly, verbose reporting of the results:
+say " start:\n";
+say (join ', ', $_->@*) for $matrix->@*;
+
+say "\n once:\n";
+show_matrix( $once );
+
+say "\n twice:\n";
+show_matrix( $twice );
+
+say "\n thrice:\n";
+show_matrix( $thrice );
+
+say "\n 180:\n";
+show_matrix( $oneeight );
+
+say "\n 270:\n";
+show_matrix( $twoseven );
+
+
+
+
+## ## ## ## ## SUBS:
+
+sub rotate90 {
+## matrix is an array ref of array refs
+## zip and reverse subarray elements
+    my $matrix = shift;
+    my $output;
+
+    my $cols = scalar $matrix->[0]->@*;     ## subarray elements, or num of cols
+    my $rows = scalar $matrix->@*;          ## array elements,    or num of rows
+
+    for my $idx ( 0..$cols-1 ) {            ## for each index in a row
+        my @newrow;
+        for my $row ( 0..$rows-1 ) {        ## for each row
+            unshift @newrow, $matrix->[$row]->[$idx];        ## reverse rows
+        }
+        push $output->@*, \@newrow;                          ## forward cols
+    }
+    return $output;
+}
+
+sub rotate180 {
+## matrix is an array ref of array refs
+## reverse each subarray, then reverse the outer array
+    my $matrix = shift;
+    my $output;
+
+    for my $row ( $matrix->@* ) {
+        my @newrow = reverse $row->@*;
+        unshift $output->@*, \@newrow;
+    }
+    return $output;
+
+}
+
+sub rotate270 {
+## matrix is an array ref of array refs
+## zip and reverse subarrays in outer array
+    my $matrix = shift;
+    my $output;
+
+    my $cols = scalar $matrix->[0]->@*;     ## subarray elements, or num of cols
+    my $rows = scalar $matrix->@*;          ## array elements, or num of rows
+
+    for my $idx ( 0..$cols-1 ) {
+        my @newrow;
+        for my $row ( 0..$rows-1 ) {
+            push @newrow, $matrix->[$row]->[$idx];     ## forward rows
+        }
+        unshift $output->@*, \@newrow;                 ## reverse cols
+    }
+    return $output;
+}
+
+
+sub show_matrix {
+## print the array data structure in grid form
+    say (join ', ', $_->@*) for $_[0]->@*
+}
diff --git a/challenge-053/colin-crain/perl/ch-2.pl b/challenge-053/colin-crain/perl/ch-2.pl
new file mode 100644
index 0000000000..f39850e48d
--- /dev/null
+++ b/challenge-053/colin-crain/perl/ch-2.pl
@@ -0,0 +1,173 @@
+#! /opt/local/bin/perl
+#
+#       vowel_wow_wow.pl
+#
+#         TASK #2
+#         Vowel Strings
+#             Write a script to accept an integer 1 <= N <= 5 that would print all
+#             possible strings of size N formed by using only vowels (a, e, i, o,
+#             u).
+#
+#             The string should follow the following rules:
+#
+#                 ‘a’ can only be followed by ‘e’ and ‘i’.
+#
+#                 ‘e’ can only be followed by ‘i’.
+#
+#                 ‘i’ can only be followed by ‘a’, ‘e’, ‘o’, and ‘u’.
+#
+#                 ‘o’ can only be followed by ‘a’ and ‘u’.
+#
+#                 ‘u’ can only be followed by ‘o’ and ‘e’.
+#
+#             For example, if the given integer N = 2 then script should print the
+#             following strings:
+#
+#                 ae
+#                 ai
+#                 ei
+#                 ia
+#                 io
+#                 iu
+#                 ie
+#                 oa
+#                 ou
+#                 uo
+#                 ue
+#
+#         method: Well just to get this out of the way:
+#
+#               chaos, audio, teal, video, deuce, poet, coin, dual, guide
+#
+#             not to mention
+#
+#               bazaar, teen, skiing, cool, and vacuum
+#
+#             The practical upshot being, the rules stated in the challenge are
+#             just rules that resemble the way vowels group in English, and
+#             don't really reflect the way this crazy mixed-up language actually
+#             works. But this is all just in fun, right? So who cares? In any
+#             case a part of me needed to make that list, just to be clear that up.
+#
+#             Incidently, it was only the 'aa' combination that was difficult to
+#             come up with, avoiding obscure loan words (think Dutch, or, you
+#             know, Afrikaans). So "krall" almost made the cut, because I know
+#             some South Africans (think "corral"). "Aarkvark" is also Afrikaans
+#             but rather more well-known. "Bazaar" has remarkably been around
+#             since the 16th century and is part of the name of a popular
+#             magazine, so that wins out. It may well be the only candidate that
+#             fits those criteria.
+#
+#             So the rules are just some rules, but that doesn't make them less
+#             important; they define connections of the data set. We start with
+#             the five most common vowels, as apparently we're ignoring "y" and
+#             "w" as well.* Moving on, moving on...
+#
+#             The problem becomes, like many, a problem of structuring data. The
+#             core components are a list of vowel combinations and a mapping of
+#             letters to an array of next letter possibilities. We transverse
+#             the list, shifting off elements of a given length and looking at
+#             the last letter in the string, adding new combinations to the end
+#             of the list as we go. By carefully keeping track of the indices,
+#             we can shift off a complete set of strings of a given length, then
+#             repeat the process to add another letter until our output strings
+#             are the desired length.
+#
+#             The method works for any positive vowel string length, not just
+#             1 <= n <= 5 as required, but as the output grows exponentially,
+#             things get out of hand quickly.
+
+#         comment: The question of how the list of solutions grows is an
+#             interesting one. I made a little meta-analytical loop wrapper and
+#             solved for 1..15, only counting the solutions rather than printing
+#             them out, with results summarized below:
+#
+#                  n     clusters
+#                 ----+--------
+#                  1     5
+#                  2     11
+#                  3     23
+#                  4     50
+#                  5     107
+#                  6     230
+#                  7     494
+#                  8     1061
+#                  9     2279
+#                 10     4895
+#                 11     10514
+#                 12     22583
+#                 13     48506
+#                 14     104186
+#                 15     223781
+#
+#             The sequence is clearly exponential, but exactly how that growth
+#             progresses is not obvious.
+#
+#             One fairly expeditious way to proceed is to just give WolframAlpha
+#             the data and have it do a least-squares fit:
+#
+#                  exponential fit 5,11,23,50,107,230,494,1061,2279,4895,10514,22583,48506,104186,223781
+#
+#             through which we find a good approximation can be made by the
+#             equation:
+#
+#                  f(x) = 2.34215 e^(0.76449 * x)       R^2 = 1.
+#
+#             So:
+#
+#                  f(20)        =  10,230,300  to 6 significant digits
+#                  clusters(20) =  10,239,398  the actual count computed
+#
+#             With a little over 10 million results for n=20 the computational
+#             effort is becoming impractical. However if we double the length to
+#             n=40 things have just exploded:
+#
+#
+#                  f(40)        = 44,685,500,000,000
+#
+#             It does seem exponential growth is all the rage these days, no?
+#
+#             * For the record, I look forward to day I figure out how to use
+#             "cwtch" in a sentence in an unforced manner. "Why" you ask? See
+#             what I did there? Why does only "y" get the love? Cwtch has been
+#             in the OED since 2005. Unlike "cwm", being a rather obscure name
+#             for the rounded divit at the end of a valley, a cwtch means the
+#             special comfort of a hug from a loved one. Now there's a word the
+#             world needs if I ever heard one.
+#
+#
+#
+#       2020 colin crain
+## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ##
+
+
+
+use warnings;
+use strict;
+use feature ":5.26";
+
+## ## ## ## ## MAIN:
+
+my $length = shift @ARGV || 20;
+
+my @output = qw( a e i o u );
+my %following = (  a => [ qw( e i     ) ],
+                   e => [ qw( i       ) ],
+                   i => [ qw( a e o u ) ],
+                   o => [ qw( a u     ) ],
+                   u => [ qw( o e     ) ]     );
+my $count = 1;
+
+while ($count < $length)    {
+    my $num_clusters = scalar @output;              ## memoize this now because we will add elements
+    for (1..$num_clusters) {
+        my $vowel_cluster = shift @output;          ## shift off a cluster
+        my $vowel = substr $vowel_cluster, -1, 1;   ## get the last letter
+        for ($following{$vowel}->@*) {              ## build new combinations from that letter
+            push @output, "$vowel_cluster" . "$_";  ## and add them to the end of the list
+        }
+    }
+    $count++;                                       ## keep track of the cluster length
+}
+
+say $_ for @output;
diff --git a/challenge-053/colin-crain/raku/ch-1.p6 b/challenge-053/colin-crain/raku/ch-1.p6
new file mode 100644
index 0000000000..963ef4ed3f
--- /dev/null
+++ b/challenge-053/colin-crain/raku/ch-1.p6
@@ -0,0 +1,114 @@
+use v6.d;
+
+#
+#     rotator.raku
+#
+#     TASK #1
+#     Rotate Matrix
+#         Write a script to rotate the followin matrix by given 90/180/270 degrees clockwise.
+#
+#             [ 1, 2, 3 ]
+#             [ 4, 5, 6 ]
+#             [ 7, 8, 9 ]
+#
+#         For example, if you rotate by 90 degrees then expected result should be like below
+#
+#             [ 7, 4, 1 ]
+#             [ 8, 5, 2 ]
+#             [ 9, 6, 3 ]
+#
+#
+#     method: The are two basic ways to proceed with this challenge, to either
+#         write three routines to perform each of the three actions, or write
+#         one routine to rotate the matrix 90° clockwise and apply it one, two
+#         or three times.
+#
+#         As both require a routine to rotate 90° clockwise, I started there. As
+#         we are given a 3x3 matrix written in brackets, we could just encode
+#         the matrix as an array with 9 elements and use a fixed mapping of the
+#         indices to indicate where to move each element into a new output list
+#         in a single pass over the data. This method could be quite fast if we
+#         need to do this transform many times or over a large matrix. For a 3x3
+#         it seems a bit like cheating, so I chose to use list routines to read
+#         and rewrite the data in a structured way.
+#
+#         The starting matrix is given in a form resembling an array of arrays,
+#         and as this is a common way to encode matrices, we will continue with
+#         that.
+#
+#         Raku has powerful list routines built in, and between zip, map,
+#         reverse and the reduction metaoperator we can perform any of these
+#         rotation operations succintly.
+#
+#       90°:   To rotate 90° CW, we need to swap rows and columns, then reverse
+#         the column order. So we need to take the first elements of each
+#         subarray, a column, and make a new subarray, or row out of them, and
+#         apply this to each set of elements in turn. We will use a combination
+#         of infix Z, the reduction metaoperator [] and the list operator (,) to
+#         construct a combined "superoperator" (not a real term) [Z,] that does
+#         everything we want. Sort of. Applying just this step to our starting
+#         matrix results in
+
+#             1  4  7
+#             2  5  8
+#             3  6  9
+#
+#         which is close but our column order is reversed.
+#
+#             [Z,] $matrix.reverse
+#
+#         reversed our rows first, which later become our columns, and solves
+#         that problem nicely.
+#
+#       180°:   To rotate 180°, we need to reverse each row, then reverse the
+#         columns. So no zipping is required, and we already have the subarrays
+#         we will need. We will need to look at each subarray and reverse it, so
+#         we will use map with a reverse to do this. Then we can reverse the
+#         outer array, which nicely chains to:
+#
+#             $matrix.map({.reverse}).reverse
+#
+#       270°:   To rotate 90° CCW, again we need to swap row and columns, but
+#         in this case we will leave the column order as is and reverse the
+#         column data. We do this by reversing the individual subarrays first
+#         using map, much as we did for 180°. We then apply the combined
+#         metaoperator [Z,] as we did for 90°. Putting it all together results
+#         in
+#
+#             [Z,] $matrix.map:{.reverse}
+#
+#         Which does what we need.
+#
+#
+#
+#       2020 colin crain
+## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ##
+
+
+sub MAIN () {
+
+    my $matrix = [  [ 1, 2, 3 ],
+                    [ 4, 5, 6 ],
+                    [ 7, 8, 9 ]   ];
+
+    'start'.say;
+    show-matrix $matrix;
+
+    ''.say;
+    '90'.say;
+    show-matrix [Z,] $matrix.reverse;
+
+    ''.say;
+    '180'.say;
+    show-matrix $matrix.map({.reverse}).reverse;
+
+    ''.say;
+    '270'.say;
+    show-matrix [Z,] $matrix.map:{.reverse};
+
+
+}
+
+sub show-matrix ( $matrix ) {
+    .join('  ').say for $matrix.list;
+}
diff --git a/challenge-053/colin-crain/raku/ch-2.p6 b/challenge-053/colin-crain/raku/ch-2.p6
new file mode 100644
index 0000000000..2dbfab9569
--- /dev/null
+++ b/challenge-053/colin-crain/raku/ch-2.p6
@@ -0,0 +1,167 @@
+use v6.d;
+
+#
+#       vowel-wow-wow.raku
+#
+#         TASK #2
+#         Vowel Strings
+#             Write a script to accept an integer 1 <= N <= 5 that would print all
+#             possible strings of size N formed by using only vowels (a, e, i, o,
+#             u).
+#
+#             The string should follow the following rules:
+#
+#                 ‘a’ can only be followed by ‘e’ and ‘i’.
+#
+#                 ‘e’ can only be followed by ‘i’.
+#
+#                 ‘i’ can only be followed by ‘a’, ‘e’, ‘o’, and ‘u’.
+#
+#                 ‘o’ can only be followed by ‘a’ and ‘u’.
+#
+#                 ‘u’ can only be followed by ‘o’ and ‘e’.
+#
+#             For example, if the given integer N = 2 then script should print the
+#             following strings:
+#
+#                 ae
+#                 ai
+#                 ei
+#                 ia
+#                 io
+#                 iu
+#                 ie
+#                 oa
+#                 ou
+#                 uo
+#                 ue
+#
+#         method: Well just to get this out of the way:
+#
+#               chaos, audio, teal, video, deuce, poet, coin, dual, guide
+#
+#             not to mention
+#
+#               bazaar, teen, skiing, cool, and vacuum
+#
+#             The practical upshot being, the rules stated in the challenge are
+#             just rules that resemble the way vowels group in English, and
+#             don't really reflect the way this crazy mixed-up language actually
+#             works. But this is all just in fun, right? So who cares? In any
+#             case a part of me needed to make that list, just to be clear that up.
+#
+#             Incidently, it was only the 'aa' combination that was difficult to
+#             come up with, avoiding obscure loan words (think Dutch, or, you
+#             know, Afrikaans). So "krall" almost made the cut, because I know
+#             some South Africans (think "corral"). "Aarkvark" is also Afrikaans
+#             but rather more well-known. "Bazaar" has remarkably been around
+#             since the 16th century and is part of the name of a popular
+#             magazine, so that wins out. It may well be the only candidate that
+#             fits those criteria.
+#
+#             So the rules are just some rules, but that doesn't make them less
+#             important; they define connections of the data set. We start with
+#             the five most common vowels, as apparently we're ignoring "y" and
+#             "w" as well.* Moving on, moving on...
+#
+#             The problem becomes, like many, a problem of structuring data. The
+#             core components are a list of vowel combinations and a mapping of
+#             letters to an array of next letter possibilities. We transverse
+#             the list, shifting off elements of a given length and looking at
+#             the last letter in the string, adding new combinations to the end
+#             of the list as we go. By carefully keeping track of the indices,
+#             we can shift off a complete set of strings of a given length, then
+#             repeat the process to add another letter until our output strings
+#             are the desired length.
+#
+#             The method works for any positive vowel string length, not just
+#             1 <= n <= 5 as required, but as the output grows exponentially,
+#             things get out of hand quickly.
+
+#         comment: The question of how the list of solutions grows is an
+#             interesting one. I made a little meta-analytical loop wrapper and
+#             solved for 1..15, only counting the solutions rather than printing
+#             them out, with results summarized below:
+#
+#                  n     clusters
+#                 ----+--------
+#                  1     5
+#                  2     11
+#                  3     23
+#                  4     50
+#                  5     107
+#                  6     230
+#                  7     494
+#                  8     1061
+#                  9     2279
+#                 10     4895
+#                 11     10514
+#                 12     22583
+#                 13     48506
+#                 14     104186
+#                 15     223781
+#
+#             The sequence is clearly exponential, but exactly how that growth
+#             progresses is not obvious.
+#
+#             One fairly expeditious way to proceed is to just give WolframAlpha
+#             the data and have it do a least-squares fit:
+#
+#                  exponential fit 5,11,23,50,107,230,494,1061,2279,4895,10514,22583,48506,104186,223781
+#
+#             through which we find a good approximation can be made by the
+#             equation:
+#
+#                  f(x) = 2.34215 e^(0.76449 * x)       R^2 = 1.
+#
+#             So:
+#
+#                  f(20)        =  10,230,300  to 6 significant digits
+#                  clusters(20) =  10,239,398  the actual count computed
+#
+#             With a little over 10 million results for n=20 the computational
+#             effort is becoming impractical. However if we double the length to
+#             n=40 things have just exploded:
+#
+#
+#                  f(40)        = 44,685,500,000,000
+#
+#             It does seem exponential growth is all the rage these days, no?
+#
+#             * For the record, I look forward to day I figure out how to use
+#             "cwtch" in a sentence in an unforced manner. "Why" you ask? See
+#             what I did there? Why does only "y" get the love? Cwtch has been
+#             in the OED since 2005. Unlike "cwm", being a rather obscure name
+#             for the rounded divit at the end of a valley, a cwtch means the
+#             special comfort of a hug from a loved one. Now there's a word the
+#             world needs if I ever heard one.
+#
+#
+#
+#       2020 colin crain
+## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ##
+
+sub MAIN (Int:D $length where {$length > 0} = 3) {
+    my @output    = qw< a e i o u >;
+    my %following =  a => qw< e i     > ,
+                     e => qw< i       > ,
+                     i => qw< a e o u > ,
+                     o => qw< a u     > ,
+                     u => qw< o e     > ;
+    my $count = 1;
+
+    while $count < $length {
+        my $num_clusters = @output.elems;
+        for ^$num_clusters {
+            my $vowel_cluster = @output.shift;
+            my $vowel = substr $vowel_cluster, *-1, 1;
+            for %following{$vowel}.list {
+                @output.push: $vowel_cluster ~ $_;
+            }
+        }
+        $count++;
+
+    }
+
+    .say for @output;
+}
diff --git a/stats/pwc-current.json b/stats/pwc-current.json
index 5e70c899cc..871f27f19e 100644
--- a/stats/pwc-current.json
+++ b/stats/pwc-current.json
@@ -1,6 +1,177 @@
 {
-   "chart" : {
-      "type" : "column"
+   "series" : [
+      {
+         "data" : [
+            {
+               "name" : "Alicia Bielsa",
+               "y" : 4,
+               "drilldown" : "Alicia Bielsa"
+            },
+            {
+               "drilldown" : "Andrezgz",
+               "name" : "Andrezgz",
+               "y" : 2
+            },
+            {
+               "y" : 3,
+               "name" : "Arne Sommer",
+               "drilldown" : "Arne Sommer"
+            },
+            {
+               "name" : "Athanasius",
+               "y" : 4,
+               "drilldown" : "Athanasius"
+            },
+            {
+               "drilldown" : "Cheok-Yin Fung",
+               "y" : 4,
+               "name" : "Cheok-Yin Fung"
+            },
+            {
+               "name" : "Colin Crain",
+               "y" : 4,
+               "drilldown" : "Colin Crain"
+            },
+            {
+               "y" : 1,
+               "name" : "Cristina Heredia",
+               "drilldown" : "Cristina Heredia"
+            },
+            {
+               "name" : "Dave Cross",
+               "y" : 2,
+               "drilldown" : "Dave Cross"
+            },
+            {
+               "drilldown" : "Dave Jacoby",
+               "y" : 3,
+               "name" : "Dave Jacoby"
+            },
+            {
+               "drilldown" : "Duncan C. White",
+               "name" : "Duncan C. White",
+               "y" : 2
+            },
+            {
+               "name" : "E. Choroba",
+               "y" : 3,
+               "drilldown" : "E. Choroba"
+            },
+            {
+               "y" : 5,
+               "name" : "Jaldhar H. Vyas",
+               "drilldown" : "Jaldhar H. Vyas"
+            },
+            {
+               "drilldown" : "Javier Luque",
+               "name" : "Javier Luque",
+               "y" : 5
+            },
+            {
+               "name" : "Kevin Colyer",
+               "y" : 2,
+               "drilldown" : "Kevin Colyer"
+            },
+            {
+               "name" : "Laurent Rosenfeld",
+               "y" : 5,
+               "drilldown" : "Laurent Rosenfeld"
+            },
+            {
+               "name" : "Lubos Kolouch",
+               "y" : 2,
+               "drilldown" : "Lubos Kolouch"
+            },
+            {
+               "drilldown" : "Luca Ferrari",
+               "name" : "Luca Ferrari",
+               "y" : 4
+            },
+            {
+               "y" : 2,
+               "name" : "Mark Anderson",
+               "drilldown" : "Mark Anderson"
+            },
+            {
+               "y" : 3,
+               "name" : "Markus Holzer",
+               "drilldown" : "Markus Holzer"
+            },
+            {
+               "y" : 5,
+               "name" : "Mohammad S Anwar",
+               "drilldown" : "Mohammad S Anwar"
+            },
+            {
+               "drilldown" : "Noud Aldenhoven",
+               "name" : "Noud Aldenhoven",
+               "y" : 2
+            },
+            {
+               "drilldown" : "Pete Houston",
+               "name" : "Pete Houston",
+               "y" : 1
+            },
+            {
+               "drilldown" : "Roger Bell West",
+               "y" : 4,
+               "name" : "Roger Bell West"
+            },
+            {
+               "drilldown" : "Ruben Westerberg",
+               "y" : 4,
+               "name" : "Ruben Westerberg"
+            },
+            {
+               "name" : "Ryan Thompson",
+               "y" : 6,
+               "drilldown" : "Ryan Thompson"
+            },
+            {
+               "y" : 2,
+               "name" : "Saif Ahmed",
+               "drilldown" : "Saif Ahmed"
+            },
+            {
+               "drilldown" : "Shahed Nooshmand",
+               "y" : 3,
+               "name" : "Shahed Nooshmand"
+            },
+            {
+               "drilldown" : "Simon Proctor",
+               "name" : "Simon Proctor",
+               "y" : 2
+            },
+            {
+               "drilldown" : "Ulrich Rieke",
+               "y" : 2,
+               "name" : "Ulrich Rieke"
+            },
+            {
+               "drilldown" : "User Person",
+               "y" : 2,
+               "name" : "User Person"
+            },
+            {
+               "y" : 2,
+               "name" : "Wanderdoc",
+               "drilldown" : "Wanderdoc"
+            },
+            {
+               "drilldown" : "Yet Ebreo",
+               "y" : 2,
+               "name" : "Yet Ebreo"
+            }
+         ],
+         "colorByPoint" : 1,
+         "name" : "Perl Weekly Challenge - 053"
+      }
+   ],
+   "title" : {
+      "text" : "Perl Weekly Challenge - 053"
+   },
+   "legend" : {
+      "enabled" : 0
    },
    "drilldown" : {
       "series" : [
@@ -30,6 +201,7 @@
          },
          {
             "id" : "Arne Sommer",
+            "name" : "Arne Sommer",
             "data" : [
                [
                   "Raku",
@@ -39,12 +211,10 @@
                   "Blog",
                   1
                ]
-            ],
-            "name" : "Arne Sommer"
+            ]
          },
          {
             "id" : "Athanasius",
-            "name" : "Athanasius",
             "data" : [
                [
                   "Perl",
@@ -54,9 +224,11 @@
                   "Raku",
                   2
                ]
-            ]
+            ],
+            "name" : "Athanasius"
          },
          {
+            "id" : "Cheok-Yin Fung",
             "data" : [
                [
                   "Perl",
@@ -67,8 +239,21 @@
                   2
                ]
             ],
-            "name" : "Cheok-Yin Fung",
-            "id" : "Cheok-Yin Fung"
+            "name" : "Cheok-Yin Fung"
+         },
+         {
+            "data" : [
+               [
+                  "Perl",
+                  2
+               ],
+               [
+                  "Raku",
+                  2
+               ]
+            ],
+            "name" : "Colin Crain",
+            "id" : "Colin Crain"
          },
          {
             "id" : "Cristina Heredia",
@@ -81,17 +266,17 @@
             ]
          },
          {
-            "name" : "Dave Cross",
+            "id" : "Dave Cross",
             "data" : [
                [
                   "Perl",
                   2
                ]
             ],
-            "id" : "Dave Cross"
+            "name" : "Dave Cross"
          },
          {
-            "id" : "Dave Jacoby",
+            "name" : "Dave Jacoby",
             "data" : [
                [
                   "Perl",
@@ -102,21 +287,20 @@
                   1
                ]
             ],
-            "name" : "Dave Jacoby"
+            "id" : "Dave Jacoby"
          },
          {
             "id" : "Duncan C. White",
-            "name" : "Duncan C. White",
             "data" : [
                [
                   "Perl",
                   2
                ]
-            ]