From b9261a75ac76d2fc12a4d5ee179e2be3bb5a57c9 Mon Sep 17 00:00:00 2001
From: drbaggy <js5@sanger.ac.uk>
Date: Mon, 26 Jul 2021 12:31:09 +0100
Subject: solution 2...

---
 challenge-123/james-smith/perl/ch-1.pl | 22 ++++++++++++++++++
 challenge-123/james-smith/perl/ch-2.pl | 42 ++++++++++++++++++++++++++++++++++
 2 files changed, 64 insertions(+)
 create mode 100644 challenge-123/james-smith/perl/ch-1.pl
 create mode 100644 challenge-123/james-smith/perl/ch-2.pl

diff --git a/challenge-123/james-smith/perl/ch-1.pl b/challenge-123/james-smith/perl/ch-1.pl
new file mode 100644
index 0000000000..2348c8b946
--- /dev/null
+++ b/challenge-123/james-smith/perl/ch-1.pl
@@ -0,0 +1,22 @@
+#!/usr/local/bin/perl
+
+use strict;
+
+use warnings;
+use feature qw(say);
+use Test::More;
+use Benchmark qw(cmpthese timethis);
+use Data::Dumper qw(Dumper);
+
+my @TESTS = (
+  [ 0, 1 ],
+);
+
+is( my_function($_->[0]), $_->[1] ) foreach @TESTS;
+
+done_testing();
+
+sub my_function {
+  return 1;
+}
+
diff --git a/challenge-123/james-smith/perl/ch-2.pl b/challenge-123/james-smith/perl/ch-2.pl
new file mode 100644
index 0000000000..af4005104e
--- /dev/null
+++ b/challenge-123/james-smith/perl/ch-2.pl
@@ -0,0 +1,42 @@
+#!/usr/local/bin/perl
+
+use strict;
+
+use warnings;
+use feature qw(say);
+use Test::More;
+use Benchmark qw(cmpthese timethis);
+use Data::Dumper qw(Dumper);
+
+my @TESTS = (
+  [ [ [10,20],[20,20],[20,10],[10,10] ], 1 ],
+  [ [ [12,24],[16,10],[20,12],[18,16] ], 0 ],
+);
+
+is( is_square(@{$_->[0]}), $_->[1] ) foreach @TESTS;
+
+done_testing();
+
+sub is_square {
+  my @pts = @_;
+
+  ## If we measure the squared distances between each
+  ## pari of points of a square we get two distances -
+  ## the edge and diagonal.
+  ## The latter being twice the former...
+  ##
+  ## No other combination of points has this property.
+
+  ## Compute distances...
+  my %D;
+  while(@pts>1) {
+    my $a = shift @pts;
+    $D{($a->[0]-$_->[0])**2+($a->[1]-$_->[1])**2}++ foreach @pts;
+  }
+  my @K = keys %D;
+  return 0 unless @K== 2;      ## More than two distances
+  return 1 if $K[0]*2==$K[1];  ## First no is the diagonal
+  return 1 if $K[1]*2==$K[0];  ## First no is the edge..
+  return 0;                    ## Equilat triangles..
+}
+
-- 
cgit 


From 3ebea6660bb9e212bb39008590758a023f7a71de Mon Sep 17 00:00:00 2001
From: drbaggy <js5@sanger.ac.uk>
Date: Mon, 26 Jul 2021 12:50:07 +0100
Subject: I think there is a bit of nasty code to add to "nth-ugly" to speed
 this up - which remembers where to start the inner for loops - but need to
 get my brain around it - at least this works - and is better than a full scan
 of 1..N as n gets larger

---
 challenge-123/james-smith/perl/ch-1.pl | 29 ++++++++++++++++++++++-------
 1 file changed, 22 insertions(+), 7 deletions(-)

diff --git a/challenge-123/james-smith/perl/ch-1.pl b/challenge-123/james-smith/perl/ch-1.pl
index 2348c8b946..6c24f48516 100644
--- a/challenge-123/james-smith/perl/ch-1.pl
+++ b/challenge-123/james-smith/perl/ch-1.pl
@@ -3,20 +3,35 @@
 use strict;
 
 use warnings;
-use feature qw(say);
+use feature qw(say state);
 use Test::More;
 use Benchmark qw(cmpthese timethis);
 use Data::Dumper qw(Dumper);
 
-my @TESTS = (
-  [ 0, 1 ],
-);
+my @uglies = qw(1 2 3 4 5 6 8 9 10 12 15 16 18 20 24 25 27 30 32 36 40 45 48 50 54 60 64 72 75 80 81 90 96 100 108 120 125 128 135 144 150 160 162 180 192 200 216 225 240 243 250 256 270 288 300 320 324 360 375 384 400 405 432 450 480 486 500 512 540 576 600 625 640 648 675 720 729 750 768 800 810 864 900 960 972 1000);
 
-is( my_function($_->[0]), $_->[1] ) foreach @TESTS;
+my $c=0;
+my @TESTS = map { [ ++$c, $_ ] } @uglies;
 
+is( nth_ugly($_->[0]), $_->[1] ) foreach @TESTS;
 done_testing();
 
-sub my_function {
-  return 1;
+sub nth_ugly {
+  my $n = shift;
+  state @uglies;
+  @uglies=(1) unless @uglies;
+  while(1) {
+    return $uglies[$n-1] if $n <= @uglies;
+    ## Get the next ugly....
+    my $next = 0;
+    foreach my $n (5,3,2) {
+      foreach(@uglies) {
+        next if $_ * $n <= $uglies[-1];
+        $next = $_*$n if !$next || $next > $_*$n;
+        last;
+      }
+    }
+    push @uglies, $next;
+  }
 }
 
-- 
cgit 


From 039bd71627180c2b0c921114d94d5529f145aa00 Mon Sep 17 00:00:00 2001
From: drbaggy <js5@sanger.ac.uk>
Date: Mon, 26 Jul 2021 12:51:56 +0100
Subject: I think there is a bit of nasty code to add to "nth-ugly" to speed
 this up - which remembers where to start the inner for loops - but need to
 get my brain around it - at least this works - and is better than a full scan
 of 1..N as n gets larger

---
 challenge-123/james-smith/perl/ch-1.pl | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/challenge-123/james-smith/perl/ch-1.pl b/challenge-123/james-smith/perl/ch-1.pl
index 6c24f48516..fddf7775f4 100644
--- a/challenge-123/james-smith/perl/ch-1.pl
+++ b/challenge-123/james-smith/perl/ch-1.pl
@@ -18,8 +18,7 @@ done_testing();
 
 sub nth_ugly {
   my $n = shift;
-  state @uglies;
-  @uglies=(1) unless @uglies;
+  state @uglies = (1);
   while(1) {
     return $uglies[$n-1] if $n <= @uglies;
     ## Get the next ugly....
-- 
cgit 


From aa609a626af59795fc92e62bdbdb8fa446728602 Mon Sep 17 00:00:00 2001
From: chirvasitua <chirvasitua@gmail.com>
Date: Mon, 26 Jul 2021 08:41:50 -0400
Subject: 1st commit on 123_raku

---
 challenge-123/stuart-little/raku/ch-1.raku | 14 ++++++++++++++
 challenge-123/stuart-little/raku/ch-2.raku | 21 +++++++++++++++++++++
 2 files changed, 35 insertions(+)
 create mode 100755 challenge-123/stuart-little/raku/ch-1.raku
 create mode 100755 challenge-123/stuart-little/raku/ch-2.raku

diff --git a/challenge-123/stuart-little/raku/ch-1.raku b/challenge-123/stuart-little/raku/ch-1.raku
new file mode 100755
index 0000000000..1dee01f189
--- /dev/null
+++ b/challenge-123/stuart-little/raku/ch-1.raku
@@ -0,0 +1,14 @@
+#!/usr/bin/env raku
+use v6;
+
+# run as <script> <number $n> to return the first $n ugly numbers
+
+my %memo=((1,2,3,5) X=> 1).Hash;
+
+sub smth5p($n) { %memo{$n} && return True; return (my $den=(2,3,5).first({ $n %% $_ })) ?? (%memo{$n div $den} && (%memo{$n}=1).Bool || False) !! (False) }
+
+my ($count,$nr)=(0,0);
+while ($count < @*ARGS[0].Int) {
+    $nr+=1;
+    ($nr.&smth5p) && do { say $nr; $count+=1; };    
+}
diff --git a/challenge-123/stuart-little/raku/ch-2.raku b/challenge-123/stuart-little/raku/ch-2.raku
new file mode 100755
index 0000000000..464bfb3b9e
--- /dev/null
+++ b/challenge-123/stuart-little/raku/ch-2.raku
@@ -0,0 +1,21 @@
+#!/usr/bin/env raku
+use v6;
+
+# run <script> <x1 y1 x2 y2 ..>
+
+sub sqDist($x1, $y1, $x2, $y2) {
+    return ($x2-$x1)**2 + ($y2-$y1)**2;
+}
+
+sub sqDistHash(@coords) {
+    my %h;
+    @coords.rotor(2).combinations(2).map({ sqDist(|$_.[0], |$_.[1]) }).map({ %h{$_}++ });
+    return %h;
+}
+
+sub isSq(@coords) {
+    my @distCounts = sqDistHash(@coords).values;
+    return (@distCounts.grep(2) && @distCounts.grep(4)).Bool;
+}
+
+say isSq(@*ARGS[0..7].map(*.Num)).Int;
-- 
cgit 


From 689f8d95e8740cd40d4b7cda2ea94b9889496314 Mon Sep 17 00:00:00 2001
From: Abigail <abigail@abigail.be>
Date: Mon, 26 Jul 2021 15:10:54 +0200
Subject: README for week 123

---
 challenge-123/abigail/README.md | 88 ++++++++++++++++-------------------------
 1 file changed, 34 insertions(+), 54 deletions(-)

diff --git a/challenge-123/abigail/README.md b/challenge-123/abigail/README.md
index fff6c14deb..c951c7d008 100644
--- a/challenge-123/abigail/README.md
+++ b/challenge-123/abigail/README.md
@@ -1,78 +1,58 @@
 # Solutions by Abigail
-## [Average of Stream][task1]
+## [Ugly Numbers][task1]
 
-> You are given a stream of numbers, `@N`.
->
-> Write a script to print the average of the stream at every point.
+> You are given an integer `$n >= 1`.
+> 
+> Write a script to find the $nth element of Ugly Numbers.
+> 
+> > Ugly numbers are those number whose prime factors are `2`, `3` or `5`.
+> > For example, the first 10 Ugly Numbers are `1`, `2`, `3`, `4`, `5`,
+> > `6`, `8`, `9`, `10`, `12`.
 
-### Example
-~~~~
-Input: @N = (10, 20, 30, 40, 50, 60, 70, 80, 90, ...)
-Output:      10, 15, 20, 25, 30, 35, 40, 45, 50, ...
+### Examples
 ~~~~
+Input: $n = 7
+Output: 8
 
-* Average of first number is `10`.
-* Average of first 2 numbers `(10+20)/2 = 15`.
-* Average of first 3 numbers `(10+20+30)/3 = 20`.
-* Average of first 4 numbers `(10+20+30+40)/4 = 25` and so on.
+Input: $n = 10
+Output: 12
+~~~~
 
 ### Solutions
 * [AWK](awk/ch-1.awk)
 * [Bash](bash/ch-1.sh)
-* [Basic](basic/ch-1.bas)
-* [bc](bc/ch-1.bc)
-* [Befunge-93](befunge-93/ch-1.bf)
 * [C](c/ch-1.c)
-* [Go](go/ch-1.go)
-* [Java](java/ch-1.java)
 * [Lua](lua/ch-1.lua)
 * [Node.js](node/ch-1.js)
-* [Pascal](pascal/ch-1.p)
 * [Perl](perl/ch-1.pl)
 * [Python](python/ch-1.py)
-* [R](r/ch-1.r)
 * [Ruby](ruby/ch-1.rb)
-* [Scheme](scheme/ch-1.scm)
-* [Tcl](tcl/ch-1.tcl)
 
 ### Blog
-[Average of Stream][blog1]
+[Perl Weekly Challenge 123: Ugly Numbers][blog1]
 
-## [Basketball Points][task2]
+## [Square Points][task2]
 
-> You are given a score `$S`.
+> You are given coordinates of four points i.e. `(x1, y1)`, `(x2, y2)`,
+> `(x3, y3)` and `(x4, y4)`.
 > 
-> You can win basketball points e.g. `1` point, `2` points and `3` points.
->
-> Write a script to find out the different ways you can score `$S`.
+> Write a script to find out if the given four points form a square.
 
 ### Examples
 ~~~~
-Input: $S = 4
-Output: 1 1 1 1
-        1 1 2
-        1 2 1
-        1 3
-        2 1 1
-        2 2
-        3 1
+Input: x1 = 10, y1 = 20
+       x2 = 20, y2 = 20
+       x3 = 20, y3 = 10
+       x4 = 10, y4 = 10
+Output: 1 as the given coordinates form a square.
 ~~~~
 
 ~~~~
-Input: $S = 5
-Output: 1 1 1 1 1
-        1 1 1 2
-        1 1 2 1
-        1 1 3
-        1 2 1 1
-        1 2 2
-        1 3 1
-        2 1 1 1
-        2 1 2
-        2 2 1
-        2 3
-        3 1 1
-        3 2
+Input: x1 = 12, y1 = 24
+       x2 = 16, y2 = 10
+       x3 = 20, y3 = 12
+       x4 = 18, y4 = 16
+Output: 0 as the given coordinates doesn't form a square.
 ~~~~
 
 ### Solutions
@@ -86,11 +66,11 @@ Output: 1 1 1 1 1
 * [Ruby](ruby/ch-2.rb)
 
 ### Blog
-[Basketball Points][blog2]
+[Perl Weekly Challenge 123: Square Points][blog2]
 
 
 
-[task1]: https://perlweeklychallenge.org/blog/perl-weekly-challenge-122/#TASK1
-[task1]: https://perlweeklychallenge.org/blog/perl-weekly-challenge-122/#TASK2
-[blog1]: https://abigail.github.io/HTML/Perl-Weekly-Challenge/week-122-1.html
-[blog2]: https://abigail.github.io/HTML/Perl-Weekly-Challenge/week-122-2.html
+[task1]: https://perlweeklychallenge.org/blog/perl-weekly-challenge-123/#TASK1
+[task2]: https://perlweeklychallenge.org/blog/perl-weekly-challenge-123/#TASK2
+[blog1]: https://abigail.github.io/HTML/Perl-Weekly-Challenge/week-123-1.html
+[blog2]: https://abigail.github.io/HTML/Perl-Weekly-Challenge/week-123-2.html
-- 
cgit 


From 4bd4a0597d7daf14e896389b66628b66a65b785e Mon Sep 17 00:00:00 2001
From: chirvasitua <chirvasitua@gmail.com>
Date: Mon, 26 Jul 2021 09:25:19 -0400
Subject: 1st commit on 123_perl

---
 challenge-123/stuart-little/perl/ch-1.pl | 27 +++++++++++++++++++++++++++
 challenge-123/stuart-little/perl/ch-2.pl | 30 ++++++++++++++++++++++++++++++
 2 files changed, 57 insertions(+)
 create mode 100755 challenge-123/stuart-little/perl/ch-1.pl
 create mode 100755 challenge-123/stuart-little/perl/ch-2.pl

diff --git a/challenge-123/stuart-little/perl/ch-1.pl b/challenge-123/stuart-little/perl/ch-1.pl
new file mode 100755
index 0000000000..11ab4cf035
--- /dev/null
+++ b/challenge-123/stuart-little/perl/ch-1.pl
@@ -0,0 +1,27 @@
+#!/usr/bin/env perl
+use warnings;
+use v5.12;
+
+# run as <script> <number $n> to return the first $n ugly numbers
+
+use feature qw(signatures);
+no warnings qw(experimental::signatures);
+
+use List::Util qw(first);
+
+my %memo = map { $_ => 1 } (1,2,3,5);
+
+sub smth5p($n) {
+    $memo{$n} && return 1;
+    my $den = first {$n % $_ ==0} (2,3,5);
+    return ($den ? ($memo{int($n/$den)} && ($memo{$n}=1)) : 0)
+}
+
+my ($count,$nr)=(0,0);
+while ($count < $ARGV[0]) {
+    $nr+=1;
+    (smth5p($nr)) && do {
+	say $nr;
+	$count+=1;
+    };    
+}
diff --git a/challenge-123/stuart-little/perl/ch-2.pl b/challenge-123/stuart-little/perl/ch-2.pl
new file mode 100755
index 0000000000..92845bec74
--- /dev/null
+++ b/challenge-123/stuart-little/perl/ch-2.pl
@@ -0,0 +1,30 @@
+#!/usr/bin/env perl
+use warnings;
+use v5.12;
+
+# run <script> <x1 y1 x2 y2 ..>
+
+use feature qw(signatures);
+no warnings qw(experimental::signatures);
+
+sub sqDist($x1, $y1, $x2, $y2) {
+    return ($x2-$x1)**2 + ($y2-$y1)**2;
+}
+
+sub sqDistHash($coords) {
+    my %h;
+    for my $i (0..2) {
+	for my $j ($i+1..3) {
+	    $h{sqDist($coords->[2*$i],$coords->[2*$i+1],$coords->[2*$j],$coords->[2*$j+1])}++;
+	}
+    }
+    return \%h;
+}
+
+sub isSq($coords) {
+    my @distCounts = values %{sqDistHash($coords)};
+    return(((grep {$_==2} @distCounts) && (grep {$_==4} @distCounts)) ? (1) : (0));
+}
+
+my @coords=@ARGV[0..7];
+say isSq(\@coords);
-- 
cgit 


From 6c0b8d1040bd4dfdbd3f90ef0d8fcc66e21a5673 Mon Sep 17 00:00:00 2001
From: chirvasitua <stuart-little@users.noreply.github.com>
Date: Mon, 26 Jul 2021 10:06:40 -0400
Subject: 1st commit on 123_haskell

---
 challenge-123/stuart-little/haskell/ch-1.hs | 13 +++++++++++++
 challenge-123/stuart-little/haskell/ch-2.hs | 20 ++++++++++++++++++++
 2 files changed, 33 insertions(+)
 create mode 100755 challenge-123/stuart-little/haskell/ch-1.hs
 create mode 100755 challenge-123/stuart-little/haskell/ch-2.hs

diff --git a/challenge-123/stuart-little/haskell/ch-1.hs b/challenge-123/stuart-little/haskell/ch-1.hs
new file mode 100755
index 0000000000..614550e161
--- /dev/null
+++ b/challenge-123/stuart-little/haskell/ch-1.hs
@@ -0,0 +1,13 @@
+#!/usr/bin/env runghc
+
+-- run as <script> <number $n> to return the first $n ugly numbers
+
+import System.Environment (getArgs,)
+import Data.List.Ordered (merge,nub,)
+
+smth = let primes=[2,3,5]
+  in nub (1:(foldl1 merge $ map (\x -> map (x*) $ nub $ smth) primes))
+
+main = do
+  (nr:_) <- getArgs
+  mapM_ putStrLn $ map show $ take (read nr::Int) $ smth
diff --git a/challenge-123/stuart-little/haskell/ch-2.hs b/challenge-123/stuart-little/haskell/ch-2.hs
new file mode 100755
index 0000000000..8590b95b16
--- /dev/null
+++ b/challenge-123/stuart-little/haskell/ch-2.hs
@@ -0,0 +1,20 @@
+#!/usr/bin/env runghc
+
+-- run <script> <x1 y1 x2 y2 ..>
+
+import Data.List (sort)
+import Data.List.Split (chunksOf)
+import System.Environment (getArgs)
+import Test.LeanCheck.Stats (counts)
+
+sqDist :: Num a => a -> a -> a -> a -> a
+sqDist x1 y1 x2 y2 = (x2-x1)*(x2-x1) + (y2-y1)*(y2-y1)
+
+sqDistHash :: (Eq a,Num a) => [a] -> [(a,Int)]
+sqDistHash xs = let pts = chunksOf 2 xs in counts $ [sqDist x1 y1 x2 y2 | [[x1,y1],[x2,y2]] <- sequence [pts,pts] ]
+
+isSq :: (Eq a,Num a) => [a] -> Bool
+isSq xs = (sort $ map snd $ sqDistHash xs) == [4,4,8]
+
+main :: IO ()
+main = getArgs >>= putStrLn . show . fromEnum . isSq . map (read::String->Double).(take 8)
-- 
cgit 


From cb35258c4b2e7de233d859e068edea04ca80b584 Mon Sep 17 00:00:00 2001
From: Abigail <abigail@abigail.be>
Date: Mon, 26 Jul 2021 15:13:23 +0200
Subject: Tests for week 123

---
 challenge-123/abigail/t/ctest.ini      | 8 ++++++++
 challenge-123/abigail/t/input-1-1      | 2 ++
 challenge-123/abigail/t/input-2-1      | 2 ++
 challenge-123/abigail/t/output-1-1.exp | 2 ++
 challenge-123/abigail/t/output-2-1.exp | 2 ++
 5 files changed, 16 insertions(+)
 create mode 100644 challenge-123/abigail/t/ctest.ini
 create mode 100644 challenge-123/abigail/t/input-1-1
 create mode 100644 challenge-123/abigail/t/input-2-1
 create mode 100644 challenge-123/abigail/t/output-1-1.exp
 create mode 100644 challenge-123/abigail/t/output-2-1.exp

diff --git a/challenge-123/abigail/t/ctest.ini b/challenge-123/abigail/t/ctest.ini
new file mode 100644
index 0000000000..527781acbb
--- /dev/null
+++ b/challenge-123/abigail/t/ctest.ini
@@ -0,0 +1,8 @@
+# 
+# Configuration file for running tests, using ctest.
+# See https://github.com/Abigail/Misc/blob/master/ctest
+# 
+
+[names]
+1-1 = Given Examples
+2-1 = Given Examples
diff --git a/challenge-123/abigail/t/input-1-1 b/challenge-123/abigail/t/input-1-1
new file mode 100644
index 0000000000..1831e2e66c
--- /dev/null
+++ b/challenge-123/abigail/t/input-1-1
@@ -0,0 +1,2 @@
+7
+10
diff --git a/challenge-123/abigail/t/input-2-1 b/challenge-123/abigail/t/input-2-1
new file mode 100644
index 0000000000..cdeb69af2f
--- /dev/null
+++ b/challenge-123/abigail/t/input-2-1
@@ -0,0 +1,2 @@
+10 20 20 20 20 10 10 10
+12 24 16 10 20 12 18 16
diff --git a/challenge-123/abigail/t/output-1-1.exp b/challenge-123/abigail/t/output-1-1.exp
new file mode 100644
index 0000000000..60d24f7251
--- /dev/null
+++ b/challenge-123/abigail/t/output-1-1.exp
@@ -0,0 +1,2 @@
+8
+12
diff --git a/challenge-123/abigail/t/output-2-1.exp b/challenge-123/abigail/t/output-2-1.exp
new file mode 100644
index 0000000000..b261da18d5
--- /dev/null
+++ b/challenge-123/abigail/t/output-2-1.exp
@@ -0,0 +1,2 @@
+1
+0
-- 
cgit 


From 838a1f7ff7ecba5ac32306cabd9af33fff3762ab Mon Sep 17 00:00:00 2001
From: Abigail <abigail@abigail.be>
Date: Mon, 26 Jul 2021 16:34:47 +0200
Subject: More tests for week 123, part 1

---
 challenge-123/abigail/t/ctest.ini      | 1 +
 challenge-123/abigail/t/input-1-2      | 4 ++++
 challenge-123/abigail/t/output-1-2.exp | 4 ++++
 3 files changed, 9 insertions(+)
 create mode 100644 challenge-123/abigail/t/input-1-2
 create mode 100644 challenge-123/abigail/t/output-1-2.exp

diff --git a/challenge-123/abigail/t/ctest.ini b/challenge-123/abigail/t/ctest.ini
index 527781acbb..7e50c2b843 100644
--- a/challenge-123/abigail/t/ctest.ini
+++ b/challenge-123/abigail/t/ctest.ini
@@ -5,4 +5,5 @@
 
 [names]
 1-1 = Given Examples
+1-2 = Larger Numbers
 2-1 = Given Examples
diff --git a/challenge-123/abigail/t/input-1-2 b/challenge-123/abigail/t/input-1-2
new file mode 100644
index 0000000000..19badcb992
--- /dev/null
+++ b/challenge-123/abigail/t/input-1-2
@@ -0,0 +1,4 @@
+10
+100
+1000
+10000
diff --git a/challenge-123/abigail/t/output-1-2.exp b/challenge-123/abigail/t/output-1-2.exp
new file mode 100644
index 0000000000..a47264692c
--- /dev/null
+++ b/challenge-123/abigail/t/output-1-2.exp
@@ -0,0 +1,4 @@
+12
+1536
+51200000
+288325195312500000
-- 
cgit 


From 0b7728d89268a2e08459260dab7725ea7a7ff727 Mon Sep 17 00:00:00 2001
From: Scimon Proctor <simon.proctor@gmail.com>
Date: Mon, 26 Jul 2021 16:13:44 +0100
Subject: Week 123 all done

---
 challenge-123/simon-proctor/raku/ch-1.raku | 27 ++++++++++++++++++++++++
 challenge-123/simon-proctor/raku/ch-2.raku | 34 ++++++++++++++++++++++++++++++
 2 files changed, 61 insertions(+)
 create mode 100644 challenge-123/simon-proctor/raku/ch-1.raku
 create mode 100644 challenge-123/simon-proctor/raku/ch-2.raku

diff --git a/challenge-123/simon-proctor/raku/ch-1.raku b/challenge-123/simon-proctor/raku/ch-1.raku
new file mode 100644
index 0000000000..e06dbfa654
--- /dev/null
+++ b/challenge-123/simon-proctor/raku/ch-1.raku
@@ -0,0 +1,27 @@
+#!/usr/bin/env raku
+
+multi MAIN("Test") is hidden-from-USAGE {
+    use Test;
+    ok is-ugly(1);
+    ok is-ugly(2);
+    ok is-ugly(3);
+    ok is-ugly(5);
+    ok !is-ugly(7);
+    ok !is-ugly(14);
+    done-testing;
+}
+
+#| Given an Integer N return the Nth 'Ugly Number' (Indexed from 1), Given two number if prints the range
+multi MAIN (
+    Int \N where * > 0,
+    Int \M where 0 < * >= N = N,
+) {
+    (1..*).grep( { is-ugly($_) } )[N-1..M-1].join(", ").say;
+}
+
+my %ugly;
+multi is-ugly( Int() $ where * ~~ 1|2|3|5 ) { True }
+multi is-ugly( Int() $n where $n %% 5 ) { %ugly{$n} //= is-ugly($n / 5) }
+multi is-ugly( Int() $n where $n %% 3 ) { %ugly{$n} //= is-ugly($n / 3) }
+multi is-ugly( Int() $n where $n %% 2 ) { %ugly{$n} //= is-ugly($n / 2) }
+multi is-ugly( $ ) { False }
diff --git a/challenge-123/simon-proctor/raku/ch-2.raku b/challenge-123/simon-proctor/raku/ch-2.raku
new file mode 100644
index 0000000000..bff4cbcc4e
--- /dev/null
+++ b/challenge-123/simon-proctor/raku/ch-2.raku
@@ -0,0 +1,34 @@
+#!/usr/bin/env raku
+
+multi MAIN( 'Test' ) {
+    use Test;
+    ok  is-square( 10, 20, 20, 20, 20, 10, 10, 10 );
+    ok !is-square( 12, 24, 16,10, 20, 12, 18, 16 );
+    ok  is-square( 0, 10, 10, 0, 0, -10, -10, 0 );
+    is sq-dist-between( 0,0, 3, 4 ), 25; 
+    done-testing;
+}
+
+#| Given a list of 8 numbers (making up 4 points) of a quadrilateral return 1 or 0 depending on if it's a square
+multi MAIN( Num() $x1, Num() $y1,
+	    Num() $x2, Num() $y2,
+	    Num() $x3, Num() $y3,
+	    Num()$x4,  Num() $y4 ) {
+    say +is-square(  $x1, $y1, $x2, $y2, $x3, $y3, $x4, $y4 );
+}
+
+multi sq-dist-between( $x1, $y1, $x2, $y2 ) {
+    ( $x1-$x2 )² + ( $y1-$y2 )²; 
+}
+
+multi is-square( $x1, $y1, $x2, $y2, $x3, $y3, $x4, $y4 ) {
+    my ( $d1, $d2, $d3, $d4, $d5, $d6 ) = (
+      sq-dist-between( $x1,$y1, $x2, $y2),
+      sq-dist-between( $x1,$y1, $x3, $y3),
+      sq-dist-between( $x1,$y1, $x4, $y4),
+      sq-dist-between( $x2,$y2, $x3, $y3),
+      sq-dist-between( $x2,$y2, $x4, $y4),
+      sq-dist-between( $x3,$y3, $x4, $y4),
+    ).sort;
+    return $d1 ~~ $d2 ~~ $d3 ~~ $d4 && $d5 ~~ $d6;
+}
-- 
cgit 


From 331e624891c64fa73a8b0523cc514b8b910f6f11 Mon Sep 17 00:00:00 2001
From: Abigail <abigail@abigail.be>
Date: Mon, 26 Jul 2021 17:49:42 +0200
Subject: Reduce largest test.

AWK can't handle integers that large...
---
 challenge-123/abigail/t/input-1-2      | 2 +-
 challenge-123/abigail/t/output-1-2.exp | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/challenge-123/abigail/t/input-1-2 b/challenge-123/abigail/t/input-1-2
index 19badcb992..d59e6110af 100644
--- a/challenge-123/abigail/t/input-1-2
+++ b/challenge-123/abigail/t/input-1-2
@@ -1,4 +1,4 @@
 10
 100
 1000
-10000
+5000
diff --git a/challenge-123/abigail/t/output-1-2.exp b/challenge-123/abigail/t/output-1-2.exp
index a47264692c..8ba1659605 100644
--- a/challenge-123/abigail/t/output-1-2.exp
+++ b/challenge-123/abigail/t/output-1-2.exp
@@ -1,4 +1,4 @@
 12
 1536
 51200000
-288325195312500000
+50837316566580
-- 
cgit 


From fa7c07153cf957f1f7b215f5b8c8ab975436d7b9 Mon Sep 17 00:00:00 2001
From: chirvasitua <chirvasitua@gmail.com>
Date: Mon, 26 Jul 2021 12:01:54 -0400
Subject: 1st commit on 123_python

---
 challenge-123/stuart-little/python/ch-1.py | 21 +++++++++++++++++++++
 challenge-123/stuart-little/python/ch-2.py | 17 +++++++++++++++++
 2 files changed, 38 insertions(+)
 create mode 100755 challenge-123/stuart-little/python/ch-1.py
 create mode 100755 challenge-123/stuart-little/python/ch-2.py

diff --git a/challenge-123/stuart-little/python/ch-1.py b/challenge-123/stuart-little/python/ch-1.py
new file mode 100755
index 0000000000..40fec4185e
--- /dev/null
+++ b/challenge-123/stuart-little/python/ch-1.py
@@ -0,0 +1,21 @@
+#!/usr/bin/env python
+
+# run <script> <number $n> to return the first $n ugly numbers
+
+import sys
+
+memo = set([1,2,3,5])
+def smth5p(n):
+    if n in memo:
+        return True
+    for prm in [2,3,5]:
+        if (n % prm == 0) and int(n/prm) in memo:
+            memo.add(n)
+            return True
+    return False
+count,nr=0,0
+while count < int(sys.argv[1]):
+    nr+=1
+    if smth5p(nr):
+        print(nr)
+        count+=1
diff --git a/challenge-123/stuart-little/python/ch-2.py b/challenge-123/stuart-little/python/ch-2.py
new file mode 100755
index 0000000000..5217e7dc6e
--- /dev/null
+++ b/challenge-123/stuart-little/python/ch-2.py
@@ -0,0 +1,17 @@
+#!/usr/bin/env python
+
+# run <script> <x1 y1 x2 y2 ..>
+
+from collections import Counter
+import sys
+
+def sqDist(coords):
+    return (coords[2]-coords[0])**2 + (coords[3]-coords[1])**2
+
+def sqDistHash(coords):
+    return Counter([sqDist([coords[ix] for ix in [2*i,2*i+1,2*j,2*j+1]]) for i in range(3) for j in range(i+1,4)])
+
+def isSq(coords):
+    return sorted(dict(sqDistHash(coords)).values()) == [2,4]
+
+print(1 if isSq([float(x) for x in sys.argv[1:9]]) else 0)
-- 
cgit 


From 67a42026de1462ff6878e5be26da0cf68b72c4c6 Mon Sep 17 00:00:00 2001
From: Roger Bell_West <roger@firedrake.org>
Date: Mon, 26 Jul 2021 17:15:11 +0100
Subject: Solutions for challenge #123

---
 challenge-123/roger-bell-west/perl/ch-1.pl       | 28 ++++++++
 challenge-123/roger-bell-west/perl/ch-2.pl       | 83 +++++++++++++++++++++
 challenge-123/roger-bell-west/postscript/ch-1.ps | 53 ++++++++++++++
 challenge-123/roger-bell-west/python/ch-1.py     | 29 ++++++++
 challenge-123/roger-bell-west/python/ch-2.py     | 58 +++++++++++++++
 challenge-123/roger-bell-west/raku/ch-1.p6       | 25 +++++++
 challenge-123/roger-bell-west/raku/ch-2.p6       | 85 ++++++++++++++++++++++
 challenge-123/roger-bell-west/ruby/ch-1.rb       | 35 +++++++++
 challenge-123/roger-bell-west/ruby/ch-2.rb       | 86 ++++++++++++++++++++++
 challenge-123/roger-bell-west/rust/ch-1.rs       | 40 +++++++++++
 challenge-123/roger-bell-west/rust/ch-2.rs       | 91 ++++++++++++++++++++++++
 11 files changed, 613 insertions(+)
 create mode 100755 challenge-123/roger-bell-west/perl/ch-1.pl
 create mode 100755 challenge-123/roger-bell-west/perl/ch-2.pl
 create mode 100644 challenge-123/roger-bell-west/postscript/ch-1.ps
 create mode 100755 challenge-123/roger-bell-west/python/ch-1.py
 create mode 100755 challenge-123/roger-bell-west/python/ch-2.py
 create mode 100755 challenge-123/roger-bell-west/raku/ch-1.p6
 create mode 100755 challenge-123/roger-bell-west/raku/ch-2.p6
 create mode 100755 challenge-123/roger-bell-west/ruby/ch-1.rb
 create mode 100755 challenge-123/roger-bell-west/ruby/ch-2.rb
 create mode 100755 challenge-123/roger-bell-west/rust/ch-1.rs
 create mode 100755 challenge-123/roger-bell-west/rust/ch-2.rs

diff --git a/challenge-123/roger-bell-west/perl/ch-1.pl b/challenge-123/roger-bell-west/perl/ch-1.pl
new file mode 100755
index 0000000000..9e35c9aaa0
--- /dev/null
+++ b/challenge-123/roger-bell-west/perl/ch-1.pl
@@ -0,0 +1,28 @@
+#! /usr/bin/perl
+
+use strict;
+use warnings FATAL => 'all';
+
+use Test::More tests => 3;
+use List::Util qw(min);
+
+is(un(7),8,'example 1');
+is(un(10),12,'example 2');
+is(un(200),16200,'example 3');
+
+sub un {
+  my $m=shift;
+  my $n;
+  my @s=([1],[1],[1]);
+  my @c=(2,3,5);
+  foreach (1..$m) {
+    $n=min($s[0][0],$s[1][0],$s[2][0]);
+    foreach my $i (0..2) {
+      if ($s[$i][0]==$n) {
+        shift @{$s[$i]};
+      }
+      push @{$s[$i]},$n*$c[$i];
+    }
+  }
+  return $n;
+}
diff --git a/challenge-123/roger-bell-west/perl/ch-2.pl b/challenge-123/roger-bell-west/perl/ch-2.pl
new file mode 100755
index 0000000000..2d3d81b994
--- /dev/null
+++ b/challenge-123/roger-bell-west/perl/ch-2.pl
@@ -0,0 +1,83 @@
+#! /usr/bin/perl
+
+use strict;
+use warnings;
+
+use Test::More tests => 4;
+
+use List::MoreUtils qw(minmax);
+use Math::Trig qw(rad2deg);
+
+is(sp([
+  [10,20],
+  [20,20],
+  [20,10],
+  [10,10],
+    ]),1,'example 1');
+
+is(sp([
+  [12,24],
+  [16,10],
+  [20,12],
+  [18,16],
+    ]),0,'example 2');
+
+is(sp([
+  [10,10],
+  [20,0],
+  [30,10],
+  [20,20],
+    ]),1,'example 3');
+
+is(sp([
+  [0,0],
+  [3,4],
+  [8,4],
+  [5,0],
+    ]),0,'example 4');
+
+sub sp {
+  my $m=shift;
+  foreach my $ordering ([0,1,2,3,0],[0,1,3,2,0],[0,2,1,3,0]) {
+    my @w=map {$m->[$ordering->[$_%4]]} (0..4);
+    # check for equal sides
+    my @ds;
+    foreach my $pp (0..3) {
+      push @ds,($w[$pp+1][0]-$w[$pp][0])**2+($w[$pp+1][1]-$w[$pp][1])**2;
+    }
+    my @t=minmax(@ds);
+    if ($t[0] != $t[1]) {
+      next;
+    }
+    # check for equal right angles
+    my @angles;
+    foreach my $pp (0..3) {
+      my @delta=map {$w[$pp+1][$_]-$w[$pp][$_]} (0,1);
+      my $angle;
+      if ($delta[0]==0) {
+        if ($delta[1]==0) {     # coincident points
+          return 0;
+        }
+        $angle=$delta[1]>0?90:-90;
+      } else {
+        $angle=rad2deg(atan2($delta[1],$delta[0]));
+      }
+      push @angles,$angle;
+    }
+    push @angles,$angles[0];
+    my $good=1;
+    my @deltas=map {($angles[$_+1]-$angles[$_]+360)%360} (0..3);
+    if ($deltas[0]!=90 && $deltas[0] != 270) {
+      next;
+    } else {
+      foreach my $di (1..3) {
+        if ($deltas[$di] != $deltas[0]) {
+          $good=0;
+          last;
+        }
+      }
+    }
+    return $good;
+  }
+  return 0;
+}
diff --git a/challenge-123/roger-bell-west/postscript/ch-1.ps b/challenge-123/roger-bell-west/postscript/ch-1.ps
new file mode 100644
index 0000000000..783fc87ced
--- /dev/null
+++ b/challenge-123/roger-bell-west/postscript/ch-1.ps
@@ -0,0 +1,53 @@
+%! Not DSC compliant
+
+/un {
+    /c exch def
+    0
+    {
+        1 add
+        dup
+        [ 2 3 5 ] {
+            /k exch def
+            {
+                dup k mod 0 eq {
+                    k div cvi
+                } {
+                    exit
+                } ifelse
+            } loop
+        } forall
+        1 eq {
+            /c c 1 sub def
+        } if
+        c 0 le {
+            exit
+        } if
+    } loop
+} def
+
+/str 50 string def
+/fs 12 def
+/Helvetica findfont
+fs scalefont setfont
+20 750 translate
+/line 0 def
+/testnum 1 def
+
+/disptest {
+    0 line moveto testnum str cvs show (.) show
+    dup
+    50 line moveto str cvs show
+    un
+    dup
+    100 line moveto str cvs show
+    eq { (Pass) } { (FAIL) } ifelse
+    150 line moveto show
+    /line line fs 2 mul sub def
+    /testnum testnum 1 add def
+} def
+
+8 7 disptest
+12 10 disptest
+16200 200 disptest
+
+showpage
diff --git a/challenge-123/roger-bell-west/python/ch-1.py b/challenge-123/roger-bell-west/python/ch-1.py
new file mode 100755
index 0000000000..f54c43e6b4
--- /dev/null
+++ b/challenge-123/roger-bell-west/python/ch-1.py
@@ -0,0 +1,29 @@
+#! /usr/bin/python3
+
+import unittest
+from collections import deque
+
+def un(m):
+  n=0
+  s=[deque([1]),deque([1]),deque([1])]
+  c=[2,3,5]
+  for j in range(0,m):
+    n=min(s[0][0],s[1][0],s[2][0])
+    for i in range(0,2+1):
+      if s[i][0]==n:
+        s[i].popleft()
+      s[i].append(n*c[i])
+  return n
+
+class TestUn(unittest.TestCase):
+
+        def test_ex1(self):
+          self.assertEqual(un(7),8,'example 1')
+
+        def test_ex2(self):
+          self.assertEqual(un(10),12,'example 2')
+
+        def test_ex3(self):
+          self.assertEqual(un(200),16200,'example 3')
+          
+unittest.main()
diff --git a/challenge-123/roger-bell-west/python/ch-2.py b/challenge-123/roger-bell-west/python/ch-2.py
new file mode 100755
index 0000000000..d3210135ef
--- /dev/null
+++ b/challenge-123/roger-bell-west/python/ch-2.py
@@ -0,0 +1,58 @@
+#! /usr/bin/python3
+
+import unittest
+
+from math import degrees,atan2
+
+def sp(m):
+  for ordering in [
+      [0,1,2,3,0],
+      [0,1,3,2,0],
+      [0,2,1,3,0],
+      ]:
+    w=[m[ordering[i%4]] for i in range(5)]
+    ds=[]
+    for pp in range(4):
+      ds.append((w[pp+1][0]-w[pp][0])**2+(w[pp+1][1]-w[pp][1])**2)
+    if min(ds) != max(ds):
+      next
+    angles=[]
+    for pp in range(4):
+      delta=[w[pp+1][i]-w[pp][i] for i in range(2)]
+      if delta[0]==0:
+        if delta[1]==0:
+          return 0
+        angle=90
+        if delta[1]<0:
+          angle=-90
+      else:
+        angle=degrees(atan2(delta[1],delta[0]))
+      angles.append(angle)
+    angles.append(angles[0])
+    good=1
+    deltas=[(angles[i+1]-angles[i]+360) % 360 for i in range(4)]
+    if deltas[0] != 90 and deltas[0] != 270:
+      continue
+    else:
+      for di in range(1,4):
+        if deltas[di] != deltas[0]:
+          good=0
+          break
+    return good
+  return 0
+
+class TestSp(unittest.TestCase):
+
+        def test_ex1(self):
+          self.assertEqual(sp([[10,20],[20,20],[20,10],[10,10]]),1,'example 1')
+
+        def test_ex2(self):
+          self.assertEqual(sp([[12,24],[16,10],[20,12],[18,16]]),0,'example 2')
+
+        def test_ex3(self):
+          self.assertEqual(sp([[10,10],[20,0],[30,10],[20,20]]),1,'example 3')
+
+        def test_ex4(self):
+          self.assertEqual(sp([[0,0],[3,4],[8,4],[5,0]]),0,'example 4')
+          
+unittest.main()
diff --git a/challenge-123/roger-bell-west/raku/ch-1.p6 b/challenge-123/roger-bell-west/raku/ch-1.p6
new file mode 100755
index 0000000000..0b74cae8bc
--- /dev/null
+++ b/challenge-123/roger-bell-west/raku/ch-1.p6
@@ -0,0 +1,25 @@
+#! /usr/bin/perl6
+
+use Test;
+
+plan 3;
+
+is(un(7),8,'example 1');
+is(un(10),12,'example 2');
+is(un(200),16200,'example 3');
+
+sub un($m) {
+  my $n;
+  my @s=([1],[1],[1]);
+  my @c=(2,3,5);
+  for (1..$m) {
+    $n=min(@s[0][0],@s[1][0],@s[2][0]);
+    for 0..2 -> $i {
+      if (@s[$i][0] == $n) {
+        shift @s[$i];
+      }
+      push @s[$i],$n*@c[$i];
+    }
+  }
+  return $n;
+}
diff --git a/challenge-123/roger-bell-west/raku/ch-2.p6 b/challenge-123/roger-bell-west/raku/ch-2.p6
new file mode 100755
index 0000000000..ce9df2da9b
--- /dev/null
+++ b/challenge-123/roger-bell-west/raku/ch-2.p6
@@ -0,0 +1,85 @@
+#! /usr/bin/perl6
+
+use Test;
+
+plan 4;
+
+is(sp([
+  [10,20],
+  [20,20],
+  [20,10],
+  [10,10],
+    ]),1,'example 1');
+
+is(sp([
+  [12,24],
+  [16,10],
+  [20,12],
+  [18,16],
+    ]),0,'example 2');
+
+is(sp([
+  [10,10],
+  [20,0],
+  [30,10],
+  [20,20],
+    ]),1,'example 3');
+
+is(sp([
+  [0,0],
+  [3,4],
+  [8,4],
+  [5,0],
+    ]),0,'example 4');
+
+sub sp(@m) {
+  for ([0,1,2,3,0],[0,1,3,2,0],[0,2,1,3,0]) -> @ordering {
+    my @w=map {@m[@ordering[$_ % 4]]},(0..4);
+    # check for equal sides
+    my @ds;
+    for (0..3) -> $pp {
+      push @ds,(@w[$pp+1][0]-@w[$pp][0])**2+(@w[$pp+1][1]-@w[$pp][1])**2;
+    }
+    if (min(@ds) != max(@ds)) {
+      next;
+    }
+    # check for equal right angles
+    my @angles;
+    for 0..3 -> $pp {
+      my @delta=map {@w[$pp+1][$_]-@w[$pp][$_]},(0,1);
+      my $angle;
+      if (@delta[0]==0) {
+        if (@delta[1]==0) {     # coincident points
+          return 0;
+        }
+        $angle=@delta[1]>0 ?? 90 !! -90;
+      } else {
+        $angle=atan2(@delta[1],@delta[0])*180/pi;
+      }
+      push @angles,$angle;
+    }
+    push @angles,@angles[0];
+    my $good=1;
+    my @deltas=map {(@angles[$_+1]-@angles[$_]+360)%360},(0..3);
+    if (@deltas[0] != 90 && @deltas[0] != 270) {
+      next;
+    } else {
+      for 1..3 -> $di {
+        if (@deltas[$di] != @deltas[0]) {
+          $good=0;
+          last;
+        }
+      }
+    }
+    return $good;
+  }
+  return 0;
+}
+
+sub eqish($a,$b) {
+  if ((abs($a-$b)/$a) < 0.0001) {
+    return 1;
+  } else {
+    return 0;
+  }
+}
\ No newline at end of file
diff --git a/challenge-123/roger-bell-west/ruby/ch-1.rb b/challenge-123/roger-bell-west/ruby/ch-1.rb
new file mode 100755
index 0000000000..d01c20c137
--- /dev/null
+++ b/challenge-123/roger-bell-west/ruby/ch-1.rb
@@ -0,0 +1,35 @@
+#! /usr/bin/ruby
+
+def un(m)
+  n=0
+  s=[[1],[1],[1]]
+  c=[2,3,5]
+  1.upto(m) do
+    n=[s[0][0],s[1][0],s[2][0]].min
+    0.upto(2) do |i|
+      if s[i][0]==n then
+        s[i].shift
+      end
+      s[i].push(n*c[i])
+    end
+  end
+  return n
+end
+
+require 'test/unit'
+
+class TestUn < Test::Unit::TestCase
+
+  def test_ex1
+    assert_equal(8,un(7))
+  end
+
+  def test_ex2
+    assert_equal(12,un(10))
+  end
+
+  def test_ex3
+    assert_equal(16200,un(200))
+  end
+  
+end
diff --git a/challenge-123/roger-bell-west/ruby/ch-2.rb b/challenge-123/roger-bell-west/ruby/ch-2.rb
new file mode 100755
index 0000000000..85a8e02b98
--- /dev/null
+++ b/challenge-123/roger-bell-west/ruby/ch-2.rb
@@ -0,0 +1,86 @@
+#! /usr/bin/ruby
+
+def sp(m)
+  [[0,1,2,3,0],[0,1,3,2,0],[0,2,1,3,0]].each do |ordering|
+    w=0.upto(4).map{|i| m[ordering[i%4]]}
+    ds=[]
+    0.upto(3) do |pp|
+      ds.push((w[pp+1][0]-w[pp][0])**2+(w[pp+1][1]-w[pp][1])**2)
+    end
+    t=ds.minmax
+    if t[0] != t[1] then
+      next
+    end
+    rad2deg=90/Math.acos(0)
+    angles=[]
+    0.upto(3) do |pp|
+      delta=0.upto(1).map{|i| w[pp+1][i]-w[pp][i]}
+      if delta[0]==0 then
+        if delta[1]==0 then
+          return 0
+        end
+        angle=delta[1]>0 ? 90 : -90
+      else
+        angle=Math.atan2(delta[1],delta[0])*rad2deg
+      end
+      angles.push(angle)
+    end
+    angles.push(angles[0])
+    good=1
+    deltas=0.upto(3).map{|i| (angles[i+1]-angles[i]+360)%360}
+    if deltas[0] != 90 and deltas[0] != 270 then
+      next
+    else
+      1.upto(3) do |di|
+        if deltas[di] != deltas[0] then
+          good=0
+          break
+        end
+      end
+    end
+    return good
+  end
+  return 0
+end
+
+require 'test/unit'
+
+class TestSp < Test::Unit::TestCase
+
+  def test_ex1
+    assert_equal(1,sp([
+                        [10,20],
+                        [20,20],
+                        [20,10],
+                        [10,10]
+                      ]))
+  end
+
+  def test_ex2
+    assert_equal(0,sp([
+                        [12,24],
+                        [16,10],
+                        [20,12],
+                        [18,16]
+                      ]))
+  end
+
+  def test_ex3
+    assert_equal(1,sp([
+                        [10,10],
+                        [20,0],
+                        [30,10],
+                        [20,20]
+                      ]))
+  end
+
+  def test_ex4
+    assert_equal(0,sp([
+                        [0,0],
+                        [3,4],
+                        [8,4],
+                        [5,0]
+                      ]))
+  end
+  
+end
diff --git a/challenge-123/roger-bell-west/rust/ch-1.rs b/challenge-123/roger-bell-west/rust/ch-1.rs
new file mode 100755
index 0000000000..d02ee20c77
--- /dev/null
+++ b/challenge-123/roger-bell-west/rust/ch-1.rs
@@ -0,0 +1,40 @@
+#! /bin/sh
+//usr/bin/env rustc --test $0 -o ${0}x && ./${0}x; rm -f ${0}x ; exit
+
+use std::collections::VecDeque;
+
+#[test]
+fn test_ex1() {
+    assert_eq!(un(7),8);
+}
+
+#[test]
+fn test_ex2() {
+    assert_eq!(un(10),12);
+}
+
+#[test]
+fn test_ex3() {
+    assert_eq!(un(200),16200);
+}
+
+fn un(m: u64) -> u64 {
+    let mut n=0;
+    let mut s: Vec<VecDeque<u64>>=vec![];
+    for _j in 0..=2 {
+        let mut p: VecDeque<u64>=VecDeque::new();
+        p.push_back(1);
+        s.push(p);
+    }
+    let c=vec![2,3,5];
+    for _j in 1..=m {
+        n=*[s[0][0],s[1][0],s[2][0]].iter().min().unwrap();
+        for i in 0..=2 {
+            if s[i][0]==n {
+                s[i].pop_front();
+            }
+            s[i].push_back(n*c[i]);
+        }
+    }
+    return n;
+}
diff --git a/challenge-123/roger-bell-west/rust/ch-2.rs b/challenge-123/roger-bell-west/rust/ch-2.rs
new file mode 100755
index 0000000000..a31f62f36f
--- /dev/null
+++ b/challenge-123/roger-bell-west/rust/ch-2.rs
@@ -0,0 +1,91 @@
+#! /bin/sh
+//usr/bin/env rustc --test $0 -o ${0}x && ./${0}x; rm -f ${0}x ; exit
+
+#[test]
+fn test_ex1() {
+    assert_eq!(sp(vec![
+        vec![10.0,20.0],
+        vec![20.0,20.0],
+        vec![20.0,10.0],
+        vec![10.0,10.0]
+    ]),1);
+}
+
+#[test]
+fn test_ex2() {
+    assert_eq!(sp(vec![
+        vec![12.0,24.0],
+        vec![16.0,10.0],
+        vec![20.0,12.0],
+        vec![18.0,16.0]
+    ]),0);
+}
+
+#[test]
+fn test_ex3() {
+    assert_eq!(sp(vec![
+        vec![10.0,10.0],
+        vec![20.0,0.0],
+        vec![30.0,10.0],
+        vec![20.0,20.0]
+    ]),1);
+}
+
+#[test]
+fn test_ex4() {
+    assert_eq!(sp(vec![
+        vec![0.0,0.0],
+        vec![3.0,4.0],
+        vec![8.0,4.0],
+        vec![5.0,0.0]
+    ]),0);
+}
+
+fn sp(m: Vec<Vec<f64>>) -> u8 {
+    for ordering in &[
+        vec![0,1,2,3,0],
+        vec![0,1,3,2,0],
+        vec![0,2,1,3,0]
+    ] {
+        let w: Vec<Vec<f64>>=(0..=4).map(|i| m[ordering[i%4]].clone()).collect();
+        let mut ds: Vec<f64>=vec![];
+        for pp in 0..=3 {
+            ds.push((w[pp+1][0]-w[pp][0])*(w[pp+1][0]-w[pp][0])+(w[pp+1][1]-w[pp][1])*(w[pp+1][1]-w[pp][1]));
+        }
+        ds.sort_by(|a,b| a.partial_cmp(b).unwrap());
+        if ds[0] != ds[3] {
+            continue;
+        }
+        let mut angles: Vec<f64>=vec![];
+        for pp in 0..=3 {
+            let angle: f64;
+            let delta: Vec<f64>=(0..=1).map(|i| w[pp+1][i]-w[pp][i]).collect();
+            if delta[0]==0.0 {
+                if delta[1]==0.0 {
+                    return 0;
+                }
+                angle=if delta[1]>0.0 {90.0} else {-90.0};
+            } else {
+                angle=delta[1].atan2(delta[0]).to_degrees();
+            }
+            angles.push(angle);
+        }
+        println!("{:?}",angles);
+        angles.push(angles[0]);
+        let mut good: u8=1;
+        let deltas: Vec<f64>=(0..=3).map(|i| (angles[i+1]-angles[i]+360.0)%360.0).collect();
+        println!("{:?}",deltas);
+        if deltas[0] != 90.0 && deltas[0] != 270.0 {
+            continue;
+        } else {
+            for di in 1..=3 {
+                if deltas[di] != deltas[0] {
+                    good=0;
+                    break;
+                }
+            }
+        }
+        return good;
+    }
+    return 0;
+}
-- 
cgit 


From 9ae73e4f847a4f268808cfaefef2dfc0466c4bf2 Mon Sep 17 00:00:00 2001
From: Lucas Ransan <lucas@ransan.tk>
Date: Mon, 26 Jul 2021 14:00:23 +0200
Subject: Raku week 123 task 1

---
 challenge-123/luc65r/raku/ch-1.raku | 11 +++++++++++
 1 file changed, 11 insertions(+)
 create mode 100755 challenge-123/luc65r/raku/ch-1.raku

diff --git a/challenge-123/luc65r/raku/ch-1.raku b/challenge-123/luc65r/raku/ch-1.raku
new file mode 100755
index 0000000000..e4df0aee54
--- /dev/null
+++ b/challenge-123/luc65r/raku/ch-1.raku
@@ -0,0 +1,11 @@
+#!/usr/bin/env raku
+
+multi ugly(1 --> True) { }
+multi ugly(UInt:D $n --> Bool) {
+    return ugly($n div $_) if $n %% $_ for 2, 3, 5;
+    False
+}
+
+unit sub MAIN(UInt:D $n);
+
+say (1..∞).grep({ .&ugly })[$n - 1];
-- 
cgit 


From 81e5f487a7a858586383f34c37a0da29f6eaa555 Mon Sep 17 00:00:00 2001
From: Lucas Ransan <lucas@ransan.tk>
Date: Mon, 26 Jul 2021 18:16:50 +0200
Subject: Raku week 123 task 2

---
 challenge-123/luc65r/raku/ch-2.raku | 8 ++++++++
 1 file changed, 8 insertions(+)
 create mode 100755 challenge-123/luc65r/raku/ch-2.raku

diff --git a/challenge-123/luc65r/raku/ch-2.raku b/challenge-123/luc65r/raku/ch-2.raku
new file mode 100755
index 0000000000..40af05942a
--- /dev/null
+++ b/challenge-123/luc65r/raku/ch-2.raku
@@ -0,0 +1,8 @@
+#!/usr/bin/env raku
+
+unit sub MAIN(*@coordinate where +* == 8);
+
+my Complex @pts = map { Complex.new($^x, $^y) }, @coordinate;
+my Complex $center = @pts.sum / 4;
+my Complex $v = @pts[0] - $center;
+say +so @pts ≡ ($v, -$v, $v.conj, -$v.conj) »+» $center;
-- 
cgit 


From 0324029092373f4cce35fbd28a656218221f970a Mon Sep 17 00:00:00 2001
From: chirvasitua <chirvasitua@gmail.com>
Date: Mon, 26 Jul 2021 12:32:25 -0400
Subject: 1st commit on 123_node

---
 challenge-123/stuart-little/node/ch-1.js | 26 ++++++++++++++++++++++++++
 challenge-123/stuart-little/node/ch-2.js | 25 +++++++++++++++++++++++++
 2 files changed, 51 insertions(+)
 create mode 100755 challenge-123/stuart-little/node/ch-1.js
 create mode 100755 challenge-123/stuart-little/node/ch-2.js

diff --git a/challenge-123/stuart-little/node/ch-1.js b/challenge-123/stuart-little/node/ch-1.js
new file mode 100755
index 0000000000..5ada161822
--- /dev/null
+++ b/challenge-123/stuart-little/node/ch-1.js
@@ -0,0 +1,26 @@
+#!/usr/bin/env node
+
+// run <script> <number $n> to return the first $n ugly numbers
+
+let memo = new Set([1,2,3,5])
+
+function smth5p(n) {
+    if (memo.has(n)) {return true}
+    for (let prm of [2,3,5]) {
+	if (n%prm===0 && memo.has(n/prm)) {
+	    memo.add(n)
+	    return true
+	}
+    }
+    return false
+}
+
+let count=0
+let nr=0
+while (count < parseInt(process.argv[2])) {
+    nr++
+    if (smth5p(nr)) {
+	count++
+	console.log(nr)
+    }    
+}
diff --git a/challenge-123/stuart-little/node/ch-2.js b/challenge-123/stuart-little/node/ch-2.js
new file mode 100755
index 0000000000..0611520f33
--- /dev/null
+++ b/challenge-123/stuart-little/node/ch-2.js
@@ -0,0 +1,25 @@
+#!/usr/bin/env node
+
+// run <script> <x1 y1 x2 y2 ..>
+
+function sqDist(coords) {
+    return (coords[2]-coords[0])**2 + (coords[3]-coords[1])**2
+}
+
+function sqDistHash(coords) {
+    let hsh={};
+    [0,1,2].forEach( function(i) {
+	[0,1,2,3].slice(i+1).forEach( function(j) {
+	    let dst = sqDist([2*i,2*i+1,2*j,2*j+1].map(ix => coords[ix]))
+	    hsh[dst] = hsh[dst] ? hsh[dst]+1 : 1
+	})
+    })
+    return hsh
+}
+
+function isSq(coords) {
+    const freqs = Object.values(sqDistHash(coords))
+    return freqs.includes(2) && freqs.includes(4)
+}
+
+console.log(isSq(process.argv.slice(2,10).map(x => parseFloat(x))) ? 1 : 0)
-- 
cgit 


From 7429f34b47a4479a50b1fc07dc08c6656d605bae Mon Sep 17 00:00:00 2001
From: chirvasitua <chirvasitua@gmail.com>
Date: Mon, 26 Jul 2021 12:58:54 -0400
Subject: 1st commit on 123_lua

---
 challenge-123/stuart-little/lua/ch-1.lua | 25 +++++++++++++++++++++++++
 challenge-123/stuart-little/lua/ch-2.lua | 29 +++++++++++++++++++++++++++++
 2 files changed, 54 insertions(+)
 create mode 100755 challenge-123/stuart-little/lua/ch-1.lua
 create mode 100755 challenge-123/stuart-little/lua/ch-2.lua

diff --git a/challenge-123/stuart-little/lua/ch-1.lua b/challenge-123/stuart-little/lua/ch-1.lua
new file mode 100755
index 0000000000..376211dc70
--- /dev/null
+++ b/challenge-123/stuart-little/lua/ch-1.lua
@@ -0,0 +1,25 @@
+#!/usr/bin/env lua
+
+-- run <script> <number $n> to return the first $n ugly numbers
+
+local memo = {[1]=1,[2]=1,[3]=1,[5]=1}
+
+function smth5p(n)
+   if memo[n] then return true end
+   for _,prm in ipairs({2,3,5}) do
+      if n % prm == 0 and memo[n/prm] then
+	 memo[n]=1
+	 return true
+      end
+   end
+   return false
+end
+
+local count,nr=0,0
+while (count < tonumber(arg[1])) do
+   nr=nr+1
+   if smth5p(nr) then
+      count=count+1
+      print(nr)
+   end
+end
diff --git a/challenge-123/stuart-little/lua/ch-2.lua b/challenge-123/stuart-little/lua/ch-2.lua
new file mode 100755
index 0000000000..6fe2c55aad
--- /dev/null
+++ b/challenge-123/stuart-little/lua/ch-2.lua
@@ -0,0 +1,29 @@
+#!/usr/bin/env lua
+
+-- run <script> <x1 y1 x2 y2 ..>
+
+function sqDist(coords)
+    return (coords[3]-coords[1])^2 + (coords[4]-coords[2])^2
+end
+
+function sqDistHash(coords)
+   local t={}
+   for i=1,3 do
+      for j=i+1,4 do
+	 local d=sqDist({coords[2*i-1],coords[2*i],coords[2*j-1],coords[2*j]})
+	 t[d] = t[d] and t[d]+1 or 1
+      end
+   end
+   return t
+end
+
+function isSq(coords)
+   local records=0
+   for k,v in pairs(sqDistHash(coords)) do
+      if k==0 then return false end
+      if v==2 or v==4 then records=records+1 end
+   end
+   return records==2
+end
+
+print(isSq(table.pack(table.unpack(arg,1,8))) and 1 or 0)
-- 
cgit 


From d3be7070715a1574b23eb786d5143a3fa23ea8d8 Mon Sep 17 00:00:00 2001
From: drbaggy <js5@sanger.ac.uk>
Date: Mon, 26 Jul 2021 20:45:36 +0100
Subject: use reverse to flip keys and values in hash to make last line logic
 easier

---
 challenge-123/james-smith/perl/ch-2.pl | 9 ++++-----
 1 file changed, 4 insertions(+), 5 deletions(-)

diff --git a/challenge-123/james-smith/perl/ch-2.pl b/challenge-123/james-smith/perl/ch-2.pl
index af4005104e..7dd9dde161 100644
--- a/challenge-123/james-smith/perl/ch-2.pl
+++ b/challenge-123/james-smith/perl/ch-2.pl
@@ -11,6 +11,8 @@ use Data::Dumper qw(Dumper);
 my @TESTS = (
   [ [ [10,20],[20,20],[20,10],[10,10] ], 1 ],
   [ [ [12,24],[16,10],[20,12],[18,16] ], 0 ],
+  [ [ [-2,5],[2,-5],[5,2],[-5,-2] ], 1 ],
+  [ [ [0,1],[1,0],[0,-1],[-1,0] ], 1 ],
 );
 
 is( is_square(@{$_->[0]}), $_->[1] ) foreach @TESTS;
@@ -33,10 +35,7 @@ sub is_square {
     my $a = shift @pts;
     $D{($a->[0]-$_->[0])**2+($a->[1]-$_->[1])**2}++ foreach @pts;
   }
-  my @K = keys %D;
-  return 0 unless @K== 2;      ## More than two distances
-  return 1 if $K[0]*2==$K[1];  ## First no is the diagonal
-  return 1 if $K[1]*2==$K[0];  ## First no is the edge..
-  return 0;                    ## Equilat triangles..
+  my %F = reverse %D;
+  return exists $F{2} && exists $F{4} && $F{2} == 2*$F{4} || 0;
 }
 
-- 
cgit 


From 3069523c72138f77a3b1bd7886ed7be15010f821 Mon Sep 17 00:00:00 2001
From: James Smith <baggy@baggy.me.uk>
Date: Mon, 26 Jul 2021 20:50:24 +0100
Subject: Update README.md

---
 challenge-123/james-smith/README.md | 365 ++++++++----------------------------
 1 file changed, 83 insertions(+), 282 deletions(-)

diff --git a/challenge-123/james-smith/README.md b/challenge-123/james-smith/README.md
index 7518cedda1..f3a8e508e2 100644
--- a/challenge-123/james-smith/README.md
+++ b/challenge-123/james-smith/README.md
@@ -1,4 +1,4 @@
-# Perl Weekly Challenge #122
+# Perl Weekly Challenge #123
 
 You can find more information about this weeks, and previous weeks challenges at:
 
@@ -12,313 +12,114 @@ You can find the solutions here on github at:
 
 https://github.com/drbaggy/perlweeklychallenge-club/tree/master/challenge-122/james-smith/perl
 
-# Task 1 - Average of Stream
+# Task 1 - Ugly Numbers
 
-***You are given a stream of numbers, `@N`. Write a script to print the average of the stream at every point.***
+***You are given an integer `$n >= 1`. Write a script to find the $nth element of Ugly Numbers.***
 
-## The solution
-
-Firstly - we create a "stream object" - we use a single function
-`stream()` for this which is a get/setter - call with a sequence of data
-and this pushes the values onto the stream. Call it without and it
-returns the first value of the stream OR dies.
+**Defn:** Ugly numbers are those number whose prime factors are 2, 3 or 5. For example, the first 10 Ugly Numbers are 1, 2, 3, 4, 5, 6, 8, 9, 10, 12.
 
-`stream_average` just pulls the next value from the stream (or dies)
-and computes the average -- updates total(`$t`) and count(`$n`) -- and
-returns the `$t`/`$n`
-
-```perl
-stream( map {$_*10} 1..50 ); ## Push values into stream...
-
-eval {say stream_average();} until $@;
-
-sub stream {
-  state(@stream);
-    @_      ? (push @stream,@_)
-  : @stream ? shift @stream
-  :           die;
-}
-
-sub stream_average {
-  state($n,$t);
-  return ($t+=stream) / ++$n;
- }
-
-```
-
-# Task 2 - Basketball Points
+## The solution
 
-***You are given a score `$S`. You can win basketball points e.g. 1 point, 2 points and 3 points. Write a script to find out the different ways you can score `$S`..***
+There are two ways of working out the *nth* ugly number - we either have to search all numbers starting at 1 counting ugly numbers -OR- do something more "intellegent".
 
-## Solution.
+The former works well for small `n`, but doesn't scale well as the ugly numbers become more sparse.
 
-To get the combinations for a give number - we can shoot a 1, 2 or 3 point shot and then reconsider the combinations for the remaining point.
+### Method
 
-This leads us to a simple recursive solution.
+Any Ugly number is either a multiple of 2, 3 or 5 of another Ugly number. So to find the next ugly number we multiple all ugly numbers by 2, 3 or 5 and find the lowest value greater than the last ugly seen.
 
 ```perl
-sub pts {
-  return $cache{$_[0]} ||= $_[0] < 1 ? [] : [
-     map( {'1'.$_} @{pts( $_[0] - 1 )} ),
-     map( {'2'.$_} @{pts( $_[0] - 2 )} ),
-     map( {'3'.$_} @{pts( $_[0] - 3 )} )
-  ];
+sub nth_ugly {
+  my $n = shift;
+  my @uglies = (1);
+  while(1) {
+    return $uglies[$n-1] if $n <= @uglies;
+    ## Get the next ugly....
+    my $next = 0;
+    foreach my $l (5,3,2) {
+      foreach(@uglies) {
+        next if $_ * $l <= $uglies[-1];
+        $next = $_*$l if !$next || $next > $_*$l;
+        last;
+      }
+    }
+    push @uglies, $next;
+  }
 }
-```
-
-**Note** To reduce complexity we pre-populate the cache for the first three cases:
 
- 1. "1"
- 2. "11" & "2"
- 3. "111", "12", "21" and "3"
+```
 
-## Solution 2 - streaming
+We cache the values internally in the function - in the `state` variable `@uglies`
 
-A caching/collecting solution always fails as the size of the data increases beyond the size of the memory of the machine. So we need to investigate
-a streaming solution.
+### Optimization
 
-The first parameter is again the total we have to match. We keep track of the scores we have already seen and pass this as the 2nd parameter.
-If we overshoot our total then the first parameter is less than 0 and we generate nothing or equal to run and display the sequence of points.
+We can speed this up by short-cutting the inner loop - by remembering which was the first ugly failed the check `$_ * $l <= $uglies[-1]`.
 
 ```perl
-sub pts_streaming {
-  return if  $_[0]<0;
-  return say $_[1] unless $_[0];
-  pts_streaming( $_[0]-$_, $_[1].$_ ) foreach 1..3;
+sub nth_ugly_opt {
+  my $n = shift;
+  my @uglies = (1);
+  my @starts = (0,0,0,0,0,0);
+  while(1) {
+    return $uglies[$n-1] if $n <= @uglies;
+    ## Get the next ugly....
+    my $next = 0;
+    foreach my $l (5,3,2) {
+      foreach ( $starts[$l] .. $#uglies ) {
+        next if $uglies[$_] * $l <= $uglies[-1];
+        $starts[$l]=$_;
+        $next = $uglies[$_]*$l if !$next || $next > $uglies[$_]*$l;
+        last;
+      }
+    }
+    push @uglies, $next;
+  }
 }
 ```
 
-There are a number of additional calls needed `$_[0] < 1`, we can optimize these out by using the pre-poulated part of the cache above.
-
-```perl
-sub pts_streaming_opt {
-  return say "$_[1]1"                             if $_[0] == 1;
-  return say "$_[1]11\n$_[1]2"                    if $_[0] == 2;
-  return say "$_[1]111\n$_[1]12\n$_[1]21\n$_[1]3" if $_[0] == 3;
-  pts_streaming_opt( $_[0]-$_, $_[1].$_ ) foreach 1..3;
-}
-```
+The extra overhead causes the optimized method to be slower than the simple method for low values of `$n` - but as `$n` goes up it saves many loop evaluations. Flip happens when `$n` is around `18` or `19`. By the time we get to `$n` as 1000 the optimized version is around 50 times faster than the naive one. For `$n = 10_0000` one of the largest values for which the ugly is less than 2^64 (and so all calculations are integer based) in around 600 times faster.
 
-If the score left is less than 4 we use the same pre-cache we had before to populate the values. This improves performance - for example for the
-30 point solution we reduce the function calls from 192 million to 31 million and time taken from 3 minutes 20 seconds to just 55 seconds with this
-simple tweak. This corresponds to an approximate reduction of 6.2 in function calls and about 3.5 reduction in time.
+Below shows these comparisons - against a simple scan algorithm (with caching of uglies). We can see that for values up to around 20-30 the scan method (because of it's simplicity is fastest) and the uglies are relatively dense. But soon the advantage of our message is seen - by the time `$n` reaches 500 (Ugly is 937,500) to optimized
+method is around 2000x faster than the scan method.
 
-## Comparing solutions
+|   n    | Ugly(n)                 | Scan        | Simple      |   Optimized | Opt v simple | Opt v scan    | Simple v scan |
+| -----: | ----------------------: | ----------: | ----------: | ----------: | -----------: | ------------: | ------------: | 
+|      1 |                       1 | 1,693,446/s | 3,131,931/s | 1,922,126/s |         -39% |           14% |           14% |
+|      2 |                       2 |   844,419/s | 1,019,073/s |   537,358/s |         -47% |          -36% |           21% |
+|      5 |                       5 |   294,998/s |   287,307/s |   167,641/s |         -42% |          -43% |           -3% |
+|     10 |                      12 |   121,349/s |   109,978/s |    78,936/s |         -28% |          -35% |          -11% |
+|     20 |                      36 |    40,792/s |    35,257/s |    38,068/s |           5% |           -7% |          -11% |
+|     50 |                     243 |     6,098/s |     6,656/s |    15,056/s |         126% |          148% |           10% |
+|    100 |                   1,536 |       941/s |     1,653/s |     7,423/s |         349% |          688% |           76% |
+|    200 |                  16,200 |      83.5/s |       395/s |     3,700/s |         843% |        4,333% |          374% |
+|    500 |                 937,500 |       0.8/s |      58.8/s |     1,479/s |       2,417% |      185,492% |        7,273% |
+|  1,000 |              51,200,000 |             |      13.8/s |       687/s |       4,866% | - | - |
+|  2,000 |           8,062,156,800 |             |      3.35/s |       352/s |      10,402% | - | - |
+|  5,000 |      50,837,316,566,580 |             |      0.49/s |       138/s |      28,036% | - | - |
+| 10,000 | 288,325,195,312,500,000 |             |      0.11/s |      67.6/s |      57,754% | - | - |
 
-By comparing timings on the 2G test machine we note that up to a score of 26 the caching solution is efficient [basically everything in physical memory] but
-after this streaming solution is the only real option. The difference in time up to this point though is not that great. After we get past 27 the caching algorithm no longer executes - but as you can see the streaming solution continues going - just consuming more and more time (increases by a factor of 21 for every 5 extra points). The estimated size of the output file for `n=40` is around 600Gbytes, for `n=50` it would generate a 300 Terrabyte file with 10 trillion combinations in around 6 days!
+# Task 2 - Square Points
 
-| n   | ways | calls cache | memory cache | time cache | calls stream | memory stream | time stream |
-| --: | --: | --: | --: | --: | --: | --: | --: |
-|  5  | 13 | 7 | 9,208K | 0.011 | 7 | 9,196K | 0.011 |
-| 10  | 274 | 22 | 9,204K | 0.010 | 157 | 9,096K | 0.011 |
-| 15  | 5,768 | 37 | 10,488K | 0.015 | 3,313 | 9,096K | 0.016 |
-| 20  | 121,415 | 52 | 38,916K | 0.117 | 69,748 | 9,100K | 0.134 |
-| 25  | 2,555,755 | 67 | 631M | 2.371 | 1,468,189 | 9,096K | 2.732 |
-| 26  | 4,700,770 | 70 | 1,156M | 4.620 | 2,700,421 | 9,100K | 4.930 |
-| 27  | 8,646,064 | 73 | 2,125M | 23.423 | 4,966,849 | 9,200K | 8.958 |
-| 28  | 15,902,591 | - | - | - | 9,135,460 | 9,096K | 16.606 |
-| 29  | 29,459,425 | - | - | - | 16,802,731 | 9,204K | 31.175 |
-| 30  | 53,798,080 | - | - | - | 30,905,041 | 9,200K | 61.527 |
-| 35  | 1,132,436,852 | - | - | - | 650,543,809 | 9,200K | 0:20:04 |
-| 40  | 23,837,527,729 | - | - | - | 13,693,793,230 | 9,196K | 6:56:20  |
+***You are given coordinates of four points i.e. (x1, y1), (x2, y2), (x3, y3) and (x4, y4). Write a script to find out if the given four points form a square.***
 
-## Number of solutions...
+## Solution.
 
-As we have the relationship that if `T(n)` is the number of score combinations for a total of `n` we have:
+First we need to think how we define a square - it has 4 sides of equal length and sides at right angles. If we want to define it terms of distances between points we have 4 pairs of points that are the same distance apart and two pairs of points which are at `sqrt(2)` times this distance.
 
-```
-  T(n) = T(n-1) + T(n-2) + T(n-3)
-```
+We therefore measure the squares of the distances between the points, and collect them together. If the list of distances is 2, and the ratio of the squares of the distance is 2 then we have a square.
 
-We see that the sequence of numbers is the *Tribonacci* sequence. Listed
-below to 186 - the highest score in NBA history about ten-quindecillion (10^49) ways to get to that score. For that the output file would be 10^51 bytes (names stop at yottabyte ~ 10^24) in size and take around the 35 decillion years...!
+ * The `while/foreach` loops calculate the square of the distances between points, and stores these in the hash `%dist` where the distance is the key.
+ * We flip the hash so that the keys become values and values become keys. This allows us to check to see if we have one length 4 times and one length 2 times, for belt and braces we check the ratio of the length of the diagonal vs the length of the edges of the sides to see that it is 2.
 
-```
-1       1
-2       2
-3       4
-4       7
-5       13
-6       24
-7       44
-8       81
-9       149
-10      274
-11      504
-12      927
-13      1,705
-14      3,136
-15      5,768
-16      10,609
-17      19,513
-18      35,890
-19      66,012
-20      121,415
-21      223,317
-22      410,744
-23      755,476
-24      1,389,537
-25      2,555,757
-26      4,700,770
-27      8,646,064
-28      15,902,591
-29      29,249,425
-30      53,798,080
-31      98,950,096
-32      181,997,601
-33      334,745,777
-34      615,693,474
-35      1,132,436,852
-36      2,082,876,103
-37      3,831,006,429
-38      7,046,319,384
-39      12,960,201,916
-40      23,837,527,729
-41      43,844,049,029
-42      80,641,778,674
-43      148,323,355,432
-44      272,809,183,135
-45      501,774,317,241
-46      922,906,855,808
-47      1,697,490,356,184
-48      3,122,171,529,233
-49      5,742,568,741,225
-50      10,562,230,626,642
-51      19,426,970,897,100
-52      35,731,770,264,967
-53      65,720,971,788,709
-54      120,879,712,950,776
-55      222,332,455,004,452
-56      408,933,139,743,937
-57      752,145,307,699,165
-58      1,383,410,902,447,554
-59      2,544,489,349,890,656
-60      4,680,045,560,037,375
-61      8,607,945,812,375,585
-62      15,832,480,722,303,616
-63      29,120,472,094,716,576
-64      53,560,898,629,395,777
-65      98,513,851,446,415,969
-66      181,195,222,170,528,322
-67      333,269,972,246,340,068
-68      612,979,045,863,284,359
-69      1,127,444,240,280,152,749
-70      2,073,693,258,389,777,176
-71      3,814,116,544,533,214,284
-72      7,015,254,043,203,144,209
-73      12,903,063,846,126,135,669
-74      23,732,434,433,862,494,162
-75      43,650,752,323,191,774,040
-76      80,286,250,603,180,403,871
-77      147,669,437,360,234,672,073
-78      271,606,440,286,606,849,984
-79      499,562,128,250,021,925,928
-80      918,838,005,896,863,447,985
-81      1,690,006,574,433,492,223,897
-82      3,108,406,708,580,377,597,810
-83      5,717,251,288,910,733,269,692
-84      10,515,664,571,924,603,091,399
-85      19,341,322,569,415,713,958,901
-86      35,574,238,430,251,050,319,992
-87      65,431,225,571,591,367,370,292
-88      120,346,786,571,258,131,649,185
-89      221,352,250,573,100,549,339,469
-90      407,130,262,715,950,048,358,946
-91      748,829,299,860,308,729,347,600
-92      1,377,311,813,149,359,327,046,015
-93      2,533,271,375,725,618,104,752,561
-94      4,659,412,488,735,286,161,146,176
-95      8,569,995,677,610,263,592,944,752
-96      15,762,679,542,071,167,858,843,489
-97      28,992,087,708,416,717,612,934,417
-98      53,324,762,928,098,149,064,722,658
-99      98,079,530,178,586,034,536,500,564
-100     180,396,380,815,100,901,214,157,639
-101     331,800,673,921,785,084,815,380,861
-102     610,276,584,915,472,020,566,039,064
-103     1,122,473,639,652,358,006,595,577,564
-104     2,064,550,898,489,615,111,976,997,489
-105     3,797,301,123,057,445,139,138,614,117
-106     6,984,325,661,199,418,257,711,189,170
-107     12,846,177,682,746,478,508,826,800,776
-108     23,627,804,467,003,341,905,676,604,063
-109     43,458,307,810,949,238,672,214,594,009
-110     79,932,289,960,699,059,086,717,998,848
-111     147,018,402,238,651,639,664,609,196,920
-112     270,409,000,010,299,937,423,541,789,777
-113     497,359,692,209,650,636,174,868,985,545
-114     914,787,094,458,602,213,263,019,972,242
-115     1,682,555,786,678,552,786,861,430,747,564
-116     3,094,702,573,346,805,636,299,319,705,351
-117     5,692,045,454,483,960,636,423,770,425,157
-118     10,469,303,814,509,319,059,584,520,878,072
-119     19,256,051,842,340,085,332,307,611,008,580
-120     35,417,401,111,333,365,028,315,902,311,809
-121     65,142,756,768,182,769,420,208,034,198,461
-122     119,816,209,721,856,219,780,831,547,518,850
-123     220,376,367,601,372,354,229,355,484,029,120
-124     405,335,334,091,411,343,430,395,065,746,431
-125     745,527,911,414,639,917,440,582,097,294,401
-126     1,371,239,613,107,423,615,100,332,647,069,952
-127     2,522,102,858,613,474,875,971,309,810,110,784
-128     4,638,870,383,135,538,408,512,224,554,475,137
-129     8,532,212,854,856,436,899,583,867,011,655,873
-130     15,693,186,096,605,450,184,067,401,376,241,794
-131     28,864,269,334,597,425,492,163,492,942,372,804
-132     53,089,668,286,059,312,575,814,761,330,270,471
-133     97,647,123,717,262,188,252,045,655,648,885,069
-134     179,601,061,337,918,926,320,023,909,921,528,344
-135     330,337,853,341,240,427,147,884,326,900,683,884
-136     607,586,038,396,421,541,719,953,892,471,097,297
-137     1,117,524,953,075,580,895,187,862,129,293,309,525
-138     2,055,448,844,813,242,864,055,700,348,665,090,706
-139     3,780,559,836,285,245,300,963,516,370,429,497,528
-140     6,953,533,634,174,069,060,207,078,848,387,897,759
-141     12,789,542,315,272,557,225,226,295,567,482,485,993
-142     23,523,635,785,731,871,586,396,890,786,299,881,280
-143     43,266,711,735,178,497,871,830,265,202,170,265,032
-144     79,579,889,836,182,926,683,453,451,555,952,632,305
-145     146,370,237,357,093,296,141,680,607,544,422,778,617
-146     269,2