- Added solutions by Colin Crain.

15 files changed, 1709 insertions, 1120 deletions

diff --git a/challenge-064/colin-crain/perl/ch-1.pl b/challenge-064/colin-crain/perl/ch-1.pl
new file mode 100644
index 0000000000..ea7ba01276
--- /dev/null
+++ b/challenge-064/colin-crain/perl/ch-1.pl
@@ -0,0 +1,172 @@
+#! /opt/local/bin/perl
+#
+#       six_blocks_way.pl
+#
+#     TASK #1 › MINIMUM SUM PATH
+#
+#     Submitted by: Mohammad S Anwar
+#     Remelted and Refined by: RYAN THOMPSON
+#
+#         Given an m × n matrix with non-negative integers, write a
+#         script to find a path from top left to bottom right which
+#         minimizes the sum of all numbers along its path. You can only
+#         move either down or right at any point in time.
+#
+#         EXAMPLE
+#
+#         Input:
+#
+#             [ 1 2 3 ]
+#             [ 4 5 6 ]
+#             [ 7 8 9 ]
+#
+#         The minimum sum path looks like this:
+#
+#             1→2→3
+#                 ↓
+#                 6
+#                 ↓
+#                 9
+#
+#         Thus, your script could output: 21 ( 1 → 2 → 3 → 6 → 9 )
+#
+#         METHOD
+#
+#         What we have here is a matrix of values, located at the points
+#         of a multidimensional array. We are connecting adjacent points
+#         with potential pathways, but restricting travel on those
+#         pathways to only the left-to-right and top-to-bottom
+#         directions. We need a method to follow routes through this
+#         grid from point to point, tallying the values as we go. From
+#         this we can determine the correct answer.
+#
+#         The structure we have made is known as a Directed Acyclic
+#         Graph, and is useful to model many things with a series of
+#         choices towards a goal. We will start by looking at the
+#         underlying structure of a simple 3×4 array, with the points
+#         labeled, rather than the values stored there:
+#
+#                 0,0     0,1     0,2     0,3
+#
+#                 1,0     1,1     1,2     1,3
+#
+#                 2,0     2,1     2,2     2,3
+#
+#         rotating the whole thing clockwise 45° makes the underlying graph easier
+#         to see.
+#
+#                          (0,0)      <-- START
+#                          ⬋   ⬊
+#                      (1,0)   (0,1)
+#                      ⬋   ⬊   ⬋   ⬊
+#                  (2,0)   (1,1)   (0,2)
+#                      ⬊   ⬋   ⬊   ⬋   ⬊
+#                      (2,1)   (1,2)   (0,3)
+#                          ⬊   ⬋   ⬊   ⬋
+#                          (2,2)   (1,3)
+#                              ⬊   ⬋
+#                              (2,3)  <-- END
+#
+#         It’s like a tree that links back into itself, and we progress
+#         from top to bottom, traveling inexorably downward, as in a
+#         pachinko machine with only one pocket. There’s a juicy
+#         metaphor in there somewhere. In any case as can easily be seen
+#         there are many ways to proceed, but if we remain bound to the
+#         restrictions we will always end up at the same endpoint.
+#
+#         When situated at any given point, on the other hand, we are
+#         only allowed at maximum two choices in direction. If we build
+#         a recursive function that will follow each open pathway
+#         available at the current node, by the time we get to the
+#         endpoint we will have logged every possible route. Then we can
+#         take those routes, as lists of points, and do a lookup to the
+#         original values at each point to do the sums. The smallest of
+#         these is the solution. Because we are asked to find “a path”
+#         with the minimal sum, in the case of multiple equal answers
+#         any one will do.
+#
+#         Walking down the script we have an input section, where we
+#         also determine the endpoint. We then find our routes, using a
+#         find_node() routine similar to that in the Raku in logic, but
+#         in this case bifurcating into two independent forks for
+#         downward pointing edges and rightward.
+#
+#       2020 colin crain
+## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ##
+
+
+
+use warnings;
+use strict;
+use feature ":5.26";
+
+## ## ## ## ## MAIN:
+
+my $graph = [   [  1,  16,  12,  43,  48,  19 ],
+                [ 13,   7,   9,  16,  26,  8  ],
+                [ 23,  18,   6,  11,  15,  17 ],
+                [ 22,  33,  28,   5,  36,  32 ],
+                [ 38,  43,   9,  46,   3,  42 ],
+                [ 56,   4,  66,  76,  25,   2 ],
+                [ 27,  10,  58,  14,  68,  52 ]   ];
+
+my $endpoint = [$graph->@* - 1, $graph->[0]->@* - 1];
+
+## determine the paths through the grid
+my @paths;
+my $startpoint = [0,0];
+my $path = [$startpoint];
+find_nodes( $path, $startpoint );
+
+## sum totals to find the smallest
+my $minsum = "+Inf";
+my $minpath;
+for $path (@paths) {
+    my $sum = 0;
+    $sum += $graph->[@$_[0]][@$_[1]] for @$path;
+    if ($sum < $minsum) {
+        $minsum  = $sum;
+        $minpath = $path;
+    }
+}
+
+## output
+say "minimum sum path:";
+print join ' -> ', map { $graph->[@$_[0]][@$_[1]] } @$minpath;
+say "\nsum is $minsum";
+
+## ## ## ## ## SUBS:
+
+sub find_nodes {
+    my ( $path, $point ) = @_;
+    if ( $point->[0] == $endpoint->[0] &&
+         $point->[1] == $endpoint->[1]    ) {
+        push @paths, $path;
+        return;
+    }
+    unless ($point->[0] + 1 > $endpoint->[0]) {
+        my $next_point = [$point->[0] + 1, $point->[1]];
+        my $new_path = [$path->@*, $next_point];
+        find_nodes( $new_path, $next_point)
+    }
+    unless ($point->[1] + 1 > $endpoint->[1]) {
+        my $next_point = [$point->[0], $point->[1] + 1];
+        my $new_path = [$path->@*, $next_point];
+        find_nodes( $new_path, $next_point)
+    }
+}
+## refactoring rejected for clarity: (works fine, though)
+#
+# sub find_nodes {
+#     my ( $path, $point ) = @_;
+#     if ( $point->[0] == $endpoint->[0] &&
+#          $point->[1] == $endpoint->[1]    ) {
+#         push @paths, $path;
+#         return;
+#     }
+#     for ([$point->[0] + 1, $point->[1]], [$point->[0], $point->[1] + 1]) {
+#         next if ($_->[0] > $endpoint->[0] || $_->[1] > $endpoint->[1]);
+#         my $new_path = [$path->@*, $_];
+#         find_nodes( $new_path, $_)
+#     }
+# }
diff --git a/challenge-064/colin-crain/perl/ch-2.pl b/challenge-064/colin-crain/perl/ch-2.pl
new file mode 100644
index 0000000000..833449a5ac
--- /dev/null
+++ b/challenge-064/colin-crain/perl/ch-2.pl
@@ -0,0 +1,89 @@
+#! /opt/local/bin/perl
+#
+#       c-c-combo-breaker!.pl
+#
+#         TASK #2 › WORD BREAK
+#
+#         Submitted by: Mohammad S Anwar
+#
+#             You are given a string $S and an array of words @W.
+#
+#             Write a script to find out if $S can be split into
+#             sequence of one or more words as in the given @W.
+#
+#             Print the all the words if found otherwise print 0.
+#
+#             EXAMPLE 1:
+#
+#             Input:
+#
+#             $S = "perlweeklychallenge"
+#             @W = ("weekly", "challenge", "perl")
+#
+#             Output:
+#
+#             "perl", "weekly", "challenge"
+#             EXAMPLE 2:
+#
+#             Input:
+#
+#             $S = "perlandraku"
+#             @W = ("python", "ruby", "haskell")
+#
+#             Output:
+#
+#             0 as none matching word found.
+
+#         METHOD
+#
+#             I have been called… things… for my love of regular
+#             expressions. That it wasn’t natural. Suggestions that
+#             there was something… off maybe, somewhere deep inside me.
+#             Not to discount the possibility that those people were on
+#             to something, I have persisted in the face of the critics.
+#             Refusing to be shamed, I announce it to the world. It has
+#             always been perhaps my favorite feature of the language,
+#             which is no small praise in a language with so many nice
+#             thing to say about it.
+#
+#             One cannot overstate the immense power contained in the
+#             DSL that is Perl Regular Expressions. The added features
+#             of the Raku RE engine only serve to augment that power,
+#             and every time I have an opportunity to learn about
+#             something new they’ve come up with I find myself giggling
+#             with glee. Oh you can do that now? Sweet… Larry’s vision
+#             of RE really knocked it out of the park when Perl grew to
+#             rule the web, and the PCRE library spawned from that
+#             effort still holds a very promenant position today. With
+#             Raku, they have in a sense applied a metaoperator to the
+#             the very idea of regexes, expanding the initial DSL into a
+#             complete object ecosystem known as Grammers which we can
+#             in turn use to write new DSLs.* It does take a little
+#             getting used to coming from pure Perl, but it well worth
+#             the effort.
+#
+#             This challenge, as I understand it, seems to me to be a
+#             straightforward application of regular expressions.
+#
+#           ---------------
+#             * Andrew Shitov Creating a Complier With Raku
+#             https://andrewshitov.com/creating-a-compiler-with-raku/
+#
+#
+#       2020 colin crain
+## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ##
+
+
+
+use warnings;
+use strict;
+use feature ":5.26";
+
+## ## ## ## ## MAIN:
+
+my ($string, @words) = @ARGV;
+
+my $group = join '|', @words;
+my @matched = $string =~ m/$group/g;
+
+say @matched ? "@matched" : 0;
diff --git a/challenge-064/colin-crain/raku/ch-1.p6 b/challenge-064/colin-crain/raku/ch-1.p6
new file mode 100644
index 0000000000..1c990d91bb
--- /dev/null
+++ b/challenge-064/colin-crain/raku/ch-1.p6
@@ -0,0 +1,237 @@
+#!/usr/bin/env perl6
+#
+#
+#       six_blocks_away.raku
+#
+#     TASK #1 › MINIMUM SUM PATH
+#
+#     Submitted by: Mohammad S Anwar
+#     Remelted and Refined by: RYAN THOMPSON
+#
+#         Given an m × n matrix with non-negative integers, write a
+#         script to find a path from top left to bottom right which
+#         minimizes the sum of all numbers along its path. You can only
+#         move either down or right at any point in time.
+#
+#         EXAMPLE
+#
+#         Input:
+#
+#             [ 1 2 3 ]
+#             [ 4 5 6 ]
+#             [ 7 8 9 ]
+#
+#         The minimum sum path looks like this:
+#
+#             1→2→3
+#                 ↓
+#                 6
+#                 ↓
+#                 9
+#
+#         Thus, your script could output: 21 ( 1 → 2 → 3 → 6 → 9 )
+#
+#         METHOD
+#
+#         What we have here is a matrix of values, located at the points
+#         of a multidimensional array. We are connecting adjacent points
+#         with potential pathways, but restricting travel on those
+#         pathways to only the left-to-right and top-to-bottom
+#         directions. We need a method to follow routes through this
+#         grid from point to point, tallying the values as we go. From
+#         this we can determine the correct answer.
+#
+#         The structure we have made is known as a Directed Acyclic
+#         Graph, and is useful to model many things with a series of
+#         choices towards a goal. We will start by looking at the
+#         underlying structure of a simple 3×4 array, with the points
+#         labeled, rather than the values stored there:
+#
+#                 0,0     0,1     0,2     0,3
+#
+#                 1,0     1,1     1,2     1,3
+#
+#                 2,0     2,1     2,2     2,3
+#
+#         rotating the whole thing clockwise 45° makes the underlying
+#         graph easier to see.
+#
+#                          (0,0)      <-- START
+#                          ⬋   ⬊
+#                      (1,0)   (0,1)
+#                      ⬋   ⬊   ⬋   ⬊
+#                  (2,0)   (1,1)   (0,2)
+#                      ⬊   ⬋   ⬊   ⬋   ⬊
+#                      (2,1)   (1,2)   (0,3)
+#                          ⬊   ⬋   ⬊   ⬋
+#                          (2,2)   (1,3)
+#                              ⬊   ⬋
+#                              (2,3)  <-- END
+#
+#         It’s like a tree that links back into itself, and we progress
+#         from top to bottom, traveling inexorably downward, as in a
+#         pachinko machine with only one pocket. There’s a juicy
+#         metaphor in there somewhere. In any case as can easily be seen
+#         there are many ways to proceed, but if we remain bound to the
+#         restrictions we will always end up at the same endpoint.
+#
+#         When situated at any given point, on the other hand, we are
+#         only allowed at maximum two choices in direction. If we build
+#         a recursive function that will follow each open pathway
+#         available at the current node, by the time we get to the
+#         endpoint we will have logged every possible route. Then we can
+#         take those routes, as lists of points, and do a lookup to the
+#         original values at each point to do the sums. The smallest of
+#         these is the solution. Because we are asked to find “a path”
+#         with the minimal sum, in the case of multiple equal answers
+#         any one will do.
+
+#         For the Raku solution I wanted to build some classes to
+#         compartmentalize the ideas of the graph and its vertices. It
+#         seemed a good way to separate the underlying structure from
+#         the data. I thought about serializing the input grid, with an
+#         x and y value followed by the values in a long list, but
+#         decided it distracted from the logic while providing little
+#         gain, so I hardwired in a crafted example array. There is a -v
+#         verbose command line switch though, which adds a pretty
+#         printing of the original grid and a list of the point
+#         coordinates of the vertices in the final route.
+#
+#         To start we need a simple Vertex, which holds an x and y
+#         coordinate and a gist method for display, as (x,y).
+#
+#         In the Grid class for data we have just the input grid. We
+#         have added methods to:
+#
+#             •find the endpoint and return it (as a Vertex)
+#             •find the theoretical following two Vertex points, which
+#               are composed by adding 1 to either the x value or the y
+#               value
+#             •determine whether a given Vertex is within the Grid or
+#               not
+#             •sum the values referenced along a given route, by mapping
+#               to the $.grid data and using the sum [+] metaoperator.
+#
+#         In the MAIN block we have input, output and two logic
+#         sections, to trace the paths and determine the minimum sum.
+#
+#         The find_nodes() routine first checks whether the given Vertex
+#         is the endpoint, logging the completed chain and returning if
+#         so. It then posits two potential new Vertexes, treating their
+#         creator methods as proper first-order functions in a for loop.
+#         For each of these we check to see whether its remains within
+#         the Grid, and if so we clone the route so far, extending it
+#         with that new Vertex, and recurse with the new parameters.
+#         Eventually all routes lead to the endpoint and terminate.
+#
+#         Summing a given list of vertices from outside is using the
+#         data from the Grid object to compute and so it seems a method
+#         of that object is a good place to put that logic. On the other
+#         hand, using those sums to find the minimum sum of a variety of
+#         routes isn’t particularly intrinsic to the data structure so
+#         we leave that in the MAIN block. This task is easily
+#         dispatched in Raku:
+#
+#             my $minpath = @paths.min( { $graph.sum_route( $_ ) } );
+#
+#         In this method we are providing a code block to apply to the
+#         data; it returns the minimum value of the array, as determined
+#         by those transformed values returned by the block. This design
+#         pattern is available for all of the min/max list functions, as
+#         if you ask me is very, very cool. Think of it as being
+#         analogous to handing sort() a block to determine the ordering.
+#         One thing though, because we’ve used this first-class function
+#         option, after we’ve found the minimum route we’ll still need
+#         to compute the minimum sum for that minimal route we’ve found.
+#         We could use a map and a hash and save the value, but this way
+#         is rather ridiculously easy and succinct so we’re going to go
+#         with that.
+#
+#
+#       2020 colin crain
+## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ##
+
+class Vertex {
+    has Int $.x;
+    has Int $.y;
+
+    method gist {
+        return "($.x,$.y)";
+    }
+}
+
+class Grid {
+    ## a special case of a rectangular grid DAG where we can
+    ## only progress rightwards or downwards between vertices
+    has $.grid;
+
+    method endpoint () {
+        ## lower right corner of the grid
+        return Vertex.new: :x(self.grid[0].end), :y(self.grid.end)
+    }
+
+    method down_edge ($vertex) {
+        return Vertex.new: :x($vertex.x), :y($vertex.y + 1)
+    }
+
+    method right_edge ($vertex) {
+        return Vertex.new: :x($vertex.x + 1), :y($vertex.y)
+    }
+
+    method sum_route ($route) {
+        ## given a path of vertices, return the sum of the values
+        my $sum = [+] $route.map( { $.grid[.y][.x] } );
+        return $sum;
+    }
+
+    method out_of_bounds ($vertex) {
+        ## Bool is vertex outside the grid?
+        return ($vertex.x > self.endpoint.x || $vertex.y > self.endpoint.y)
+                ?? True
+                !! False
+    }
+
+}
+
+sub MAIN (Bool :$v = False) {
+
+    ## input
+    my @grid = [1,  16, 12, 43, 48, 19],
+               [13,  7,  9, 16, 26,  8],
+               [23, 18,  6, 11, 15, 17],
+               [22, 33, 28,  5, 36, 32],
+               [38, 43,  9, 46,  3, 42],
+               [56,  4, 66, 76, 25,  2],
+               [27, 10, 58, 14, 68, 52];
+
+    my $graph = Grid.new: :grid(@grid);
+    my @paths;
+    my $startpoint = Vertex.new: :x(0), :y(0);
+    my $route = [$startpoint];
+
+    find_nodes( $route, $startpoint, $graph, @paths );
+
+    my $minpath = @paths.min( { $graph.sum_route( $_ ) } );
+    my $minsum = $graph.sum_route( $minpath );
+
+    ## output
+    say "grid:"                                 if $v;
+    (.fmt( '%3d', '  ' ).say for $graph.grid)   if $v;
+    say "minimum sum: $minsum";
+    say "route:";
+    say $minpath                                if $v;
+    $minpath.map( { $graph.grid[.y][.x] } ).join( ' ➔ ' ).say;
+}
+
+sub find_nodes ($route, $vertex, $graph, @paths) {
+
+    if $vertex eqv $graph.endpoint( ) {
+        @paths.push: $route;
+        return;
+    }
+    for ($graph.down_edge( $vertex ), $graph.right_edge( $vertex )) -> $next_vertex {
+        next if $graph.out_of_bounds( $next_vertex );
+        my $new_path = [|$route, $next_vertex];
+        find_nodes( $new_path, $next_vertex, $graph, @paths );
+    }
+}
diff --git a/challenge-064/colin-crain/raku/ch-2.p6 b/challenge-064/colin-crain/raku/ch-2.p6
new file mode 100644
index 0000000000..84b76b1eaa
--- /dev/null
+++ b/challenge-064/colin-crain/raku/ch-2.p6
@@ -0,0 +1,83 @@
+#!/usr/bin/env perl6
+#         TASK #2 › WORD BREAK
+#
+#         Submitted by: Mohammad S Anwar
+#
+#             You are given a string $S and an array of words @W.
+#
+#             Write a script to find out if $S can be split into
+#             sequence of one or more words as in the given @W.
+#
+#             Print the all the words if found otherwise print 0.
+#
+#             EXAMPLE 1:
+#
+#             Input:
+#
+#             $S = "perlweeklychallenge"
+#             @W = ("weekly", "challenge", "perl")
+#
+#             Output:
+#
+#             "perl", "weekly", "challenge"
+#             EXAMPLE 2:
+#
+#             Input:
+#
+#             $S = "perlandraku"
+#             @W = ("python", "ruby", "haskell")
+#
+#             Output:
+#
+#             0 as none matching word found.
+#
+#         METHOD
+#
+#             I have been called… things… for my love of regular
+#             expressions. That it wasn’t natural. Suggestions that
+#             there was something… off maybe, somewhere deep inside me.
+#             Not to discount the possibility that those people were on
+#             to something, I have persisted in the face of the critics.
+#             Refusing to be shamed, I announce it to the world. It has
+#             always been perhaps my favorite feature of the language,
+#             which is no small praise in a language with so many nice
+#             thing to say about it.
+#
+#             One cannot overstate the immense power contained in the
+#             DSL that is Perl Regular Expressions. The added features
+#             of the Raku RE engine only serve to augment that power,
+#             and every time I have an opportunity to learn about
+#             something new they’ve come up with I find myself giggling
+#             with glee. Oh you can do that now? Sweet… Larry’s vision
+#             of RE really knocked it out of the park when Perl grew to
+#             rule the web, and the PCRE library spawned from that
+#             effort still holds a very promenant position today. With
+#             Raku, they have in a sense applied a metaoperator to the
+#             the very idea of regexes, expanding the initial DSL into a
+#             complete object ecosystem known as Grammers which we can
+#             in turn use to write new DSLs.* It does take a little
+#             getting used to coming from pure Perl, but it well worth
+#             the effort.
+#
+#             This challenge, as I understand it, seems to me to be a
+#             straightforward application of regular expressions.
+#
+#           ---------------
+#             * Andrew Shitov Creating a Complier With Raku
+#             https://andrewshitov.com/creating-a-compiler-with-raku/
+
+sub MAIN(Str:D $string, *@words) {
+    my $group = @words.join(' | ');
+    my $matches = $string ~~ m:g/ <$group> /;
+    $matches.list.elems ?? (.Str.say for $matches.list)
+                        !!   say '0';
+
+#    say "two:";
+#    $matches = $string ~~ m:g/
+#                             | weekly
+#                             | perl
+#                             | challenge
+#                              /;
+#    .Str.say for $matches.list;
+
+}
diff --git a/stats/pwc-current.json b/stats/pwc-current.json
index c1dfc0a2a7..429afef308 100644
--- a/stats/pwc-current.json
+++ b/stats/pwc-current.json
@@ -1,13 +1,11 @@
 {
-   "tooltip" : {
-      "headerFormat" : "<span style='font-size:11px'>{series.name}</span><br/>",
-      "pointFormat" : "<span style='color:{point.color}'>{point.name}</span>: <b>{point.y:f}</b><br/>",
-      "followPointer" : 1
+   "legend" : {
+      "enabled" : 0
    },
    "series" : [
       {
-         "name" : "Perl Weekly Challenge - 064",
          "colorByPoint" : 1,
+         "name" : "Perl Weekly Challenge - 064",
          "data" : [
             {
                "y" : 3,
@@ -20,103 +18,103 @@
                "y" : 2
             },
             {
-               "y" : 3,
                "name" : "Bartosz Jarzyna",
-               "drilldown" : "Bartosz Jarzyna"
+               "drilldown" : "Bartosz Jarzyna",
+               "y" : 3
             },
             {
-               "drilldown" : "Cheok-Yin Fung",
                "name" : "Cheok-Yin Fung",
+               "drilldown" : "Cheok-Yin Fung",
                "y" : 3
             },
             {
                "drilldown" : "Colin Crain",
                "name" : "Colin Crain",
-               "y" : 1
+               "y" : 5
             },
             {
+               "drilldown" : "Dave Jacoby",
                "name" : "Dave Jacoby",
-               "y" : 3,
-               "drilldown" : "Dave Jacoby"
+               "y" : 3
             },
             {
-               "y" : 2,
+               "drilldown" : "Duncan C. White",
                "name" : "Duncan C. White",
-               "drilldown" : "Duncan C. White"
+               "y" : 2
             },
             {
-               "drilldown" : "E. Choroba",
                "name" : "E. Choroba",
+               "drilldown" : "E. Choroba",
                "y" : 2
             },
             {
                "name" : "Javier Luque",
-               "y" : 5,
-               "drilldown" : "Javier Luque"
+               "drilldown" : "Javier Luque",
+               "y" : 5
             },
             {
+               "y" : 2,
                "drilldown" : "Jorg Sommrey",
-               "name" : "Jorg Sommrey",
-               "y" : 2
+               "name" : "Jorg Sommrey"
             },
             {
-               "drilldown" : "Laurent Rosenfeld",
                "name" : "Laurent Rosenfeld",
+               "drilldown" : "Laurent Rosenfeld",
                "y" : 5
             },
             {
-               "name" : "Leo Manfredi",
                "y" : 1,
-               "drilldown" : "Leo Manfredi"
+               "drilldown" : "Leo Manfredi",
+               "name" : "Leo Manfredi"
             },
             {
+               "name" : "Luca Ferrari",
                "drilldown" : "Luca Ferrari",
-               "y" : 4,
-               "name" : "Luca Ferrari"
+               "y" : 4
             },
             {
-               "drilldown" : "Mark Anderson",
+               "y" : 2,
                "name" : "Mark Anderson",
-               "y" : 2
+               "drilldown" : "Mark Anderson"
             },
             {
+               "y" : 4,
                "drilldown" : "Mohammad S Anwar",
-               "name" : "Mohammad S Anwar",
-               "y" : 4
+               "name" : "Mohammad S Anwar"
             },
             {
-               "y" : 2,
                "name" : "Niels van Dijke",
-               "drilldown" : "Niels van Dijke"
+               "drilldown" : "Niels van Dijke",
+               "y" : 2
             },
             {
                "drilldown" : "Richard Hainsworth",
-               "y" : 1,
-               "name" : "Richard Hainsworth"
+               "name" : "Richard Hainsworth",
+               "y" : 1
             },
             {
+               "drilldown" : "Richard Park",
                "name" : "Richard Park",
-               "y" : 1,
-               "drilldown" : "Richard Park"
+               "y" : 1
             },
             {
                "name" : "Roger Bell_West",
-               "y" : 5,
-               "drilldown" : "Roger Bell_West"
+               "drilldown" : "Roger Bell_West",
+               "y" : 5
             },
             {
-               "name" : "Sangeet Kar",
                "y" : 2,
-               "drilldown" : "Sangeet Kar"
+               "drilldown" : "Sangeet Kar",
+               "name" : "Sangeet Kar"
             },
             {
-               "y" : 2,
                "name" : "Simon Proctor",
-               "drilldown" : "Simon Proctor"
+               "drilldown" : "Simon Proctor",
+               "y" : 2
             },
             {
-               "name" : "Ulrich Rieke",
                "y" : 2,
+               "name" : "Ulrich Rieke",
                "drilldown" : "Ulrich Rieke"
             },
             {
@@ -130,6 +128,8 @@
    "drilldown" : {
       "series" : [
          {
+            "name" : "Arne Sommer",
+            "id" : "Arne Sommer",
             "data" : [
                [
                   "Raku",
@@ -139,9 +139,7 @@
                   "Blog",
                   1
                ]
-            ],
-            "id" : "Arne Sommer",
-            "name" : "Arne Sommer"
+            ]
          },
          {
             "data" : [
@@ -158,8 +156,6 @@
             "id" : "Athanasius"
          },
          {
-            "id" : "Bartosz Jarzyna",
-            "name" : "Bartosz Jarzyna",
             "data" : [
                [
                   "Perl",
@@ -169,7 +165,9 @@
                   "Blog",
                   1
                ]
-            ]
+            ],
+            "name" : "Bartosz Jarzyna",
+            "id" : "Bartosz Jarzyna"
          },
          {
             "name" : "Cheok-Yin Fung",
@@ -188,6 +186,14 @@
          {
             "data" : [
                [
+                  "Perl",
+                  2
+               ],
+               [
+                  "Raku",
+                  2
+               ],
+               [
                   "Blog",
                   1
                ]
@@ -196,6 +202,8 @@
             "name" : "Colin Crain"
          },
          {
+            "name" : "Dave Jacoby",
+            "id" : "Dave Jacoby",
             "data" : [
                [
                   "Perl",
@@ -205,9 +213,7 @@
                   "Blog",
                   1
                ]
-            ],
-            "id" : "Dave Jacoby",
-            "name" : "Dave Jacoby"
+            ]
          },
          {
             "data" : [
@@ -216,8 +222,8 @@
                   2
                ]
             ],
-            "name" : "Duncan C. White",
-            "id" : "Duncan C. White"
+            "id" : "Duncan C. White",
+            "name" : "Duncan C. White"
          },
          {
             "data" : [
@@ -276,14 +282,14 @@
             "name" : "Laurent Rosenfeld"
          },
          {
+            "name" : "Leo Manfredi",
+            "id" : "Leo Manfredi",
             "data" : [
                [
                   "Perl",
                   1
                ]
-            ],
-            "name" : "Leo Manfredi",
-            "id" : "Leo Manfredi"
+            ]
          },
          {
             "name" : "Luca Ferrari",
@@ -306,12 +312,12 @@
                   2
                ]
             ],
-            "id" : "Mark Anderson",
-            "name" : "Mark Anderson"
+            "name" : "Mark Anderson",
+            "id" : "Mark Anderson"
          },
          {
-            "id" : "Mohammad S Anwar",
             "name" : "Mohammad S Anwar",
+            "id" : "Mohammad S Anwar",
             "data" : [
                [
                   "Perl",
@@ -338,8 +344,8 @@
             ]
          },
          {
-            "id" : "Richard Hainsworth",
             "name" : "Richard Hainsworth",
+            "id" : "Richard Hainsworth",
             "data" : [
                [
                   "Raku",
@@ -348,16 +354,18 @@
             ]
          },
          {
+            "name" : "Richard Park",
+            "id" : "Richard Park",
             "data" : [
                [
                   "Blog",
                   1
                ]
-            ],
-            "id" : "Richard Park",
-            "name" : "Richard Park"
+            ]
          },
          {
+            "id" : "Roger Bell_West",
+            "name" : "Roger Bell_West",
             "data" : [
                [
                   "Perl",
@@ -371,23 +379,21 @@