diff options
| -rw-r--r-- | challenge-056/colin-crain/perl/ch-1.pl | 92 | ||||
| -rw-r--r-- | challenge-056/colin-crain/perl/ch-2.pl | 235 | ||||
| -rw-r--r-- | challenge-056/colin-crain/raku/ch-1.p6 | 79 | ||||
| -rw-r--r-- | challenge-056/colin-crain/raku/ch-2.p6 | 224 | ||||
| -rw-r--r-- | stats/pwc-current.json | 249 | ||||
| -rw-r--r-- | stats/pwc-language-breakdown-summary.json | 72 | ||||
| -rw-r--r-- | stats/pwc-language-breakdown.json | 406 | ||||
| -rw-r--r-- | stats/pwc-leaders.json | 734 | ||||
| -rw-r--r-- | stats/pwc-summary-1-30.json | 100 | ||||
| -rw-r--r-- | stats/pwc-summary-121-150.json | 96 | ||||
| -rw-r--r-- | stats/pwc-summary-151-180.json | 38 | ||||
| -rw-r--r-- | stats/pwc-summary-31-60.json | 106 | ||||
| -rw-r--r-- | stats/pwc-summary-61-90.json | 44 | ||||
| -rw-r--r-- | stats/pwc-summary-91-120.json | 112 | ||||
| -rw-r--r-- | stats/pwc-summary.json | 354 |
15 files changed, 1795 insertions, 1146 deletions
diff --git a/challenge-056/colin-crain/perl/ch-1.pl b/challenge-056/colin-crain/perl/ch-1.pl new file mode 100644 index 0000000000..4be9872274 --- /dev/null +++ b/challenge-056/colin-crain/perl/ch-1.pl @@ -0,0 +1,92 @@ +#! /opt/local/bin/perl +# +# diffickult.pl +# +# PWC 56 - TASK #1 +# Diff-K +# You are given an array @N of positive integers (sorted) and +# another non negative integer k. +# +# Write a script to find if there exists 2 indices i and j such that +# A[i] - A[j] = k and i != j. +# +# It should print the pairs of indices, if any such pairs exist. +# +# Example: +# +# @N = (2, 7, 9) +# $k = 2 +# Output : 2,1 +# +# method: +# Given that +# ∀ n: +# A[n] > 0 +# A[n+1] >= A[n] +# k >= 0 +# +# And the required truths +# +# A[i] - A[j] = k +# i != j +# +# To be true, A[i] > k +# A[j] <= A[i] +# +# which allows us to limit the search space somewhat for a brute +# force attack on the problem. In fact, because A[j] = A[i] - k, we +# only need to iterate over the possible i range and then can use a +# hash lookup for the second part of the search. Note that we can't +# outright assume that j < i because there exists the case where +# A[j] = A[i] and j > i. In general, because we allow duplicate +# values, there can exist multiple j solutions for a given i; we use +# use a cascading grep filter to produce an array of results for +# each i in the loop. +# +# +# 2020 colin crain +## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ## + + + +use warnings; +use strict; +use feature ":5.26"; + +## ## ## ## ## MAIN: + +my $k = shift @ARGV // 24; + +my @input; +push @input, int(rand(50)) for (1..20); +@input = sort { $a <=> $b } @input; + +my @indices = (0..scalar @input - 1); +my @output; + +my @is = grep { $input[$_] > $k } @indices; + +for my $i ( @is ) { + ## for each $i we can do a lookup and see whether any values $input[$j] = $input[$i] - $k exist + ## we need to make allowances that adjacent multiple indices may hold equal values + my @js = grep { $input[$_] <= $input[$i] ## A[j] <= A[i] + && $input[$_] == $input[$i] - $k ## A[j] = A[i] - k + && $_ != $i } @indices; ## i != j + for my $j ( @js ) { + push @output, [ $i, $j ]; + } +} + +## output report +## +say "input\n-----\n"; +say ' array: ', join ', ', @input; + +say "target: $k"; +say ''; + +say "solutions\n---------\n"; +for (@output) { + my ( $i, $j) = $_->@*; + printf "i = %2d, j = %-2d --> %2d - %-2d = %d\n", $i, $j, $input[$i], $input[$j], $k; +} diff --git a/challenge-056/colin-crain/perl/ch-2.pl b/challenge-056/colin-crain/perl/ch-2.pl new file mode 100644 index 0000000000..92ca5211f9 --- /dev/null +++ b/challenge-056/colin-crain/perl/ch-2.pl @@ -0,0 +1,235 @@ +#! /opt/local/bin/perl +# +# 56_2_pathsum.pl +# +# PWC 56 - TASK #2 +# Path Sum +# You are given a binary tree and a sum, write a script to find if +# the tree has a path such that adding up all the values along the +# path equals the given sum. Only complete paths (from root to leaf +# node) may be considered for a sum. +# +# Example +# Given the below binary tree and sum = 22, +# +# 5 +# / \ +# 4 8 +# / / \ +# 11 13 9 +# / \ \ +# 7 2 1 +# +# For the given binary tree, the partial path sum 5 → 8 → 9 = 22 is not valid. +# +# The script should return the path 5 → 4 → 11 → 2 whose sum is 22. +# +# method: +# +# The challenge is on the surface pretty straightforward; the binary +# tree data structure was designed to be transversed, so a recursive +# routine that walks the paths until it finds a terminator node +# would do the trick. Once the path is found, we can compare the sum +# and if it fits log it. +# +# The problem rears its head here with the phrase “given a binary +# tree and a sum”. What does that mean? Not what is a binary tree, +# of course. But what does it mean here? We are given an ascii +# drawing of an example tree. Although I spent more time than I’d +# like to admit considering directly parsing this format it’s +# ill-defined itself and a totally useless effort. Not that that +# ever stopped me before, mind you; I still may get to it. For the +# greater good. For the ASCII art. Maybe a reader and writer. Sure +# thing, get right on it... +# +# But how then, should we encode our tree? In Set theory, each node +# of a binary tree can be defined as {L, S, R} for the Left child, +# Singleton value, and Right child sets. The value is a Singleton +# set, the others binary tree sets themselves or empty sets.* The +# example tree could thusly be encoded: +# +# {{{∅,7,∅},11,{∅,2,∅}},4,∅},5,{{∅,13,∅},8,{∅,9,{∅,1,∅}}} +# +# If I was to build this structure in perl for some practical use, a +# natural way would be to define a tree node object and add in nodes +# as we aquire the data. This could be done with a blessing a proper +# Node objects, in a package, but at its heart each node is a hash +# with three keys: {left}, {right} and {value}, to hold the value +# and references (or undef) for the left and right children . +# +# The example would then look like this: +# +# $data = { value => 5, +# left => { value => 4, +# left => { value => 11, +# left => { value => 7, +# left => undef, +# right => undef +# } +# right => { value => 2, +# left => undef, +# right => undef +# } +# } +# right => undef +# } +# right => { value => 8, +# left => { value => 13, +# left => undef, +# right => undef +# } +# right => { value => 9, +# left => undef +# right => { value => 1, +# left => undef, +# right => undef +# } +# +# But this isn't a very practical way to give anything to anybody, +# is it? Once loaded it provides the functionality, but it's hardly +# command-line friendly. +# +# A third way of implimenting this structure is to imagine every +# node in every rank as complete, assigning the values of the nodes +# into fixed indices of an array; starting with the rank 0 node at +# index 0, proceeding with the next level into indices 1 and 2, +# etcetera, in a level-first traversal. A given index for a null set +# child is filled with a null value, undef for Perl, and its +# theoretical children with null values as well, thus maintaining +# synchronization with the level structure no matter the shape of +# the actual tree. Each child is located relative to its parent, +# index n, at indices 2n + 1 and 2n + 2, so traversing a given path +# is a matter of following from parent to child, recusively, +# as long as there is another defined value to jump to. +# +# In this manner the example tree can be encoded, in perl, as +# +# @tree = (5, 4, 8, 11, undef, 13, 9, 7, 2, undef, undef, undef, undef, undef, 1) +# +# Notice there's a fair amount of wasted space in this encoding, as +# every node must be given an index, whether it's populated or not, +# or even whether its parent exists or not. It does provide a simple +# relationship between parent and child nodes that can be easily +# visualized for smaller trees. Due to its fairly compact serialized +# nature and (mostly) human readable form we will use this method to +# encode our tree. +# +# Traversing all possible paths in the tree using a recursive +# routine as described is executed in sum_path(), below. Originally +# I allowed passing in a target and tree array from the commandline, +# but found that even though the serialized tree format is somewhat +# human-readable, writing an arbitrary new tree to demonstrate the +# behavior proved troublesome, to say the least. So alternately, I +# decided it was easier to make functions that generates random +# trees and median targets, and used those for input data instead. +# Tweaking the algorithm to give a semi-random tree that also was a +# good demonstration example proved more complicated than I first +# expected, but after a little work I think we're there. The odds of +# any given node as being a terminator increase as the level, or +# rank, increases. A high point was the little function that +# reverse-engineers the construction algorithm to produce the rank +# level from an input index. +# +# In the output, the input tree is listed, along with the target. +# Because I thought it was interesting, all traversals are noted as +# they are found, with their sums. At the end, the data asked for, +# those paths that sum to the target, are listed. +# +# +# -------------------- +# * Discrete Mathematics : Proofs, Structures and Applications, +# Third Edition (Garnier, Rowan, Taylor, John) 2009 +# +# "A binary tree comprises a triple of sets (L, S, R) where L and R +# are binary trees (or are empty) and S is a singleton set. The +# single element of S is the root, and L and R are called, +# respectively, the left and right subtrees of the root." +# +# +# +# 2020 colin crain +## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ## + + + +use warnings; +use strict; +use feature ":5.26"; + +## ## ## ## ## MAIN: +our $depth = 4; +our @tree = generate_tree($depth); +say "tree: ", join ', ', map {defined $_? $_ : "undef"} @tree; + +our $target = shift // int (($depth+1) * 4.5) ; +say "target: $target"; +say ""; +say "paths found:\n"; + +my $index = 0; +my $working = []; +our $paths = []; +sum_path ($index, $working); + +say "\nsolutions:\n"; +if (scalar $paths->@* == 0) { + say '(none)'; +} +else { + say join ' -> ', $_->@* for $paths->@*; +} + + +## ## ## ## ## SUBS: + +sub sum_path { +## walks the tree and computes complete the path sum + my ($index, $working) = @_; + my @working = $working->@*; + push @working, $tree[$index]; + + ## if we are at a terminal node check the sum and return + if ( ! defined $tree[$index * 2 + 1] && ! defined $tree[$index * 2 + 2] ) { + my $sum; + $sum += $_ for @working; + push $paths->@*, \@working if ($sum == $target); + + print (join ' -> ', map {defined $_ ? $_ : "undef"} @working); + say " = $sum"; + + return; + } + + ## walk to next nodes if present + for my $child ( $index * 2 + 1, $index * 2 + 2 ) { + sum_path( $child, \@working ) if defined $tree[$child]; + } +} + +sub generate_tree { +## automatically generates a binary tree of rank n. +## odds of a node being a terminator increase as the rank of the node increases +## which avoids trees with branches that quickly end + my $depth = shift; + my @tree; + $tree[0] = int(rand(10)); ## always defined + my $nodes = (2**($depth+1)) - 2; ## 0-based count to last node, start of next rank - 1 + + for my $index ( 0..$nodes ) { + my $rank = get_rank($index); ## determines the rank of a node from its index + my $parent = int(($index-1)/2); + if ( defined $tree[$parent]) { + ## the odds of the switch being 0 increase as the rank progresses + ## the start node, rank 0, will always generate the next rank + my $switch = $index > 0 ? int(rand ($nodes - 2 ** $rank)/2) : 1 ; + @tree[$index] = $switch ? int(rand(10)) : undef; + } + } + return @tree; +} + +sub get_rank { +## determines the rank of a node from its index + my $n = shift; + return $n > 0 ? int log($n+1)/log(2) : 0; +} diff --git a/challenge-056/colin-crain/raku/ch-1.p6 b/challenge-056/colin-crain/raku/ch-1.p6 new file mode 100644 index 0000000000..54ef849361 --- /dev/null +++ b/challenge-056/colin-crain/raku/ch-1.p6 @@ -0,0 +1,79 @@ +use v6.d; + +# +# 56-1-diffickult.raku +# +# PWC 56 - TASK #1 +# Diff-K +# You are given an array @N of positive integers (sorted) and +# another non negative integer k. +# +# Write a script to find if there exists 2 indices i and j such that +# A[i] - A[j] = k and i != j. +# +# It should print the pairs of indices, if any such pairs exist. +# +# Example: +# +# @N = (2, 7, 9) +# $k = 2 +# Output : 2,1 +# +# method: +# Given that +# ∀ n: +# A[n] > 0 +# A[n+1] >= A[n] +# k >= 0 +# +# And the required truths +# +# A[i] - A[j] = k +# i != j +# +# To be true, A[i] > k +# A[j] <= A[i] +# +# which allows us to limit the search space somewhat for a brute +# force attack on the problem. In fact, because A[j] = A[i] - k, we +# only need to iterate over the possible i range and then can use a +# hash lookup for the second part of the search. Note that we can't +# outright assume that j < i because there exists the case where +# A[j] = A[i] and j > i. In general, because we allow duplicate +# values, there can exist multiple j solutions for a given i; we use +# use a cascading grep filter to produce an array of results for +# each i in the loop. +# +# +# +# 2020 colin crain +## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ## + +sub MAIN (Int:D $k = 24, *@N) { + + my @input = @N.elems > 0 ?? @N !! (^20).map({ (1..50).pick }).sort({ $^a <=> $^b }); + my @indices = (^@input.elems); + my @output; + + my @is = @indices.grep({ @input[$_] > $k }); + + ## for each $i we can do a lookup and see whether any values $input[$j] = $input[$i] - $k exist + for @is -> $i { + my @js = @indices.grep({ @input[$_] <= @input[$i] ## A[j] <= A[i] + && @input[$_] == @input[$i] - $k }); ## A[i] - A[j] = k + && $_ != $i ## i != j + for @js -> $j { @output.push: [ $i, $j ] } + } + + ## output report section + say "input\n-----\n"; + say ' array: ' ~ @input.join: ', ',; + + say "target: $k"; + say ''; + + say "solutions\n---------\n"; + + my $format = "i = %2d, j = %-2d --> %2d - %-2d = %d\n"; + printf $format, $_[0], $_[1], @input[$_[0]], @input[$_[1]], $k for @output; +} diff --git a/challenge-056/colin-crain/raku/ch-2.p6 b/challenge-056/colin-crain/raku/ch-2.p6 new file mode 100644 index 0000000000..055cd2ddd3 --- /dev/null +++ b/challenge-056/colin-crain/raku/ch-2.p6 @@ -0,0 +1,224 @@ +use v6.d; + +# +# 56-2-pathsum.raku +# +# PWC 56 - TASK #2 +# Path Sum +# You are given a binary tree and a sum, write a script to find if +# the tree has a path such that adding up all the values along the +# path equals the given sum. Only complete paths (from root to leaf +# node) may be considered for a sum. +# +# Example +# Given the below binary tree and sum = 22, +# +# 5 +# / \ +# 4 8 +# / / \ +# 11 13 9 +# / \ \ +# 7 2 1 +# +# For the given binary tree, the partial path sum 5 → 8 → 9 = 22 is +# not valid. +# +# The script should return the path 5 → 4 → 11 → 2 whose sum is 22. +# +# method: +# +# The challenge is on the surface pretty straightforward; the binary +# tree data structure was designed to be transversed, so a recursive +# routine that walks the paths until it finds a terminator node +# would do the trick. Once the path is found, we can compare the sum +# and if it fits log it. +# +# The problem rears its head here with the phrase “given a binary +# tree and a sum”. What does that mean? Not what is a binary tree, +# of course. But what does it mean here? We are given an ascii +# drawing of an example tree. Although I spent more time than I’d +# like to admit considering directly parsing this format it’s +# ill-defined itself and a totally useless effort. Not that that +# ever stopped me before, mind you; I still may get to it. For the +# greater good. For the ASCII art. Maybe a reader and writer. Sure +# thing, get right on it... +# +# But how then, should we encode our tree? In Set theory, each node +# of a binary tree can be defined as {L, S, R} for the Left child, +# Singleton value, and Right child sets. The value is a Singleton +# set, the others binary tree sets themselves or empty sets.* The +# example tree could thusly be encoded: +# +# {{{∅,7,∅},11,{∅,2,∅}},4,∅},5,{{∅,13,∅},8,{∅,9,{∅,1,∅}}} +# +# If I was to build this structure for some practical use, a +# natural way would be to define a tree node class and add in nodes +# as we aquire the data. This could be done with a proper +# Class, but at its heart each node is a hash +# with three keys: {left}, {right} and {value}, to hold the value +# and references (or undef) for the left and right children . +# +# Using a Node class, the example might then look like this: +# +# class Node { +# has Node $.left; +# has Node $.right; +# has $.value; +# +# my Node $tree .= new( value => 5, +# left => Node.new( value => 4, +# left => Node.new( value => 11, +# left => Node.new(value => 7), +# right => Node.new(value => 2) +# ) +# ), +# right => Node.new( value => 8, +# left => Node.new( value => 13), +# right => Node.new( value => 9 +# right => Node.new( value => 1) +# ) +# ) +# ); +# +# That's untested, but I'm pretty sure that's right. But this isn't +# a very practical way to give anything to anybody, is it? Once +# loaded it provides the functionality (maybe add some methods), but +# it's hardly command-line friendly. +# +# A third way of implimenting this structure is to imagine every +# node in every rank as complete, assigning the values of the nodes +# into fixed indices of an array; starting with the rank 0 node at +# index 0, proceeding with the next level into indices 1 and 2, +# etcetera, we give every node an index in a level-first traversal. +# A given index for a null set child is filled with a null value, +# Nil in this case, and its theoretical children down the line get +# null values as well, thus maintaining synchronization with the +# level structure no matter the shape of the actual tree. Each child +# is located relative to its parent, index n, at indices 2n + 1 and +# 2n + 2, so traversing a given path is a matter of following from +# parent to child, recusively, as long as there is another defined +# value to jump to. +# +# In this manner the example tree can be encoded, in raku, as +# +# @tree = 5, 4, 8, 11, Nil, 13, 9, 7, 2, Nil, Nil, Nil, Nil, Nil, 1 +# +# Notice there's a fair amount of wasted space in this encoding, as +# every node must be given an index, whether it's populated or not, +# or even whether its parent exists or not. It does provide a simple +# relationship between parent and child nodes that can be easily +# visualized for smaller trees. Due to its fairly compact serialized +# nature and (mostly) human readable form we will use this method to +# encode our tree. +# +# Traversing all possible paths in the tree using a recursive +# routine as described is executed in sum_path(), below. Originally +# I allowed passing in a target and tree array from the commandline, +# but found that even though the serialized tree format is somewhat +# human-readable, writing an arbitrary new tree to demonstrate the +# behavior proved troublesome, to say the least. So alternately, I +# decided it was easier to make functions that generates random +# trees and median targets, and used those for input data instead. +# Tweaking the algorithm to give a semi-random tree that also +# provided a good demonstration example proved more complicated than +# I first expected, but after a little work tuning the odds of a +# node spawning children, I think we're there. In execution, the +# odds of any given node as being a terminator increase as the +# level, or rank, increases; degenerate trees just aren't very +# interesting. A high point was the little function, get_rank($n), +# that reverse-engineers the construction algorithm to produce the +# rank level from an input index, rather than keeping a count +# somehow. +# +# In the output, the input tree is listed, along with the target. +# Because I thought it was interesting, all traversals are noted as +# they are found, with their sums. At the end, the data asked for, +# those paths that sum to the target, are listed. +# +# +# -------------------- +# * Discrete Mathematics : Proofs, Structures and Applications, +# Third Edition (Garnier, Rowan, Taylor, John) 2009 +# +# "A binary tree comprises a triple of sets (L, S, R) where L and R +# are binary trees (or are empty) and S is a singleton set. The +# single element of S is the root, and L and R are called, +# respectively, the left and right subtrees of the root." +# +# +# +# 2020 colin crain +## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ## + +sub MAIN ($depth = 3) { + + my @tree = generate_tree($depth); + + my $tstr = @tree.map({$_.defined ?? $_ !! "undef"}).join(', '); + my $target = (($depth+1) * 4.5).Int; + + say qq:to/__END__/; + tree: $tstr + target: $target + + paths found: + __END__ + + my $index = 0; + my @working; + my @paths; + sum_path(@tree, $target, $index, @working, @paths); + + say "\nsolutions:\n"; + @paths.elems == 0 ?? say '(none)' !! ($_.join(' -> ').say for @paths); +} + +## ## ## ## ## SUBS: + +sub sum_path (@tree, $target, $index, @prev_working, @paths) { +## walks the tree and computes complete the path sum + my @working = @prev_working; + @working.append: @tree[$index]; + + ## if we are at a terminal node check the sum and return + if ( ! @tree[$index * 2 + 1].defined && ! @tree[$index * 2 + 2].defined ) { + my $sum = [+] @working; + @paths.push: @working if $sum == $target; + + say @working.join(' + ') ~ " = $sum"; + + return; + } + + for ( $index * 2 + 1, $index * 2 + 2 ) -> $child { + sum_path( @tree, $target, $child, @working, @paths ) if @tree[$child].defined; + } +} + +sub generate_tree ($depth){ +## automatically generates a random binary tree of rank n, with node values 1..10 +## odds of a node being a terminator increase as the rank of the node increases +## which avoids trees with branches that quickly end + my @tree; + @tree[0] = (^10).pick; ## always defined + my $nodes = (2**($depth+1)) - 2; ## 0-based count to last node, (start of next rank - 1) + + for ( 0..$nodes ) -> $index { + my $rank = get_rank($index); + my $parent = (($index-1)/2).Int; + if @tree[$parent].defined { + ## the odds of the switch being 0 increase as the rank progresses + ## the first node will always generate the next rank + my $switch = $index > 0 ?? (^($nodes - 2 ** $rank)/2).pick.Int !! 1; + @tree[$index] = $switch ?? (^10).pick !! Nil; + } + } + return @tree; +} + +sub get_rank ($n) { +## determines the rank of a node from its index + return $n > 0 ?? (log($n+1)/log(2)).Int !! 0; +} + diff --git a/stats/pwc-current.json b/stats/pwc-current.json index 23b2c6d588..9ecaf69e01 100644 --- a/stats/pwc-current.json +++ b/stats/pwc-current.json @@ -1,18 +1,21 @@ { + "tooltip" : { + "followPointer" : 1, + "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/>" + }, "series" : [ { - "colorByPoint" : 1, - "name" : "Perl Weekly Challenge - 056", "data" : [ { - "name" : "Alicia Bielsa", "y" : 2, - "drilldown" : "Alicia Bielsa" + "drilldown" : "Alicia Bielsa", + "name" : "Alicia Bielsa" }, { + "y" : 2, "drilldown" : "Andrezgz", - "name" : "Andrezgz", - "y" : 2 + "name" : "Andrezgz" }, { "drilldown" : "Arne Sommer", @@ -20,53 +23,58 @@ "y" : 3 }, { + "name" : "Athanasius", "drilldown" : "Athanasius", - "y" : 3, - "name" : "Athanasius" + "y" : 3 }, { - "drilldown" : "Cheok-Yin Fung", "name" : "Cheok-Yin Fung", + "drilldown" : "Cheok-Yin Fung", "y" : 1 }, { + "y" : 4, + "drilldown" : "Colin Crain", + "name" : "Colin Crain" + }, + { "y" : 1, "name" : "Cristina Heredia", "drilldown" : "Cristina Heredia" }, { - "name" : "Dave Jacoby", "y" : 3, + "name" : "Dave Jacoby", "drilldown" : "Dave Jacoby" }, { - "name" : "Duncan C. White", "y" : 2, + "name" : "Duncan C. White", "drilldown" : "Duncan C. White" }, { - "drilldown" : "E. Choroba", "y" : 2, - "name" : "E. Choroba" + "name" : "E. Choroba", + "drilldown" : "E. Choroba" }, { - "drilldown" : "Jared Martin", + "y" : 3, "name" : "Jared Martin", - "y" : 3 + "drilldown" : "Jared Martin" }, { + "name" : "Javier Luque", "drilldown" : "Javier Luque", - "y" : 5, - "name" : "Javier Luque" + "y" : 5 }, { - "drilldown" : "Kevin Colyer", + "y" : 2, "name" : "Kevin Colyer", - "y" : 2 + "drilldown" : "Kevin Colyer" }, { - "name" : "Laurent Rosenfeld", "y" : 5, + "name" : "Laurent Rosenfeld", "drilldown" : "Laurent Rosenfeld" }, { @@ -81,17 +89,17 @@ }, { "y" : 4, - "name" : "Luca Ferrari", - "drilldown" : "Luca Ferrari" + "drilldown" : "Luca Ferrari", + "name" : "Luca Ferrari" }, { - "y" : 4, "name" : "Mark Anderson", - "drilldown" : "Mark Anderson" + "drilldown" : "Mark Anderson", + "y" : 4 }, { - "name" : "Markus Holzer", "y" : 2, + "name" : "Markus Holzer", "drilldown" : "Markus Holzer" }, { @@ -100,51 +108,70 @@ "drilldown" : "Matthew Somerville" }, { - "drilldown" : "Mohammad S Anwar", + "y" : 4, "name" : "Mohammad S Anwar", - "y" : 4 + "drilldown" : "Mohammad S Anwar" }, { - "y" : 2, "name" : "Noud Aldenhoven", - "drilldown" : "Noud Aldenhoven" + "drilldown" : "Noud Aldenhoven", + "y" : 2 }, { "name" : "Roger Bell West", - "y" : 3, - "drilldown" : "Roger Bell West" + "drilldown" : "Roger Bell West", + "y" : 3 }, { + "drilldown" : "Shahed Nooshmand", "name" : "Shahed Nooshmand", - "y" : 3, - "drilldown" : "Shahed Nooshmand" + "y" : 3 }, { + "name" : "Simon Proctor", "drilldown" : "Simon Proctor", - "y" : 2, - "name" : "Simon Proctor" + "y" : 2 }, { - "drilldown" : "User Person", "name" : "User Person", + "drilldown" : "User Person", "y" : 2 }, { - "drilldown" : "Wanderdoc", + "y" : 2, "name" : "Wanderdoc", - "y" : 2 + "drilldown" : "Wanderdoc" }, { + "drilldown" : "Yet Ebreo", "name" : "Yet Ebreo", - "y" : 2, - "drilldown" : "Yet Ebreo" + "y" : 2 } - ] + ], + "name" : "Perl Weekly Challenge - 056", + "colorByPoint" : 1 } ], + "yAxis" : { + "title" : { + "text" : "Total Solutions" + } + }, + "xAxis" : { + "type" : "category" + }, "title" : { "text" : "Perl Weekly Challenge - 056" }, + "plotOptions" : { + "series" : { + "borderWidth" : 0, + "dataLabels" : { + "enabled" : 1, + "format" : "{point.y}" + } + } + }, "legend" : { "enabled" : 0 }, @@ -157,12 +184,12 @@ 2 ] ], - "name" : "Alicia Bielsa", - "id" : "Alicia Bielsa" |