From a49fd6757614fffec4d45a2b8962b40aa406fad8 Mon Sep 17 00:00:00 2001
From: Abigail <abigail@abigail.be>
Date: Mon, 9 Aug 2021 14:27:18 +0200
Subject: README

---
 challenge-125/abigail/README.md | 95 ++++++++++++++++++++++++-----------------
 1 file changed, 55 insertions(+), 40 deletions(-)

diff --git a/challenge-125/abigail/README.md b/challenge-125/abigail/README.md
index c116d92523..155bfc8302 100644
--- a/challenge-125/abigail/README.md
+++ b/challenge-125/abigail/README.md
@@ -1,27 +1,31 @@
 # Solutions by Abigail
-## [Happy Women Day][task1]
+## [Pythagorean Triples][task1]
 
-> Write a script to print the Venus Symbol, international gender symbol
-> for women. Please feel free to use any character.
+> You are given a positive integer `$N`.
+>
+> Write a script to print all Pythagorean Triples containing $N as
+> a member. Print `-1` if it can't be a member of any.
+>
+> Triples with the same set of elements are considered the same,
+> i.e. if your script has already printed `(3, 4, 5)`, `(4, 3, 5)` should
+> not be printed.
+>
+> > The famous Pythagorean theorem states that in a right angle
+> > triangle, the length of the two shorter sides and the length of the
+> > longest side are related by `a^2+b^2 = c^2`.
 
+### Example
 ~~~~
-    ^^^^^
-   ^     ^
-  ^       ^
- ^         ^
- ^         ^
- ^         ^
- ^         ^
- ^         ^
-  ^       ^
-   ^     ^
-    ^^^^^
-      ^
-      ^
-      ^
-    ^^^^^
-      ^
-      ^
+Input: $N = 5
+Output: (3, 4, 5)
+        (5, 12, 13)
+
+Input: $N = 13
+Output: (5, 12, 13)
+        (13, 84, 85)
+
+Input: $N = 1
+Output: -1
 ~~~~
 
 ### Solutions
@@ -56,40 +60,51 @@
 * [Tcl](tcl/ch-1.tcl)
 
 ### Blog
-[Perl Weekly Challenge 124: Happy Women Day][blog1]
+[Perl Weekly Challenge 125: Pythagorean Triples][blog1]
+
+## [Binary Tree Diameter][task2]
 
-## [Tug of War][task2]
+> You are given binary tree as below:
 
-> You are given a set of $n integers `(n1, n2, n3, ...)`.
+~~~~
+    1
+   / \
+  2   5
+ / \ / \
+3  4 6  7
+       / \
+      8  10
+     /
+    9
+~~~~
+
+> Write a script to find the diameter of the given binary tree.
 >
-> Write a script to divide the set in two subsets of `n/2` sizes each
-> so that the difference of the sum of two subsets is the least. If
-> `$n` is even then each subset must be of size `$n/2` each. In case $n
-> is odd then one subset must be `($n-1)/2` and other must be `($n+1)/2`.
+> > The diameter of a binary tree is the length of the longest path
+> > between any two nodes in a tree. It doesn't have to pass
+> > through the root.
+
+For the above given binary tree, possible diameters (7) are:
 
-### Examples
 ~~~~
-Input:        Set = (10, 20, 30, 40, 50, 60, 70, 80, 90, 100)
-Output:  Subset 1 = (30, 40, 60, 70, 80)
-         Subset 2 = (10, 20, 50, 90, 100)
+3, 2, 1, 5, 7, 8, 9
 ~~~~
 
+or
+
 ~~~~
-Input:        Set = (10, -15, 20, 30, -25, 0, 5, 40, -5)
-         Subset 1 = (30, 0, 5, -5)
-         Subset 2 = (10, -15, 20, -25, 40)
+4, 2, 1, 5, 7, 8, 9
 ~~~~
 
 ### Solutions
 * [Perl](perl/ch-2.pl)
-* [Python](python/ch-2.py)
 
 ### Blog
-[Perl Weekly Challenge 124: Tug of War][blog2]
+[Perl Weekly Challenge 125: Binary Tree Diameter][blog2]
 
 
 
-[task1]: https://perlweeklychallenge.org/blog/perl-weekly-challenge-124/#TASK1
-[task2]: https://perlweeklychallenge.org/blog/perl-weekly-challenge-124/#TASK2
-[blog1]: https://abigail.github.io/HTML/Perl-Weekly-Challenge/week-124-1.html
-[blog2]: https://abigail.github.io/HTML/Perl-Weekly-Challenge/week-124-2.html
+[task1]: https://perlweeklychallenge.org/blog/perl-weekly-challenge-125/#TASK1
+[task2]: https://perlweeklychallenge.org/blog/perl-weekly-challenge-125/#TASK2
+[blog1]: https://abigail.github.io/HTML/Perl-Weekly-Challenge/week-125-1.html
+[blog2]: https://abigail.github.io/HTML/Perl-Weekly-Challenge/week-125-2.html
-- 
cgit 


From 2fd3284b4fe1fff4704852af151b0efcecad2d2c Mon Sep 17 00:00:00 2001
From: Scimon Proctor <simon.proctor@gmail.com>
Date: Mon, 9 Aug 2021 14:12:10 +0100
Subject: Simon reads wikipedia time is over

---
 challenge-125/simon-proctor/raku/ch-1.raku | 39 ++++++++++++++++++++++++++++++
 1 file changed, 39 insertions(+)
 create mode 100644 challenge-125/simon-proctor/raku/ch-1.raku

diff --git a/challenge-125/simon-proctor/raku/ch-1.raku b/challenge-125/simon-proctor/raku/ch-1.raku
new file mode 100644
index 0000000000..bf36282fe4
--- /dev/null
+++ b/challenge-125/simon-proctor/raku/ch-1.raku
@@ -0,0 +1,39 @@
+#!/usr/bin/env raku
+
+my @odds = (1,*+2...*).cache;
+
+multi sub MAIN('test') is hidden-from-USAGE {
+    use Test;
+
+    is py-triples(3), ( (3,4,5) );
+    is py-triples(4), ( (3,4,5) );
+    is py-triples(5), ( (3,4,5), (5,12,13) );
+    is py-triples(6), ();
+    is py-triples(13), ( (5,12,13), (13, 84, 85) );
+
+    done-testing;
+}
+
+#| Given a positive Integer $N print the pythagorean triples it's found in or -1 if there are none
+multi sub MAIN(UInt $N where * > 0) {
+    my @trips = py-triples( $N );
+    say -1 unless +@trips;
+    .join(",").say for @trips; 
+}
+
+sub py-triples(UInt $N) {
+    my @out;
+    
+    my @odds = (1,*+2...* >= $N).cache;
+
+    my @pairs = (@odds X, @odds).grep( -> ($m, $n) { $m > $n } );
+    
+    for @pairs -> ( $m, $n ) {
+        if ( $N ~~ $m * $n || $N ~~ ($m²-$n²)/2 || $N ~~ ($m² + $n²)/2 ) {
+            push @out, $ = ( ($m * $n), ( ($m²-$n²)/2), ( ($m² + $n²)/2 ) );
+        }
+    }
+    
+    return @out;
+}
+  
-- 
cgit 


From 12dd93a4a9defb89724f216bb360689ff3fd1b9e Mon Sep 17 00:00:00 2001
From: Scimon Proctor <simon.proctor@gmail.com>
Date: Mon, 9 Aug 2021 14:15:15 +0100
Subject: Tidying up a bit

---
 challenge-125/simon-proctor/raku/ch-1.raku | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/challenge-125/simon-proctor/raku/ch-1.raku b/challenge-125/simon-proctor/raku/ch-1.raku
index bf36282fe4..e5dc16521a 100644
--- a/challenge-125/simon-proctor/raku/ch-1.raku
+++ b/challenge-125/simon-proctor/raku/ch-1.raku
@@ -29,8 +29,9 @@ sub py-triples(UInt $N) {
     my @pairs = (@odds X, @odds).grep( -> ($m, $n) { $m > $n } );
     
     for @pairs -> ( $m, $n ) {
-        if ( $N ~~ $m * $n || $N ~~ ($m²-$n²)/2 || $N ~~ ($m² + $n²)/2 ) {
-            push @out, $ = ( ($m * $n), ( ($m²-$n²)/2), ( ($m² + $n²)/2 ) );
+        my $pos = (  ($m * $n), ( ($m²-$n²)/2), ( ($m² + $n²)/2 ) );
+        if ( $N ~~ $pos.any ) {
+            push @out, $pos;
         }
     }
     
-- 
cgit 


From f6f9fa776f9dc5bd59f7d63ff97625fbea3c3f1a Mon Sep 17 00:00:00 2001
From: Scimon Proctor <simon.proctor@gmail.com>
Date: Mon, 9 Aug 2021 14:54:59 +0100
Subject: Hyper for the win

---
 challenge-125/simon-proctor/raku/ch-1.raku | 11 +----------
 1 file changed, 1 insertion(+), 10 deletions(-)

diff --git a/challenge-125/simon-proctor/raku/ch-1.raku b/challenge-125/simon-proctor/raku/ch-1.raku
index e5dc16521a..5caf5d2c2d 100644
--- a/challenge-125/simon-proctor/raku/ch-1.raku
+++ b/challenge-125/simon-proctor/raku/ch-1.raku
@@ -26,15 +26,6 @@ sub py-triples(UInt $N) {
     
     my @odds = (1,*+2...* >= $N).cache;
 
-    my @pairs = (@odds X, @odds).grep( -> ($m, $n) { $m > $n } );
-    
-    for @pairs -> ( $m, $n ) {
-        my $pos = (  ($m * $n), ( ($m²-$n²)/2), ( ($m² + $n²)/2 ) );
-        if ( $N ~~ $pos.any ) {
-            push @out, $pos;
-        }
-    }
-    
-    return @out;
+    return (@odds X, @odds).hyper.grep( -> ($m, $n) { $m > $n } ).map( -> ( $m, $n ) { (  ($m * $n), ( ($m²-$n²)/2), ( ($m² + $n²)/2 ) ) } ).grep( -> $pos { $N ~~ $pos.any; } );
 }
   
-- 
cgit 


From 4fb773b850b3327ac01eb409f24184b21984fa85 Mon Sep 17 00:00:00 2001
From: Scimon Proctor <simon.proctor@gmail.com>
Date: Mon, 9 Aug 2021 16:25:11 +0100
Subject: Binary tree stuff.

---
 challenge-125/simon-proctor/raku/ch-2.raku | 156 +++++++++++++++++++++++++++++
 1 file changed, 156 insertions(+)
 create mode 100644 challenge-125/simon-proctor/raku/ch-2.raku

diff --git a/challenge-125/simon-proctor/raku/ch-2.raku b/challenge-125/simon-proctor/raku/ch-2.raku
new file mode 100644
index 0000000000..2c11ae1465
--- /dev/null
+++ b/challenge-125/simon-proctor/raku/ch-2.raku
@@ -0,0 +1,156 @@
+#!/usr/bin/env raku
+
+grammar BTreeGrammar {
+    token TOP { <tree> };
+    token tree { <value> ["(" $<left>=<tree> ")"]? ["(" $<right>=<tree> ")"]? };
+    regex value { <-[()]>+ }
+}
+
+class BTreeRep {...}
+
+role BTree[::T] {
+    has T $.value is required;
+    has BTree @!nodes[2];
+
+    submethod BUILD ( T() :$value, :@nodes ) {
+        $!value = $value;
+        @!nodes = @nodes;
+    }
+    
+    method Str( ) {
+        ( $!value , |@.nodes.map( { "({$_})" } ) ).join("");
+    }
+
+    method COERCE( Str:D $str --> BTree ) {
+        return ::?CLASS.from-Str( $str );
+    }
+
+    method nodes() {
+        @!nodes.grep({defined $_});
+    }
+
+    method children() {
+        @.nodes.elems;
+    }
+
+    method gist() {
+        BTreeRep.new( tree=>self ).gist();
+    }
+
+    method raku() {
+        "{self.^name}.new( {("value => {$!value}", self.nodes ?? "nodes => {(self.nodes.map(*.raku)).join(", ")}" !! Empty).join(", ")} )";
+    }
+
+    method traverse() {
+        gather {
+            if ( self.children ) {
+                for @.nodes -> $n {
+                    for $n.traverse -> @t {
+                        take ($!value, |@t);
+                    }
+                }
+            } else {
+                take ( $!value, );
+            }
+        }
+    }
+
+    multi method reverse( ::?CLASS:D: ) {
+        self.new(
+            value => $!value,
+            nodes => @.nodes.reverse.map( *.reverse )
+        )
+    }
+    
+    multi method from-Str('') { BTree }
+
+    multi method from-Str( ::?CLASS:U: Str $in ) {
+        my $match = BTreeGrammar.parse( $in );
+        if ( $match ) {
+            self.new(
+                value => $match<tree><value>.Str,
+                nodes => [
+                          self.from-Str( $match<tree><left> ?? $match<tree><left>.Str !! '' ),
+                          self.from-Str( $match<tree><right> ?? $match<tree><right>.Str !! '' )
+                      ]
+            );
+        } else {
+            die "Unable to Parse $in";
+        }
+            
+    }
+}
+
+class BTreeRep {
+    has @.data;
+    has UInt $.join-point;
+
+    multi submethod BUILD ( BTree :$tree where { ! $tree.children } ) {
+            @!data = [$tree.value.Str];
+            $!join-point = $tree.value.Str.codes div 2;
+    }
+
+    multi submethod BUILD ( BTree :$tree ) {
+        my ( $left, $right, $left-width, $right-width );
+        my ( @ldata, @rdata, $left-pad, $right-pad );
+
+        my $mid-string = '┘';
+        $left = BTreeRep.new( tree => $tree.nodes[0] );
+        $left-width = $left.data[0].codes;
+        @ldata = $left.data;
+        @ldata.unshift( (" " x $left.join-point) ~ "┌" ~ ("─" x ($left-width - 1 - $left.join-point) ) );
+
+        if ( $tree.children == 2 ) {
+            my $right = BTreeRep.new( tree => $tree.nodes[1] );
+            $mid-string = '┴';
+            @rdata = $right.data;
+            $right-width = @rdata[0].codes;
+            @rdata.unshift( ( "─" x ( $right.join-point ) ~ '┐' ~ ( " " x $right-width - 1 - $right.join-point ) ) );
+        } else {
+            $right-width = 1;
+            @rdata = @ldata.map( { " " } );
+        }
+
+        if ( $left-width + $right-width + 1 < $tree.value.codes ) {
+            $left-pad = 0;
+            $right-pad = 0;
+            my $extra = $tree.value.codes - ($left-width + $right-width + 1);
+            @ldata = @ldata.map( { ( " " x ( $extra div 2 ) ) ~ $_ } );
+            @rdata = @rdata.map( { $_ ~ ( " " x ( $extra div 2 + $extra % 2 ) ) } );
+        } else {
+            $left-pad = $left-width - ($tree.value.codes div 2);
+            $right-pad = ($left-width + $right-width + 1) - $left-pad - $tree.value.codes;
+        }
+        my $top = ( " " x $left-pad ) ~ $tree.value ~ ( " " x $right-pad );
+        my $left-fill = gather { for @ldata.elems^..@rdata.elems { take " " x $left-width } };
+        my $right-fill = gather { for @rdata.elems^..@ldata.elems { take " " x $right-width } };
+
+        @!data = $top, |( ( (|@ldata, |$left-fill) Z, (|@rdata, |$right-fill) ).map( { state $i=0;$_.join($i++??" "!!$mid-string) } ) );
+        $!join-point = $left-pad + ( $tree.value.Str.codes div 2);
+    }
+
+    method gist {
+        @.data.join("\n");
+    }
+
+}
+
+multi sub MAIN( 'example' ) {
+    MAIN('1(2(3)(4))(5(6)(7(8(9))(10)))');
+}
+
+multi sub MAIN( *@data ) {
+    my BTree[Any](Str) $tree = @data.join("");
+    my @routes = $tree.traverse.sort( -*.elems );
+
+    my $long = shift @routes;
+    my $result = $long.elems;
+    for @routes -> $pos {
+        if ($long (&) $pos).elems == 1 {
+            $result = $long.elems + $pos.elems - 1;
+            last;
+        }
+    }
+    say $result;
+}
+
-- 
cgit 


From df64daf6d419ae5be1a3f7f2c23ab4c3181d568e Mon Sep 17 00:00:00 2001
From: Scimon Proctor <simon.proctor@gmail.com>
Date: Mon, 9 Aug 2021 16:27:32 +0100
Subject: Make the Str Rep Object a passable

---
 challenge-125/simon-proctor/raku/ch-2.raku | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/challenge-125/simon-proctor/raku/ch-2.raku b/challenge-125/simon-proctor/raku/ch-2.raku
index 2c11ae1465..2ab4173e5a 100644
--- a/challenge-125/simon-proctor/raku/ch-2.raku
+++ b/challenge-125/simon-proctor/raku/ch-2.raku
@@ -8,7 +8,7 @@ grammar BTreeGrammar {
 
 class BTreeRep {...}
 
-role BTree[::T] {
+role BTree[::T,::R=BTreeRep] {
     has T $.value is required;
     has BTree @!nodes[2];
 
@@ -34,7 +34,7 @@ role BTree[::T] {
     }
 
     method gist() {
-        BTreeRep.new( tree=>self ).gist();
+        R.new( tree=>self ).gist();
     }
 
     method raku() {
@@ -143,6 +143,8 @@ multi sub MAIN( *@data ) {
     my BTree[Any](Str) $tree = @data.join("");
     my @routes = $tree.traverse.sort( -*.elems );
 
+    say $tree;
+    
     my $long = shift @routes;
     my $result = $long.elems;
     for @routes -> $pos {
-- 
cgit 


From 5f09f670cc58cb94b6a36599ecf5e580484e6759 Mon Sep 17 00:00:00 2001
From: chirvasitua <stuart-little@users.noreply.github.com>
Date: Mon, 9 Aug 2021 17:18:10 -0400
Subject: 1st commit on 125_raku

---
 challenge-125/stuart-little/raku/ch-1.raku | 21 ++++++++++++
 challenge-125/stuart-little/raku/ch-2.raku | 55 ++++++++++++++++++++++++++++++
 2 files changed, 76 insertions(+)
 create mode 100755 challenge-125/stuart-little/raku/ch-1.raku
 create mode 100755 challenge-125/stuart-little/raku/ch-2.raku

diff --git a/challenge-125/stuart-little/raku/ch-1.raku b/challenge-125/stuart-little/raku/ch-1.raku
new file mode 100755
index 0000000000..4799cc37c4
--- /dev/null
+++ b/challenge-125/stuart-little/raku/ch-1.raku
@@ -0,0 +1,21 @@
+#!/usr/bin/env raku
+use v6;
+
+# run <script> <number>
+
+sub trps($n) {
+    my @triples;
+    @triples.push(| (1..(($n+1)/2).floor).map({ [$_, sqrt($n**2-$_**2).floor, $n] }).grep({ $_.[0] && $_.[1] && $_.[1]**2 == $n**2-$_.[0]**2 }) );
+    @triples.push(| (1..$n-1).grep({ ($n**2 %% $_) && ($_%2 == ($n**2/$_).floor%2) }).map({ my $s = ($n**2/$_).floor; my $a = (($s-$_)/2).floor; my $b = (($s+$_)/2).floor; [$a,$n,$b] }) );
+    return @triples;
+}
+
+my @sol=trps(@*ARGS[0].Int);
+(@sol.elems) && do {
+    for (@sol) {
+	.say;
+    }
+    exit;
+};
+
+say -1;
diff --git a/challenge-125/stuart-little/raku/ch-2.raku b/challenge-125/stuart-little/raku/ch-2.raku
new file mode 100755
index 0000000000..1024763da1
--- /dev/null
+++ b/challenge-125/stuart-little/raku/ch-2.raku
@@ -0,0 +1,55 @@
+#!/usr/bin/env raku
+use v6;
+
+sub lr(@tree) {
+    (@tree.elems < 3 || @tree[0] eq '.') && return [[],[]];
+    (@tree.elems == 3) && return [["."],["."]];
+    my @left;
+    my ($sum,$ix)=(0,1);
+    while ($sum != -1) {
+	@left.push(@tree[$ix]);
+	$sum+=((@tree[$ix] eq '.') ?? (-1) !! (1));
+	$ix++;
+    }
+    my @right = @tree[@left.elems^..^@tree.elems];
+    return [@left,@right];
+}
+
+sub lrLongPath(@tree) {
+    @tree[0] eq '.' && return [[],[]];
+    @tree.elems == 3 && return [[@tree[0]],[@tree[0]]];
+    my ($left,$right) = lr(@tree);
+    my $lLongPath = [@tree[0], |(lrLongPath($left).max({ $_.elems }))];
+    my $rLongPath = [@tree[0], |(lrLongPath($right).max({ $_.elems }))];
+    return [$lLongPath,$rLongPath];    
+}
+
+sub biLongPath(@tree) {
+    (@tree.elems < 3 || @tree[0] eq '.') && return [];
+    (@tree.elems == 3) && return [@tree[0],];
+    my ($lPath,$rPath) = lrLongPath(@tree);
+    my @lPath = $lPath.[1..*].reverse;
+    my @path = [|@lPath,|$rPath];
+    my ($left,$right) = lr(@tree);
+    return (@path, |($left,$right).map({ biLongPath($_) })).max({ $_.elems });
+}
+
+my $sol = biLongPath(@*ARGS);
+say $sol;
+
+=finish
+run <script> <tree in preorder form with '.' for empty nodes, entered as space-separated values>
+
+ref: https://stackoverflow.com/a/2676849/11064961
+
+e.g. 1 2 4 . 7 . . . 3 5 . . 6 . . represents the tree
+
+        1
+       / \
+      2   3
+     /   / \
+    4   5   6
+     \
+      7
+
+given as an example in the problem formulation at https://perlweeklychallenge.org/blog/perl-weekly-challenge-113/#TASK2
-- 
cgit 


From df7773a8aeae0cb3f555febd76596a3317dab974 Mon Sep 17 00:00:00 2001
From: chirvasitua <stuart-little@users.noreply.github.com>
Date: Mon, 9 Aug 2021 17:19:14 -0400
Subject: 1st commit on 125_perl

---
 challenge-125/stuart-little/perl/ch-1.pl | 25 +++++++++++++
 challenge-125/stuart-little/perl/ch-2.pl | 64 ++++++++++++++++++++++++++++++++
 2 files changed, 89 insertions(+)
 create mode 100755 challenge-125/stuart-little/perl/ch-1.pl
 create mode 100755 challenge-125/stuart-little/perl/ch-2.pl

diff --git a/challenge-125/stuart-little/perl/ch-1.pl b/challenge-125/stuart-little/perl/ch-1.pl
new file mode 100755
index 0000000000..d528990782
--- /dev/null
+++ b/challenge-125/stuart-little/perl/ch-1.pl
@@ -0,0 +1,25 @@
+#!/usr/bin/env perl
+use warnings;
+use v5.12;
+
+# run <script> <number>
+
+use feature qw(signatures);
+no warnings qw(experimental::signatures);
+
+sub trps($n) {
+    my @triples;
+    push @triples, (grep {$_->[0] && $_->[1] && $_->[1]**2 == $n**2-$_->[0]**2} map {[$_, int(sqrt($n**2-$_**2)), $n]} 1..int(($n+1)/2));
+    push @triples, ( map { my $s = int($n**2/$_); my $a = int(($s-$_)/2); my $b = int(($s+$_)/2); [$a,$n,$b]} grep { ($n**2 % $_ == 0) && ($_%2 == int($n**2/$_)%2) } 1..$n-1 );
+    return \@triples;
+}
+
+my $sol=trps($ARGV[0]);
+(scalar @{$sol}) && do {
+    for (@{$sol}) {
+	say "@{$_}";
+    }
+    exit;
+};
+
+say -1;
diff --git a/challenge-125/stuart-little/perl/ch-2.pl b/challenge-125/stuart-little/perl/ch-2.pl
new file mode 100755
index 0000000000..8a55bdb680
--- /dev/null
+++ b/challenge-125/stuart-little/perl/ch-2.pl
@@ -0,0 +1,64 @@
+#!/usr/bin/env perl
+use warnings;
+use v5.12;
+
+use feature qw(signatures);
+no warnings qw(experimental::signatures);
+
+use List::AllUtils qw(max_by);
+
+sub lr($tree) {
+    (scalar @{$tree} < 3 || $tree->[0] eq '.') && return [[],[]];
+    (scalar @{$tree} == 3) && return [["."],["."]];
+    my @left;
+    my ($sum,$ix)=(0,1);
+    while ($sum != -1) {
+	push @left, $tree->[$ix];
+	$sum+=(($tree->[$ix] eq '.') ? (-1) : (1));
+	$ix++;
+    }
+    my @right = $tree->@[(scalar @left)+1..(scalar @{$tree})-1];
+    return [\@left,\@right];
+}
+
+sub lrLongPath($tree) {
+    $tree->[0] eq '.' && return [[],[]];
+    scalar @{$tree} == 3 && return [[$tree->[0]],[$tree->[0]]];
+    my ($left,$right) = @{lr($tree)};
+    my $lLongPath = max_by {scalar @{$_}} @{lrLongPath($left)};
+    my $rLongPath = max_by {scalar @{$_}} @{lrLongPath($right)};
+    my @lLongPath = ($tree->[0],@{$lLongPath});
+    my @rLongPath = ($tree->[0],@{$rLongPath});
+    return [\@lLongPath,\@rLongPath];
+    
+}
+
+sub biLongPath($tree) {
+    (scalar @{$tree} < 3 || $tree->[0] eq '.') && return [];
+    (scalar @{$tree} == 3) && return [$tree->[0]];
+    my ($lPath,$rPath) = @{lrLongPath($tree)};
+    my @lPath = reverse $lPath->@[1..(scalar @{$lPath})-1];
+    my @path = (@lPath,@{$rPath});
+    my ($left,$right) = @{lr($tree)};
+    return max_by {scalar @{$_}} (\@path, map {biLongPath($_)} ($left,$right));
+}
+
+my $sol = biLongPath(\@ARGV);
+say "@{$sol}";
+
+__END__
+run <script> <tree in preorder form with '.' for empty nodes, entered as space-separated values>
+
+ref: https://stackoverflow.com/a/2676849/11064961
+
+e.g. 1 2 4 . 7 . . . 3 5 . . 6 . . represents the tree
+
+        1
+       / \
+      2   3
+     /   / \
+    4   5   6
+     \
+      7
+
+given as an example in the problem formulation at https://perlweeklychallenge.org/blog/perl-weekly-challenge-113/#TASK2
-- 
cgit 


From 3b86d11379632b17ca5328d8b92756e4950f0bfc Mon Sep 17 00:00:00 2001
From: Abigail <abigail@abigail.be>
Date: Tue, 10 Aug 2021 01:15:28 +0200
Subject: Tests for week 125, part 1

---
 challenge-125/abigail/t/ctest.ini      |  10 +
 challenge-125/abigail/t/input-1-1      |   3 +
 challenge-125/abigail/t/input-1-2      |   2 +
 challenge-125/abigail/t/input-1-3      |  98 +++++++++
 challenge-125/abigail/t/input-1-4      | 143 ++++++++++++
 challenge-125/abigail/t/output-1-1.exp |   5 +
 challenge-125/abigail/t/output-1-2.exp |   2 +
 challenge-125/abigail/t/output-1-3.exp | 391 +++++++++++++++++++++++++++++++++
 challenge-125/abigail/t/output-1-4.exp | 212 ++++++++++++++++++
 9 files changed, 866 insertions(+)
 create mode 100644 challenge-125/abigail/t/ctest.ini
 create mode 100644 challenge-125/abigail/t/input-1-1
 create mode 100644 challenge-125/abigail/t/input-1-2
 create mode 100644 challenge-125/abigail/t/input-1-3
 create mode 100644 challenge-125/abigail/t/input-1-4
 create mode 100644 challenge-125/abigail/t/output-1-1.exp
 create mode 100644 challenge-125/abigail/t/output-1-2.exp
 create mode 100644 challenge-125/abigail/t/output-1-3.exp
 create mode 100644 challenge-125/abigail/t/output-1-4.exp

diff --git a/challenge-125/abigail/t/ctest.ini b/challenge-125/abigail/t/ctest.ini
new file mode 100644
index 0000000000..44057cf8e4
--- /dev/null
+++ b/challenge-125/abigail/t/ctest.ini
@@ -0,0 +1,10 @@
+# 
+# Configuration file for running tests, using ctest.
+# See https://github.com/Abigail/Misc/blob/master/ctest
+# 
+
+[names]
+1-1 = Given examples
+1-2 = No solutions
+1-3 = Up to 100
+1-4 = Primes up to 1000
diff --git a/challenge-125/abigail/t/input-1-1 b/challenge-125/abigail/t/input-1-1
new file mode 100644
index 0000000000..48685feaae
--- /dev/null
+++ b/challenge-125/abigail/t/input-1-1
@@ -0,0 +1,3 @@
+5
+13
+1
diff --git a/challenge-125/abigail/t/input-1-2 b/challenge-125/abigail/t/input-1-2
new file mode 100644
index 0000000000..1191247b6d
--- /dev/null
+++ b/challenge-125/abigail/t/input-1-2
@@ -0,0 +1,2 @@
+1
+2
diff --git a/challenge-125/abigail/t/input-1-3 b/challenge-125/abigail/t/input-1-3
new file mode 100644
index 0000000000..3758ba5b23
--- /dev/null
+++ b/challenge-125/abigail/t/input-1-3
@@ -0,0 +1,98 @@
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+20
+21
+22
+23
+24
+25
+26
+27
+28
+29
+30
+31
+32
+33
+34
+35
+36
+37
+38
+39
+40
+41
+42
+43
+44
+45
+46
+47
+48
+49
+50
+51
+52
+53
+54
+55
+56
+57
+58
+59
+60
+61
+62
+63
+64
+65
+66
+67
+68
+69
+70
+71
+72
+73
+74
+75
+76
+77
+78
+79
+80
+81
+82
+83
+84
+85
+86
+87
+88
+89
+90
+91
+92
+93
+94
+95
+96
+97
+98
+99
+100
diff --git a/challenge-125/abigail/t/input-1-4 b/challenge-125/abigail/t/input-1-4
new file mode 100644
index 0000000000..0aa2bff2b8
--- /dev/null
+++ b/challenge-125/abigail/t/input-1-4
@@ -0,0 +1,143 @@
+101
+103
+107
+109
+113
+127
+131
+137
+139
+149
+151
+157
+163
+167
+173
+179
+181
+191
+193
+197
+199
+211
+223
+227
+229
+233
+239
+241
+251
+257
+263
+269
+271
+277
+281
+283
+293
+307
+311
+313
+317
+331
+337
+347
+349
+353
+359
+367
+373
+379
+383
+389
+397
+401
+409
+419
+421
+431
+433
+439
+443
+449
+457
+461
+463
+467
+479
+487
+491
+499
+503
+509
+521
+523
+541
+547
+557
+563
+569
+571
+577
+587
+593
+599
+601
+607
+613
+617
+619
+631
+641
+643
+647
+653
+659
+661
+673
+677
+683
+691
+701
+709
+719
+727
+733
+739
+743
+751
+757
+761
+769
+773
+787
+797
+809
+811
+821
+823
+827
+829
+839
+853
+857
+859
+863
+877
+881
+883
+887
+907
+911
+919
+929
+937
+941
+947
+953
+967
+971
+977
+983
+991
+997
diff --git a/challenge-125/abigail/t/output-1-1.exp b/challenge-125/abigail/t/output-1-1.exp
new file mode 100644
index 0000000000..c81387014a
--- /dev/null
+++ b/challenge-125/abigail/t/output-1-1.exp
@@ -0,0 +1,5 @@
+5 12 13
+3 4 5
+13 84 85
+5 12 13
+-1
diff --git a/challenge-125/abigail/t/output-1-2.exp b/challenge-125/abigail/t/output-1-2.exp
new file mode 100644
index 0000000000..343ee5c2f6
--- /dev/null
+++ b/challenge-125/abigail/t/output-1-2.exp
@@ -0,0 +1,2 @@
+-1
+-1
diff --git a/challenge-125/abigail/t/output-1-3.exp b/challenge-125/abigail/t/output-1-3.exp
new file mode 100644
index 0000000000..d1717d0529
--- /dev/null
+++ b/challenge-125/abigail/t/output-1-3.exp
@@ -0,0 +1,391 @@
+3 4 5
+4 3 5
+5 12 13
+3 4 5
+6 8 10
+7 24 25
+8 6 10
+8 15 17
+9 12 15
+9 40 41
+10 24 26
+6 8 10
+11 60 61
+12 5 13
+12 9 15
+12 16 20
+12 35 37
+13 84 85
+5 12 13
+14 48 50
+15 8 17
+15 20 25
+15 36 39
+15 112 113
+9 12 15
+16 12 20
+16 30 34
+16 63 65
+17 144 145
+8 15 17
+18 24 30
+18 80 82
+19 180 181
+20 15 25
+20 21 29
+20 48 52
+20 99 101
+12 16 20
+21 20 29
+21 28 35
+21 72 75
+21 220 221
+22 120 122
+23 264 265
+24 7 25
+24 10 26
+24 18 30
+24 32 40
+24 45 51
+24 70 74
+24 143 145
+25 60 65
+25 312 313
+7 24 25
+15 20 25
+26 168 170
+10 24 26
+27 36 45
+27 120 123
+27 364 365
+28 21 35
+28 45 53
+28 96 100
+28 195 197
+29 420 421
+20 21 29
+30 16 34
+30 40 50
+30 72 78
+30 224 226
+18 24 30
+31 480 481
+32 24 40
+32 60 68
+32 126 130
+32 255 257
+33 44 55
+33 56 65
+33 180 183
+33 544 545
+34 288 290
+16 30 34
+35 12 37
+35 84 91
+35 120 125
+35 612 613
+21 28 35
+36 15 39
+36 27 45
+36 48 60
+36 77 85
+36 105 111
+36 160 164
+36 323 325
+37 684 685
+12 35 37
+38 360 362
+39 52 65
+39 80 89
+39 252 255
+39 760 761
+15 36 39
+40 9 41
+40 30 50
+40 42 58
+40 75 85
+40 96 104
+40 198 202
+40 399 401
+24 32 40
+41 840 841
+9 40 41
+42 40 58
+42 56 70
+42 144 150
+42 440 442
+43 924 925
+44 33 55
+44 117 125
+44 240 244
+44 483 485
+45 24 51
+45 28 53
+45 60 75
+45 108 117
+45 200 205
+45 336 339
+45 1012 1013
+27 36 45
+46 528 530
+47 1104 1105
+48 14 50
+48 20 52
+48 36 60
+48 55 73
+48 64 80
+48 90 102
+48 140 148
+48 189 195
+48 286 290
+48 575 577
+49 168 175
+49 1200 1201
+50 120 130
+50 624 626
+14 48 50
+30 40 50
+51 68 85
+51 140 149
+51 432 435
+51 1300 1301
+24 45 51
+52 39 65
+52 165 173
+52 336 340
+52 675 677
+20 48 52
+53 1404 1405
+28 45 53
+54 72 90
+54 240 246
+54 728 730
+55 48 73
+55 132 143
+55 300 305
+55 1512 1513
+33 44 55
+56 33 65
+56 42 70
+56 90 106
+56 105 119
+56 192 200
+56 390 394
+56 783 785
+57 76 95
+57 176 185
+57 540 543
+57 1624 1625
+58 840 842
+40 42 58
+59 1740 1741
+60 11 61
+60 25 65
+60 32 68
+60 45 75
+60 63 87
+60 80 100
+60 91 109
+60 144 156
+60 175 185
+60 221 229
+60 297 303
+60 448 452
+60 899 901
+36 48 60
+61 1860 1861
+11 60 61
+62 960 962
+63 16 65
+63 60 87
+63 84 105
+63 216 225
+63 280 287
+63 660 663
+63 1984 1985
+64 48 80
+64 120 136
+64 252 260
+64 510 514
+64 1023 1025
+65 72 97
+65 156 169
+65 420 425
+65 2112 2113
+16 63 65
+25 60 65
+33 56 65
+39 52 65
+66 88 110
+66 112 130
+66 360 366
+66 1088 1090
+67 2244 2245
+68 51 85
+68 285 293
+68 576 580
+68 1155 1157
+32 60 68
+69 92 115
+69 260 269
+69 792 795
+69 2380 2381
+70 24 74
+70 168 182
+70 240 250
+70 1224 1226
+42 56 70
+71 2520 2521
+72 21 75
+72 30 78
+72 54 90
+72 65 97
+72 96 120
+72 135 153
+72 154 170
+72 210 222
+72 320 328
+72 429 435
+72 646 650
+72 1295 1297
+73 2664 2665
+48 55 73
+74 1368 1370
+24 70 74
+75 40 85
+75 100 125
+75 180 195
+75 308 317
+75 560 565
+75 936 939
+75 2812 2813
+21 72 75
+45 60 75
+76 57 95
+76 357 365
+76 720 724
+76 1443 1445
+77 36 85
+77 264 275
+77 420 427
+77 2964 2965
+78 104 130
+78 160 178
+78 504 510
+78 1520 1522
+30 72 78
+79 3120 3121
+80 18 82
+80 39 89
+80 60 100
+80 84 116
+80 150 170
+80 192 208
+80 315 325
+80 396 404
+80 798 802
+80 1599 1601
+48 64 80
+81 108 135
+81 360 369
+81 1092 1095
+81 3280 3281
+82 1680 1682
+18 80 82
+83 3444 3445
+84 13 85
+84 35 91
+84 63 105
+84 80 116
+84 112 140
+84 135 159
+84 187 205
+84 245 259
+84 288 300
+84 437 445
+84 585 591
+84 880 884
+84 1763 1765
+85 132 157
+85 204 221
+85 720 725
+85 3612 3613
+13 84 85
+36 77 85
+40 75 85
+51 68 85
+86 1848 1850
+87 116 145
+87 416 425
+87 1260 1263
+87 3784 3785
+60 63 87
+88 66 110
+88 105 137
+88 165 187
+88 234 250
+88 480 488
+88 966 970
+88 1935 1937
+89 3960 3961
+39 80 89
+90 48 102
+90 56 106
+90 120 150
+90 216 234
+90 400 410
+90 672 678
+90 2024 2026
+54 72 90
+91 60 109
+91 312 325
+91 588 595
+91 4140 4141
+35 84 91
+92 69 115
+92 525 533
+92 1056 1060
+92 2115 2117
+93 124 155
+93 476 485
+93 1440 1443
+93 4324 4325
+94 2208 2210
+95 168 193
+95 228 247
+95 900 905
+95 4512 4513
+57 76 95
+96 28 100
+96 40 104
+96 72 120
+96 110 146
+96 128 160
+96 180 204
+96 247 265
+96 280 296
+96 378 390
+96 572 580
+96 765 771
+96 1150 1154
+96 2303 2305
+97 4704 4705
+65 72 97
+98 336 350
+98 2400 2402
+99 20 101
+99 132 165
+99 168 195
+99 440 451
+99 540 549
+99 1632 1635
+99 4900 4901
+100 75 125
+100 105 145
+100 240 260
+100 495 505
+100 621 629
+100 1248 1252
+100 2499 2501
+28 96 100
+60 80 100
diff --git a/challenge-125/abigail/t/output-1-4.exp b/challenge-125/abigail/t/output-1-4.exp
new file mode 100644
index 0000000000..1038f1ac74
--- /dev/null
+++ b/challenge-125/abigail/t/output-1-4.exp
@@ -0,0 +1,212 @@
+101 5100 5101
+20 99 101
+103 5304 5305
+107 5724 5725
+109 5940 5941
+60 91 109
+113 6384 6385
+15 112 113
+127 8064 8065
+131 8580 8581
+137 9384 9385
+88 105 137
+139 9660 9661
+149 11100 11101
+51 140 149
+151 11400 11401
+157 12324 12325
+85 132 157
+163 13284 13285
+167 13944 13945
+173 14964 14965
+52 165 173
+179 16020 16021
+181 16380 16381
+19 180 181
+191 18240 18241
+193 18624 18625
+95 168 193
+197 19404 19405
+28 195 197
+199 19800 19801
+211 22260 22261
+223 24864 24865
+227 25764 25765
+229 26220 26221
+60 221 229
+233 27144 27145
+105 208 233
+239 28560 28561
+241 29040 29041
+120 209 241
+251 31500 31501
+257 33024 33025
+32 255 257
+263 34584 34585
+269 36180 36181
+69 260 269
+271 36720 36721
+277 38364 38365
+115 252 277
+281 39480 39481
+160 231 281
+283 40044 40045
+293 42924 42925
+68 285 293
+307 47124 47125
+311 48360 48361
+313 48984 48985
+25 312 313
+317 50244 50245
+75 308 317
+331 54780 54781
+337 56784 56785
+175 288 337
+347 60204 60205
+349 60900 60901
+180 299 349
+353 62304 62305
+225 272 353
+359 64440 64441
+367 67344 67345
+373 69564 69565
+252 275 373
+379 71820 71821
+383 73344 73345
+389 75660 75661
+189 340 389
+397 78804 78805
+228 325 397
+401 80400 80401
+40 399 401
+409 83640 83641
+120 391 409
+419 87780 87781
+421 88620 88621
+29 420 421
+431 92880 92881
+433 93744 93745
+145 408 433
+439 96360 96361
+443 98124 98125
+449 100800 100801
+280 351 449
+457 104424 104425
+168 425 457
+461 106260 106261
+261 380 461
+463 107184 107185
+467 109044 109045
+479 114720 114721
+487 118584 118585
+491 120540 120541
+499 124500 124501
+503 126504 126505
+509 129540 129541
+220 459 509
+521 135720 135721
+279 440 521
+523 136764 136765
+541 146340 146341
+341 420 541
+547 149604 149605
+557 155124 155125
+165 532 557
+563 158484 158485
+569 161880 161881
+231 520 569
+571 163020 163021
+577 166464 166465
+48 575 577
+587 172284 172285
+593 175824 175825
+368 465 593
+599 179400 179401
+601 180600 180601
+240 551 601
+607 184224 184225
+613 187884 187885
+35 612 613
+617 190344 190345
+105 608 617
+619 191580 191581
+631 199080 199081
+641 205440 205441
+200 609 641
+643 206724 206725
+647 209304 209305
+653 213204 213205
+315 572 653
+659 217140 217141
+661 218460 218461
+300 589 661
+673 226464 226465
+385 552 673
+677 229164 229165
+52 675 677
+683 233244 233245
+691 238740 238741
+701 245700 245701
+260 651 701
+709 251340 251341
+259 660 709
+719 258480 258481
+727 264264 264265
+733 268644 268645
+108 725 733
+739 273060 273061
+743 276024 276025
+751 282000 282001
+757 286524 286525
+468 595 757
+761 289560 289561
+39 760 761
+769 295680 295681
+481 600 769
+773 298764 298765
+195 748 773
+787 309684 309685
+797 317604 317605
+555 572 797
+809 327240 327241
+280 759 809
+811 328860 328861
+821 337020 337021
+429 700 821
+823 338664 338665
+827 341964 341965
+829 343620 343621
+540 629 829
+839 351960 351961
+853 363804 363805
+205 828 853
+857 367224 367225
+232 825 857
+859 368940 368941
+863 372384 372385
+877 384564 384565
+348 805 877
+881 388080 388081
+369 800 881
+883 389844 389845
+887 393384 393385
+907 411324 411325
+911 414960 414961
+919 422280 422281
+929 431520 431521
+129 920 929
+937 438984 438985
+215 912 937
+941 442740 442741
+580 741 941
+947 448404 448405
+953 454104 454105
+615 728 953
+967 467544 467545
+971 471420 471421
+977 477264 477265
+248 945 977
+983 483144 483145
+991 491040 491041
+997 497004 497005
+372 925 997
-- 
cgit 


From 645d483178b78bec308d687439d201c1779b9373 Mon Sep 17 00:00:00 2001
From: chirvasitua <stuart-little@users.noreply.github.com>
Date: Mon, 9 Aug 2021 19:49:13 -0400
Subject: 1st commit on 125_node

---
 challenge-125/stuart-little/node/ch-1.js | 27 +++++++++++++++++
 challenge-125/stuart-little/node/ch-2.js | 51 ++++++++++++++++++++++++++++++++
 2 files changed, 78 insertions(+)
 create mode 100755 challenge-125/stuart-little/node/ch-1.js
 create mode 100755 challenge-125/stuart-little/node/ch-2.js

diff --git a/challenge-125/stuart-little/node/ch-1.js b/challenge-125/stuart-little/node/ch-1.js
new file mode 100755
index 0000000000..e779fc8023
--- /dev/null
+++ b/challenge-125/stuart-little/node/ch-1.js
@@ -0,0 +1,27 @@
+#!/usr/bin/env node
+
+// run <script> <number>
+
+function trps(n) {
+    let triples=[]
+    for (let i=1; i<=Math.floor((n+1)/2); i++) {
+	let sqDif = Math.floor(Math.sqrt(n**2-i**2))
+	if ((i<n) && (i**2+sqDif**2==n**2)) {
+	    triples.push([i,sqDif,n])
+	}
+    }
+    for (let i=1; i<n; i++) {
+	if ((n**2 % i == 0) && ((i%2) === ((Math.floor(n**2/i))%2))) {
+	    let s = Math.floor(n**2/i)
+	    triples.push([Math.floor((s-i)/2), n, Math.floor((s+i)/2)])	    
+	}
+    }
+    return triples
+}
+
+const sol = trps(parseInt(process.argv[2]));
+if (sol.length>0) {
+    sol.forEach(x => console.log(x));
+    process.exit()
+}
+console.log(-1)
diff --git a/challenge-125/stuart-little/node/ch-2.js b/challenge-125/stuart-little/node/ch-2.js
new file mode 100755
index 0000000000..500019c150
--- /dev/null
+++ b/challenge-125/stuart-little/node/ch-2.js
@@ -0,0 +1,51 @@
+#!/usr/bin/env node
+
+const { maxBy } = require('lodash')
+
+function lr(tree) {
+    if (tree.length < 3 || tree[0] === '.') { return [[],[]] }        
+    if (tree.length === 3) { return [["."],["."]] }        
+    left=[]
+    let [sm,ix] = [0,1]
+    while (sm !== -1) { 
+        left.push(tree[ix])
+        sm+=(tree[ix] == '.' ? -1 : 1)
+        ix+=1
+    }
+    return [left,tree.slice(left.length+1)]
+}
+
+function lrLongPath(tree) {
+    if (tree[0] === '.') { return [[],[]] }        
+    if (tree.length === 3) { return [[tree[0]],[tree[0]]] }        
+    return lr(tree).map( ar => [tree[0], ...maxBy(lrLongPath(ar), x => x.length)] )
+}
+
+function biLongPath(tree) {
+    if (tree.length < 3 || tree[0] == '.') { return [] }
+    if (tree.length === 3) { return [tree[0]] }
+    let [lPath,rPath] = lrLongPath(tree)
+    let path = [...([...(lPath.slice(1))].reverse()),...rPath]
+    let [left,right] = lr(tree)
+    return maxBy([path, ...[left,right].map(biLongPath)], x => x.length)
+}
+
+console.log(biLongPath(process.argv.slice(2)).join(" "))
+
+/*
+run <script> <tree in preorder form with '.' for empty nodes, entered as space-separated values>
+
+ref: https://stackoverflow.com/a/2676849/11064961
+
+e.g. 1 2 4 . 7 . . . 3 5 . . 6 . . represents the tree
+
+        1
+       / \
+      2   3
+     /   / \
+    4   5   6
+     \
+      7
+
+given as an example in the problem formulation at https://perlweeklychallenge.org/blog/perl-weekly-challenge-113/#TASK2
+*/
-- 
cgit 


From 913bd2198fa356651e23e90e9552a5b78e378b50 Mon Sep 17 00:00:00 2001
From: chirvasitua <stuart-little@users.noreply.github.com>
Date: Mon, 9 Aug 2021 19:49:22 -0400
Subject: 1st commit on 125_python

---
 challenge-125/stuart-little/python/ch-1.py | 18 ++++++++++
 challenge-125/stuart-little/python/ch-2.py | 57 ++++++++++++++++++++++++++++++
 2 files changed, 75 insertions(+)
 create mode 100755 challenge-125/stuart-little/python/ch-1.py
 create mode 100755 challenge-125/stuart-little/python/ch-2.py

diff --git a/challenge-125/stuart-little/python/ch-1.py b/challenge-125/stuart-little/python/ch-1.py
new file mode 100755
index 0000000000..f35cf52624
--- /dev/null
+++ b/challenge-125/stuart-little/python/ch-1.py
@@ -0,0 +1,18 @@
+#!/usr/bin/env python
+
+# run <script> <number>
+
+import math
+import sys
+
+def trps(n):
+    triples=[]
+    triples.extend([[x, math.floor(math.sqrt(n**2-x**2)), n] for x in range(1,math.ceil((n+1)/2)+1) if x<n and x**2 + math.floor(math.sqrt(n**2-x**2))**2 == n**2 ])
+    triples.extend([ [math.floor((math.floor(n**2/x)-x)/2),n,math.floor((math.floor(n**2/x)+x)/2)] for x in [i for i in range(1,n) if n**2 % i == 0 and i%2==(math.floor(n**2/i))%2]])
+    return triples
+
+sol = trps(int(sys.argv[1]))
+if len(sol)>0:
+    [print(i) for i in sol]
+    sys.exit()
+print(-1)
diff --git a/challenge-125/stuart-little/python/ch-2.py b/challenge-125/stuart-little/python/ch-2.py
new file mode 100755
index 0000000000..9b5b75aa84
--- /dev/null
+++ b/challenge-125/stuart-little/python/ch-2.py
@@ -0,0 +1,57 @@
+#!/usr/bin/env python
+
+import sys
+
+def lr(tree):
+    if (len(tree) < 3 or tree[0] == '.'):
+        return [[],[]]
+    if len(tree) == 3:
+        return [["."],["."]]
+    left=[]
+    sm,ix = 0,1
+    while sm != -1: 
+        left.append(tree[ix])
+        sm+=(-1 if tree[ix] == '.' else 1)
+        ix+=1
+    right = tree[len(left)+1:]
+    return [left,right]
+
+def lrLongPath(tree):
+    if tree[0] == '.':
+        return [[],[]]
+    if len(tree) == 3:
+        return [[tree[0]],[tree[0]]]
+    left,right = lr(tree)
+    lLongPath = [tree[0]] + max(lrLongPath(left), key=len)
+    rLongPath = [tree[0]] + max(lrLongPath(right), key=len)
+    return [lLongPath,rLongPath]
+
+def biLongPath(tree):
+    if len(tree) < 3 or tree[0] == '.':
+        return []
+    if len(tree) == 3:
+        return [tree[0]]
+    lPath,rPath = lrLongPath(tree)
+    path = list(reversed(lPath[1:])) + rPath
+    left,right = lr(tree)
+    return max([path]+list(map(biLongPath, [left,right])), key=len)
+
+print(" ".join(biLongPath(sys.argv[1:])))
+
+"""
+run <script> <tree in preorder form with '.' for empty nodes, entered as space-separated values>
+
+ref: https://stackoverflow.com/a/2676849/11064961
+
+e.g. 1 2 4 . 7 . . . 3 5 . . 6 . . represents the tree
+
+        1
+       / \
+      2   3
+     /   / \
+    4   5   6
+     \
+      7
+
+given as an example in the problem formulation at https://perlweeklychallenge.org/blog/perl-weekly-challenge-113/#TASK2
+"""
-- 
cgit 


From 799b0b82c35e9347f115536475c3ec40df17c368 Mon Sep 17 00:00:00 2001
From: chirvasitua <chirvasitua@gmail.com>
Date: Mon, 9 Aug 2021 20:47:26 -0400
Subject: 1st commit on 125_lua

---
 challenge-125/stuart-little/lua/ch-1.lua | 27 ++++++++++++++
 challenge-125/stuart-little/lua/ch-2.lua | 63 ++++++++++++++++++++++++++++++++
 2 files changed, 90 insertions(+)
 create mode 100755 challenge-125/stuart-little/lua/ch-1.lua
 create mode 100755 challenge-125/stuart-little/lua/ch-2.lua

diff --git a/challenge-125/stuart-little/lua/ch-1.lua b/challenge-125/stuart-little/lua/ch-1.lua
new file mode 100755
index 0000000000..5358490334
--- /dev/null
+++ b/challenge-125/stuart-little/lua/ch-1.lua
@@ -0,0 +1,27 @@
+#!/usr/bin/env lua
+
+-- run <script> <number>
+
+function trps(n)
+   local triples={}
+   for i=1,math.floor((n+1)/2) do
+      local sqDif=math.floor(math.sqrt(n^2-i^2))
+      if i<n and i^2+sqDif^2==n^2 then table.insert(triples,{i,sqDif,n}) end	 
+   end
+   for i=1,n-1 do
+      if n^2 % i == 0 and i%2 == (math.floor(n^2/i))%2 then
+	 local s = math.floor(n^2/i)
+	 table.insert(triples,{math.floor((s-i)/2), n, math.floor((s+i)/2)})
+      end
+   end
+   return triples
+end
+
+local sol = trps(tonumber(arg[1]))
+if #sol>0 then
+   for _,v in ipairs(sol) do
+      print(table.unpack(v))
+   end
+   os.exit()
+end
+print(-1)
diff --git a/challenge-125/stuart-little/lua/ch-2.lua b/challenge-125/stuart-little/lua/ch-2.lua
new file mode 100755
index 0000000000..78dc34273c
--- /dev/null
+++ b/challenge-125/stuart-little/lua/ch-2.lua
@@ -0,0 +1,63 @@
+#!/usr/bin/env lua
+
+function maxBy(fn,t)
+   local mx,val = -math.huge,nil
+   for k,v in ipairs(t) do
+      if fn(v,k,t) > mx then
+	 mx = fn(v,k,t)
+	 val = v
+      end
+   end
+   return val
+end
+
+function lr(tree) 
+   if #tree < 3 or tree[1] == '.' then return {{},{}} end
+   if #tree == 3 then return {{"."},{"."}} end
+   local left={}
+   local sm,ix = 0,2
+   while (sm ~= -1) do
+      table.insert(left,tree[ix])
+      sm = sm+(tree[ix] == '.' and -1 or 1)
+      ix = ix+1
+   end
+   return {left,table.pack(table.unpack(tree, #left+2))}
+end
+
+function lrLongPath(tree) 
+   if tree[1] == '.' then return {{},{}} end
+   if #tree == 3 then return {{tree[1]},{tree[1]}} end
+   local left,right = table.unpack(lr(tree))
+   local lPath = table.pack(tree[1], table.unpack(maxBy(function(v,k,t) return #v end, lrLongPath(left))))
+   local rPath = table.pack(tree[1], table.unpack(maxBy(function(v,k,t) return #v end, lrLongPath(right))))
+   return {lPath,rPath}
+end
+
+function biLongPath(tree) 
+   if #tree < 3 or tree[1] == '.' then return {} end
+   if #tree == 3 then return {tree[1]} end
+   local lPath,path = table.unpack(lrLongPath(tree))
+   for i=2,#lPath do table.insert(path,1,lPath[i]) end   
+   local left,right = table.unpack(lr(tree))
+   return maxBy(function(v,k,t) return #v end, {path, biLongPath(left), biLongPath(right)})
+end
+
+print(table.unpack(biLongPath(arg)))
+
+--[[
+run <script> <tree in preorder form with '.' for empty nodes, entered as space-separated values>
+
+ref: https://stackoverflow.com/a/2676849/11064961
+
+e.g. 1 2 4 . 7 . . . 3 5 . . 6 . . represents the tree
+
+        1
+       / \
+      2   3
+     /   / \
+    4   5   6
+     \
+      7
+
+given as an example in the problem formulation at https://perlweeklychallenge.org/blog/perl-weekly-challenge-113/#TASK2
+--]]
-- 
cgit 


From 9a2d50bfc4d0eea9e36781189154e59179ff46ca Mon Sep 17 00:00:00 2001
From: chirvasitua <stuart-little@users.noreply.github.com>
Date: Mon, 9 Aug 2021 21:31:33 -0400
Subject: 1st commit on 125_haskell

---
 challenge-125/stuart-little/haskell/ch-1.hs | 13 ++++++++
 challenge-125/stuart-little/haskell/ch-2.hs | 48 +++++++++++++++++++++++++++++
 2 files changed, 61 insertions(+)
 create mode 100755 challenge-125/stuart-little/haskell/ch-1.hs
 create mode 100755 challenge-125/stuart-little/haskell/ch-2.hs

diff --git a/challenge-125/stuart-little/haskell/ch-1.hs b/challenge-125/stuart-little/haskell/ch-1.hs
new file mode 100755
index 0000000000..f54ca4974e
--- /dev/null
+++ b/challenge-125/stuart-little/haskell/ch-1.hs
@@ -0,0 +1,13 @@
+#!/usr/bin/env runghc
+
+-- run <script> <number>
+
+import System.Environment (getArgs)
+
+trps :: Int -> [[Int]]
+trps n = top ++ mid where
+  top = filter (\[x,y,z] -> x>0 && y>0 && x^2+y^2==z^2) [[i,(floor $ sqrt $ fromIntegral (n^2-i^2)),n] | i <- [1..div (n+1) 2]]
+  mid = map (\i-> [div ((div (n^2) i)-i) 2, n, div ((div (n^2) i)+i) 2]) $ filter(\i-> mod (n^2) i == 0 && mod i 2 == mod (div (n^2) i) 2) [1..n-1]
+
+main :: IO ()
+main = getArgs >>= putStrLn . (\x-> if length x > 0 then x else "-1") . unlines . map unwords . (map.map) show . trps.(read::String->Int).head
diff --git a/challenge-125/stuart-little/haskell/ch-2.hs b/challenge-125/stuart-little/haskell/ch-2.hs
new file mode 100755
index 0000000000..3d0e17fb25
--- /dev/null
+++ b/challenge-125/stuart-little/haskell/ch-2.hs
@@ -0,0 +1,48 @@
+#!/usr/bin/env runghc
+
+import Data.List ((\\), inits)
+import Data.List.Extra (maximumOn)
+import System.Environment (getArgs)
+
+lr :: [String] -> [[String]]
+lr xs
+  |(length xs < 3) || (head xs == ".") =[[],[]]
+  |length xs == 3 =[["."],["."]]
+  |otherwise = [l, (tail xs) \\ l] where
+     l = head $ filter (((-1)==).sum.map (\x-> if x == "." then (-1) else 1)) $ inits $ tail xs
+
+lrLongPath :: [String] -> [[String]]
+lrLongPath xs
+  |head xs == "." =[[],[]]
+  |length xs == 3 = replicate 2 [head xs]
+  |otherwise = map ((head xs):) $ map ((maximumOn length).lrLongPath) $ lr xs     
+
+biLongPath :: [String] -> [String]
+biLongPath xs
+  |length xs < 3 || head xs == "." =[]
+  |length xs == 3 = [head xs]
+  |otherwise = maximumOn length [path, biLongPath(left), biLongPath(right)] where
+     [left,right] = lr(xs)
+     [lPath,rPath] = lrLongPath(xs)
+     path = (reverse $ tail lPath) ++ rPath
+
+main :: IO ()
+main = getArgs >>= putStrLn.unwords.biLongPath
+
+{-
+run <script> <tree in preorder form with '.' for empty nodes, entered as space-separated values>
+
+ref: https://stackoverflow.com/a/2676849/11064961
+
+e.g. 1 2 4 . 7 . . . 3 5 . . 6 . . represents the tree
+
+        1
+       / \
+      2   3
+     /   / \
+    4   5   6
+     \
+      7
+
+given as an example in the problem formulation at https://perlweeklychallenge.org/blog/perl-weekly-challenge-113/#TASK2
+-}
-- 
cgit 


From b48f7ee39a1296d5d0f22f94d4ef84d7dbb6a4af Mon Sep 17 00:00:00 2001
From: Mark A <andemark@a-iot1t.uch.ad.pvt>
Date: Mon, 9 Aug 2021 22:29:36 -0600
Subject: initial ch-1.raku

---
 challenge-125/mark-anderson/raku/ch-1.raku | 62 ++++++++++++++++++++++++++++++
 1 file changed, 62 insertions(+)
 create mode 100644 challenge-125/mark-anderson/raku/ch-1.raku

diff --git a/challenge-125/mark-anderson/raku/ch-1.raku b/challenge-125/mark-anderson/raku/ch-1.raku
new file mode 100644
index 0000000000..577a55520b
--- /dev/null
+++ b/challenge-125/mark-anderson/raku/ch-1.raku
@@ -0,0 +1,62 @@
+#!/usr/bin/env raku
+
+# Pythagorean-triples uses the Dickson method
+# https://en.wikipedia.org/wiki/Formulas_for_generating_Pythagorean_triples#Dickson's_method
+
+# factor-pairs uses the Rainbow method
+# https://www.chilimath.com/lessons/introductory-algebra/finding-all-the-factors-of-a-whole-number-using-the-rainbow-method
+
+use Test;
+plan 4;
+
+is-deeply Pythagorean-triples(5),  ((3, 4,  5),
+                                    (5, 12, 13));
+
+is-deeply Pythagorean-triples(13), ((5,  12, 13),
+                                    (13, 84, 85));
+ 
+is Pythagorean-triples(1), -1;
+
+is-deeply Pythagorean-triples(15), ((8,  15,  17),
+                                    (9,  12,  15),
+                                    (15, 20,  25),
+                                    (15, 36,  39),
+                                    (15, 112, 113));
+
+multi Pythagorean-triples($N where * == 1|2|4) { -1 }
+
+multi Pythagorean-triples($N where $N > 0)
+{
+    gather
+    {
+        SEQ: for 2, 4 ... * -> $r
+        {
+            for factor-pairs(($r**2/2).Int) -> $p
+            {
+                my $x = $r + $p[0];
+                my $y = $r + $p[1];
+                my $z = $r + $p[0] + $p[1];
+        
+                take ($x, $y, $z) if any($x, $y, $z) == $N;
+
+                last SEQ if $x == $N and $z - $y == 1|2;
+            }
+        }
+    }
+}
+
+sub factor-pairs($n)
+{
+    gather
+    {
+        for 1..9 -> $div
+        {
+            if $n %% $div
+            {
+                my $tail = $n div $div;
+                last if $div > $tail;
+                take ($div, $tail);
+            }
+        }
+    }
+}
-- 
cgit 


From 5790b78867576c6f711b044d78e5c7b9f668793f Mon Sep 17 00:00:00 2001
From: Mark A <andemark@a-iot1t.uch.ad.pvt>
Date: Tue, 10 Aug 2021 05:32:43 -0600
Subject: never mind. numerous errors :(

---
 challenge-125/mark-anderson/raku/ch-1.raku | 62 ------------------------------
 1 file changed, 62 deletions(-)
 delete mode 100644 challenge-125/mark-anderson/raku/ch-1.raku

diff --git a/challenge-125/mark-anderson/raku/ch-1.raku b/challenge-125/mark-anderson/raku/ch-1.raku
deleted file mode 100644
index 577a55520b..0000000000
--- a/challenge-125/mark-anderson/raku/ch-1.raku
+++ /dev/null
@@ -1,62 +0,0 @@
-#!/usr/bin/env raku
-
-# Pythagorean-triples uses the Dickson method
-# https://en.wikipedia.org/wiki/Formulas_for_generating_Pythagorean_triples#Dickson's_method
-
-# factor-pairs uses the Rainbow method
-# https://www.chilimath.com/lessons/introductory-algebra/finding-all-the-factors-of-a-whole-number-using-the-rainbow-method
-
-use Test;
-plan 4;
-
-is-deeply Pythagorean-triples(5),  ((3, 4,  5),
-                                    (5, 12, 13));
-
-is-deeply Pythagorean-triples(13), ((5,  12, 13),
-                                    (13, 84, 85));
- 
-is Pythagorean-triples(1), -1;
-
-is-deeply Pythagorean-triples(15), ((8,  15,  17),
-                                    (9,  12,  15),
-                                    (15, 20,  25),
-                                    (15, 36,  39),
-                                    (15, 112, 113));
-
-multi Pythagorean-triples($N where * == 1|2|4) { -1 }
-
-multi Pythagorean-triples($N where $N > 0)
-{
-    gather
-    {
-        SEQ: for 2, 4 ... * -> $r
-        {
-            for factor-pairs(($r**2/2).Int) -> $p
-            {
-                my $x = $r + $p[0];
-                my $y = $r + $p[1];
-                my $z = $r + $p[0] + $p[1];
-        
-                take ($x, $y, $z) if any($x, $y, $z) == $N;
-
-                last SEQ if $x == $N and $z - $y == 1|2;
-            }
-        }
-    }
-}
-
-sub factor-pairs($n)
-{
-    gather
-    {
-        for 1..9 -> $div
-        {
-            if $n %% $div
-            {
-                my $tail = $n div $div;
-                last if $div > $tail;
-                take ($div, $tail);
-            }
-        }
-    }
-}
-- 
cgit 


From 6895c52b8cb0e2c5082a1e5be4066ed71d43ba5d Mon Sep 17 00:00:00 2001
From: Mark A <andemark@a-iot1t.uch.ad.pvt>
Date: Tue, 10 Aug 2021 08:15:56 -0600
Subject: Not very Raku-ish but I think it works now.

---
 challenge-125/mark-anderson/raku/ch-1.raku | 70 ++++++++++++++++++++++++++++++
 1 file changed, 70 insertions(+)
 create mode 100644 challenge-125/mark-anderson/raku/ch-1.raku

diff --git a/challenge-125/mark-anderson/raku/ch-1.raku b/challenge-125/mark-anderson/raku/ch-1.raku
new file mode 100644
index 0000000000..45d1b480c3
--- /dev/null
+++ b/challenge-125/mark-anderson/raku/ch-1.raku
@@ -0,0 +1,70 @@
+#!/usr/bin/env raku
+
+# Caveat: This program grabs all Pythagorean triples (not just the primitives)
+
+# py-tris uses the Dickson method
+# https://en.wikipedia.org/wiki/Formulas_for_generating_Pythagorean_triples#Dickson's_method
+
+# factor-pairs uses the Rainbow method
+# https://www.chilimath.com/lessons/introductory-algebra/finding-all-the-factors-of-a-whole-number-using-the-rainbow-method
+
+multi sub MAIN($N)
+{
+    .say for py-tris($N);
+}
+
+multi sub MAIN
+{
+    use Test;
+    plan 9;
+
+    is py-tris(1), -1;
+    is py-tris(2), -1;
+    is-deeply py-tris(3),  ((3, 4, 5),);
+    is-deeply py-tris(4),  ((3, 4, 5),);
+    is-deeply py-tris(5),  ((3, 4,  5), (5, 12, 13));
+    is-deeply py-tris(6),  ((6, 8, 10),);
+    is-deeply py-tris(13), ((5, 12, 13), (13, 84, 85));
+    is-deeply py-tris(15), ((8, 15, 17), (9, 12, 15), (15, 20, 25), (15, 36, 39), (15, 112, 113));
+    is-deeply py-tris(33), ((33, 56, 65), (33, 180, 183), (33, 544, 545));
+}
+
+multi py-tris($N where * == 1|2) { -1 }
+
+multi py-tris($N where * == 3|4) { (3,4,5), }
+
+multi py-tris($N where * > 0)
+{
+    gather
+    {
+        SEQ: for 2, 4 ... * -> $r
+        {
+            for factor-pairs(($r**2/2).Int) -> $p
+            {
+                my $x = $r + $p[0];
+                my $y = $r + $p[1];
+                my $z = $r + $p[0] + $p[1];
+        
+                take ($x, $y, $z) if any($x, $y, $z) == $N;
+
+                last SEQ if $x == $N and $z - $y == 1|2;
+            }
+        }
+    }
+}
+
+sub factor-pairs($n)
+{
+    gather
+    {
+        for 1..9 -> $div
+        {
+            if $n %% $div
+            {
+                my $tail = $n div $div;
+                last if $div > $tail;
+                take ($div, $tail);
+            }
+        }
+    }
+}
-- 
cgit 


From cb5a47e90829ac7089033d1c06d316b68ce7e986 Mon Sep 17 00:00:00 2001
From: Scimon <simon.proctor@gmail.com>
Date: Tue, 10 Aug 2021 15:39:23 +0100
Subject: Update to challenge 1

---
 challenge-125/simon-proctor/raku/ch-1.raku | 20 ++++++++++++++++++--
 1 file changed, 18 insertions(+), 2 deletions(-)

diff --git a/challenge-125/simon-proctor/raku/ch-1.raku b/challenge-125/simon-proctor/raku/ch-1.raku
index 5caf5d2c2d..348b00d445 100644
--- a/challenge-125/simon-proctor/raku/ch-1.raku
+++ b/challenge-125/simon-proctor/raku/ch-1.raku
@@ -24,8 +24,24 @@ multi sub MAIN(UInt $N where * > 0) {
 sub py-triples(UInt $N) {
     my @out;
     
-    my @odds = (1,*+2...* >= $N).cache;
+    #my @odds = (1,*+2...* >= $N).cache;
+    
+    #return (@odds X, @odds).hyper.grep( -> ($m, $n) { $m > $n } ).map( -> ( $m, $n ) { note ($m,$n); (  ($m * $n), ( ($m²-$n²)/2), ( ($m² + $n²)/2 ) ) } ).grep( -> $pos { note $pos; $N ~~ $pos.any; } );
+
+    my $as = start ((1..^$N) X, (1..^$N²)).hyper
+                                  .grep( -> ($a,$b) { $b >= $a } )
+                                  .grep( -> ($a,$b) { $N² == $a² + $b² } )
+                                  .map( -> ($a, $b) { ( $a, $b, $N ).sort } );
+
+    my $cs = start (($N^..($N² div 2)) X, ($N^..($N² div 2)+1)).hyper
+                                     .grep( -> ($a,$c) { $c >= $a } )
+                                     .grep( -> ($a,$c) { $N² + $a² == $c² } )
+                                     .map( -> ($a, $c) { ( $a, $N, $c ).sort } );
+                                     
+    await $as, $cs;
+    
+    return |$as.result , |$cs.result;
 
-    return (@odds X, @odds).hyper.grep( -> ($m, $n) { $m > $n } ).map( -> ( $m, $n ) { (  ($m * $n), ( ($m²-$n²)/2), ( ($m² + $n²)/2 ) ) } ).grep( -> $pos { $N ~~ $pos.any; } );
+                                                                                                                       
 }
   
-- 
cgit 


From 316bb93b2b781ef5e37adc23a28db06ca363472a Mon Sep 17 00:00:00 2001
From: Scimon <simon.proctor@gmail.com>
Date: Tue, 10 Aug 2021 15:40:59 +0100
Subject: Update to challenge 1

---
 challenge-125/simon-proctor/raku/ch-1.raku | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/challenge-125/simon-proctor/raku/ch-1.raku b/challenge-125/simon-proctor/raku/ch-1.raku
index 348b00d445..c580a2e678 100644
--- a/challenge-125/simon-proctor/raku/ch-1.raku
+++ b/challenge-125/simon-proctor/raku/ch-1.raku
@@ -33,7 +33,7 @@ sub py-triples(UInt $N) {
                                   .grep( -> ($a,$b) { $N² == $a² + $b² } )
                                   .map( -> ($a, $b) { ( $a, $b, $N ).sort } );
 
-    my $cs = start (($N^..($N² div 2)) X, ($N^..($N² div 2)+1)).hyper
+    my $cs = start ((1..($N² div 2)) X, (1..($N² div 2)+1)).hyper
                                      .grep( -> ($a,$c) { $c >= $a } )
                                      .grep( -> ($a,$c) { $N² + $a² == $c² } )
                                      .map( -> ($a, $c) { ( $a, $N, $c ).sort } );
-- 
cgit 


From ef6b617f44a1d0998e767bdea638c671b4180e01 Mon Sep 17 00:00:00 2001
From: Scimon <simon.proctor@gmail.com>
Date: Tue, 10 Aug 2021 15:47:57 +0100
Subject: Small fix

---
 challenge-125/simon-proctor/raku/ch-1.raku | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/challenge-125/simon-proctor/raku/ch-1.raku b/challenge-125/simon-proctor/raku/ch-1.raku
index c580a2e678..1d911c8085 100644
--- a/challenge-125/simon-proctor/raku/ch-1.raku
+++ b/challenge-125/simon-proctor/raku/ch-1.raku
@@ -28,7 +28,7 @@ sub py-triples(UInt $N) {
     
     #return (@odds X, @odds).hyper.grep( -> ($m, $n) { $m > $n } ).map( -> ( $m, $n ) { note ($m,$n); (  ($m * $n), ( ($m²-$n²)/2), ( ($m² + $n²)/2 ) ) } ).grep( -> $pos { note $pos; $N ~~ $pos.any; } );
 
-    my $as = start ((1..^$N) X, (1..^$N²)).hyper
+    my $as = start ((1..^$N) X, (1..^$N)).hyper
                                   .grep( -> ($a,$b) { $b >= $a } )
                                   .grep( -> ($a,$b) { $N² == $a² + $b² } )
                                   .map( -> ($a, $b) { ( $a, $b, $N ).sort } );
-- 
cgit 


From e0e7bd9c6f99fa775f8d41e44379e11ac2080b67 Mon Sep 17 00:00:00 2001
From: Scimon <simon.proctor@gmail.com>
Date: Tue, 10 Aug 2021 15:57:31 +0100
Subject: Simplify

---
 challenge-125/simon-proctor/raku/ch-1.raku | 25 ++++---------------------
 1 file changed, 4 insertions(+), 21 deletions(-)

diff --git a/challenge-125/simon-proctor/raku/ch-1.raku b/challenge-125/simon-proctor/raku/ch-1.raku
index 1d911c8085..0dde3bf6eb 100644
--- a/challenge-125/simon-proctor/raku/ch-1.raku
+++ b/challenge-125/simon-proctor/raku/ch-1.raku
@@ -22,26 +22,9 @@ multi sub MAIN(UInt $N where * > 0) {
 }
 
 sub py-triples(UInt $N) {
-    my @out;
-    
-    #my @odds = (1,*+2...* >= $N).cache;
-    
-    #return (@odds X, @odds).hyper.grep( -> ($m, $n) { $m > $n } ).map( -> ( $m, $n ) { note ($m,$n); (  ($m * $n), ( ($m²-$n²)/2), ( ($m² + $n²)/2 ) ) } ).grep( -> $pos { note $pos; $N ~~ $pos.any; } );
-
-    my $as = start ((1..^$N) X, (1..^$N)).hyper
-                                  .grep( -> ($a,$b) { $b >= $a } )
-                                  .grep( -> ($a,$b) { $N² == $a² + $b² } )
-                                  .map( -> ($a, $b) { ( $a, $b, $N ).sort } );
-
-    my $cs = start ((1..($N² div 2)) X, (1..($N² div 2)+1)).hyper
-                                     .grep( -> ($a,$c) { $c >= $a } )
-                                     .grep( -> ($a,$c) { $N² + $a² == $c² } )
-                                     .map( -> ($a, $c) { ( $a, $N, $c ).sort } );
-                                     
-    await $as, $cs;
-    
-    return |$as.result , |$cs.result;
-
-                                                                                                                       
+    return ((1..($N² div 2)) X, (1..($N² div 2)+1)).hyper
+                                     .grep( -> ($a,$b) { $b >= $a } )
+                                     .grep( -> ($a,$b) { $N² + $a² == $b² || $N² == $a² + $b² } )
+                                     .map(  -> ($a,$b) { ( $a, $b, $N ).sort } );
 }
   
-- 
cgit 


From 80a7812ffe6393fa6fea265055ff31eefd83f38e Mon Sep 17 00:00:00 2001
From: Scimon <simon.proctor@gmail.com>
Date: Tue, 10 Aug 2021 16:02:06 +0100
Subject: Fix test cases

---
 challenge-125/simon-proctor/raku/ch-1.raku | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/challenge-125/simon-proctor/raku/ch-1.raku b/challenge-125/simon-proctor/raku/ch-1.raku
index 0dde3bf6eb..ba39055309 100644
--- a/challenge-125/simon-proctor/raku/ch-1.raku
+++ b/challenge-125/simon-proctor/raku/ch-1.raku
@@ -8,7 +8,7 @@ multi sub MAIN('test') is hidden-from-USAGE {
     is py-triples(3), ( (3,4,5) );
     is py-triples(4), ( (3,4,5) );
     is py-triples(5), ( (3,4,5), (5,12,13) );
-    is py-triples(6), ();
+    is py-triples(6), ( (6,8,10) );
     is py-triples(13), ( (5,12,13), (13, 84, 85) );
 
     done-testing;
-- 
cgit 


From e808986da634b43d1ef36d0952ce8b2a2c5d821d Mon Sep 17 00:00:00 2001
From: Scimon <simon.proctor@gmail.com>
Date: Tue, 10 Aug 2021 16:05:58 +0100
Subject: Removed unused ods list

---
 challenge-125/simon-proctor/raku/ch-1.raku | 2 --
 1 file changed, 2 deletions(-)

diff --git a/challenge-125/simon-proctor/raku/ch-1.raku b/challenge-125/simon-proctor/raku/ch-1.raku
index ba39055309..353150f240 100644
--- a/challenge-125/simon-proctor/raku/ch-1.raku
+++ b/challenge-125/simon-proctor/raku/ch-1.raku
@@ -1,7 +1,5 @@
 #!/usr/bin/env raku
 
-my @odds = (1,*+2...*).cache;
-
 multi sub MAIN('test') is hidden-from-USAGE {
     use Test;
 
-- 
cgit 


From c07ad5febc4d9cf8fc5983a2286b77ca131f6f77 Mon Sep 17 00:00:00 2001
From: Mark A <andemark@a-iot1t.uch.ad.pvt>
Date: Tue, 10 Aug 2021 09:46:39 -0600
Subject: minor touch-up

---
 challenge-125/mark-anderson/raku/ch-1.raku | 5 ++---
 1 file changed, 2 insertions(+), 3 deletions(-)

diff --git a/challenge-125/mark-anderson/raku/ch-1.raku b/challenge-125/mark-anderson/raku/ch-1.raku
index 45d1b480c3..1099bfbccb 100644
--- a/challenge-125/mark-anderson/raku/ch-1.raku
+++ b/challenge-125/mark-anderson/raku/ch-1.raku
@@ -8,12 +8,12 @@
 # factor-pairs uses the Rainbow method
 # https://www.chilimath.com/lessons/introductory-algebra/finding-all-the-factors-of-a-whole-number-using-the-rainbow-method
 
-multi sub MAIN($N)
+multi MAIN($N)
 {
     .say for py-tris($N);
 }
 
-multi sub MAIN
+multi MAIN
 {
     use Test;
     plan 9;
@@ -46,7 +46,6 @@ multi py-tris($N where * > 0)
                 my $z = $r + $p[0] + $p[1];
         
                 take ($x, $y, $z) if any($x, $y, $z) == $N;
-
                 last SEQ if $x == $N and $z - $y == 1|2;
             }
         }
-- 
cgit 


From b53039528e50ab4c3308e3cb1ce8e66aa55b96e4 Mon Sep 17 00:00:00 2001
From: "E. Choroba" <choroba@matfyz.cz>
Date: Tue, 10 Aug 2021 18:37:27 +0200
Subject: Solve 125: Pythagorean Triples & Binary Tree Diameter by E. Choroba

---
 challenge-125/e-choroba/perl/ch-1.pl | 78 ++++++++++++++++++++++++++++++++++++
 challenge-125/e-choroba/perl/ch-2.pl | 61 ++++++++++++++++++++++++++++
 2 files changed, 139 insertions(+)
 create mode 100755 challenge-125/e-choroba/perl/ch-1.pl
 create mode 100755 challenge-125/e-choroba/perl/ch-2.pl

diff --git a/challenge-125/e-choroba/perl/ch-1.pl b/challenge-125/e-choroba/perl/ch-1.pl
new file mode 100755
index 0000000000..9b7c931499
--- /dev/null
+++ b/challenge-125/e-choroba/perl/ch-1.pl
@@ -0,0 +1,78 @@
+#!/usr/bin/perl
+use warnings;
+use strict;
+
+sub pythagorean_triples {
+    my ($n) = @_;
+    my @solutions;
+    my $nsquare = $n * $n;
+
+    # A <= B < C
+
+    # A**2 + n**2 = C**2
+    for my $A (1 .. $n) {
+        my $B = sqrt($nsquare - $A * $A);
+        last if $B < $A;
+
+        push @solutions, [$A, $B, $n]
+            if $B == int $B;
+    }
+
+    # A**2 + n**2 = C**2
+    for my $A (1 .. $n) {
+        my $C = sqrt($A * $A + $nsquare);
+        push @solutions, [$A, $n, $C]
+            if $C == int $C;
+    }
+
+    # n**2 + B ** 2 = C**2
+    my $B = $n;
+    while (1) {
+        my $C = sqrt($nsquare + $B * $B);
+        last if $C - $B < 1;
+
+        push @solutions, [$n, $B, $C]
+            if $C == int $C;
+    } continue {
+        ++$B;
+    }
+
+    return @solutions ? \@solutions : -1
+}
+
+use Test2::V0;
+plan 5;
+
+is pythagorean_triples(5),
+    bag { item [3, 4, 5];
+          item [5, 12, 13];
+          end },
+    'Example 1';
+
+is pythagorean_triples(13),
+    bag { item [5, 12, 13];
+          item [13, 84, 85];
+          end },
+    'Example 2';
+
+is pythagorean_triples(1), -1, 'Example 3';
+
+is pythagorean_triples(12),
+    bag { item [ 5,  12,  13];
+          item [ 9,  12,  15];
+          item [12,  16,  20];
+          item [12,  35,  37];
+          end },
+    'N=12';
+
+is pythagorean_triples(40),
+    bag { item [ 9,  40,  41];
+          item [24,  32,  40];
+          item [30,  40,  50];
+          item [40,  42,  58];
+          item [40,  75,  85];
+          item [40,  96, 104];
+          item [40, 198, 202];
+          item [40, 399, 401];
+          end },
+    'N=40';
diff --git a/challenge-125/e-choroba/perl/ch-2.pl b/challenge-125/e-choroba/perl/ch-2.pl
new file mode 100755
index 0000000000..b8201c91c5
--- /dev/null
+++ b/challenge-125/e-choroba/perl/ch-2.pl
@@ -0,0 +1,61 @@
+#! /usr/bin/perl
+use warnings;
+use strict;
+
+{   package Node;
+    use Moo;
+    use List::Util qw{ max sum };
+    use namespace::clean;
+
+    has value => (is => 'ro');
+    has [qw[ left right ]] => (is => 'rw');
+
+    sub new_from_structure {
+        my ($class, $structure) = @_;
+        my $self = $class->new(value => $structure->[0]);
+        my @ch = @{ $structure->[1] };
+        if (defined $ch[0][0]) {
+            my $left  = $ch[0][1]
+                ? 'Node'->new_from_structure([$ch[0][0], $ch[0][1]])
+                : 'Node'->new(value => $ch[0][0]);
+            $self->left($left);
+        }
+        if (defined $ch[1][0]) {
+            my $right  = $ch[1][1]
+                ? 'Node'->new_from_structure([$ch[1][0], $ch[1][1]])
+                : 'Node'->new(value => $ch[1][0]);
+            $self->right($right);
+        }
+        return $self
+    }
+
+    sub children {
+        my ($self) = @_;
+        return grep defined, $self->left, $self->right
+    }
+
+