vi ch-1.plMerge remote-tracking branch 'upstream/master'

46 files changed, 3397 insertions, 1726 deletions

diff --git a/challenge-147/luca-ferrari/blog-1.txt b/challenge-147/luca-ferrari/blog-1.txt
new file mode 100644
index 0000000000..af17183edb
--- /dev/null
+++ b/challenge-147/luca-ferrari/blog-1.txt
@@ -0,0 +1 @@
+https://fluca1978.github.io/2022/01/04/PerlWeeklyChallenge146.html#task1
diff --git a/challenge-147/luca-ferrari/blog-2.txt b/challenge-147/luca-ferrari/blog-2.txt
new file mode 100644
index 0000000000..5e5d379514
--- /dev/null
+++ b/challenge-147/luca-ferrari/blog-2.txt
@@ -0,0 +1 @@
+https://fluca1978.github.io/2022/01/04/PerlWeeklyChallenge146.html#task2
diff --git a/challenge-147/luca-ferrari/blog-3.txt b/challenge-147/luca-ferrari/blog-3.txt
new file mode 100644
index 0000000000..aa716b41b9
--- /dev/null
+++ b/challenge-147/luca-ferrari/blog-3.txt
@@ -0,0 +1 @@
+https://fluca1978.github.io/2022/01/04/PerlWeeklyChallenge146.html#task1pg
diff --git a/challenge-147/luca-ferrari/blog-4.txt b/challenge-147/luca-ferrari/blog-4.txt
new file mode 100644
index 0000000000..520b859582
--- /dev/null
+++ b/challenge-147/luca-ferrari/blog-4.txt
@@ -0,0 +1 @@
+https://fluca1978.github.io/2022/01/04/PerlWeeklyChallenge146.html#task2pg
diff --git a/challenge-147/luca-ferrari/postgresql/ch-1.sql b/challenge-147/luca-ferrari/postgresql/ch-1.sql
new file mode 100644
index 0000000000..7e24f9ceb0
--- /dev/null
+++ b/challenge-147/luca-ferrari/postgresql/ch-1.sql
@@ -0,0 +1,83 @@
+CREATE OR REPLACE FUNCTION
+f_is_prime( n bigint )
+RETURNS bool
+AS
+$CODE$
+DECLARE
+        i int;
+BEGIN
+        FOR i IN 2 .. ( n - 1 ) LOOP
+            IF n % i = 0 THEN
+               RETURN false;
+            END IF;
+        END LOOP;
+
+        RETURN true;
+END
+$CODE$
+LANGUAGE plpgsql;
+
+
+/**
+testdb=> select * from f_generate_truncated_primes();
+f_generate_truncated_primes
+-----------------------------
+11
+13
+17
+23
+31
+37
+41
+43
+47
+53
+61
+67
+71
+73
+83
+97
+113
+131
+137
+167
+(20 rows)
+
+*/
+CREATE OR REPLACE FUNCTION
+f_generate_truncated_primes( l int = 20 )
+RETURNS SETOF int
+AS
+$CODE$
+DECLARE
+        i int;
+        current bigint;
+        fnd   int := 0;
+BEGIN
+<<MAIN_LOOP>>
+        FOR current IN SELECT * FROM generate_series( 10, 999999 ) LOOP
+            CONTINUE WHEN current::text LIKE '%0%';
+
+            IF NOT f_is_prime( current ) THEN
+               CONTINUE MAIN_LOOP;
+            END IF;
+
+
+            FOR i IN 1 .. length( current::text ) LOOP
+                IF NOT f_is_prime( substring( current::text FROM i )::int ) THEN
+                   CONTINUE MAIN_LOOP;
+                END IF;
+            END LOOP;
+
+            fnd := fnd + 1;
+            RETURN NEXT current;
+            IF fnd >= l THEN
+               RETURN;
+            END IF;
+        END LOOP;
+
+        RETURN;
+END
+$CODE$
+LANGUAGE plpgsql;
diff --git a/challenge-147/luca-ferrari/postgresql/ch-2.sql b/challenge-147/luca-ferrari/postgresql/ch-2.sql
new file mode 100644
index 0000000000..61465a21c6
--- /dev/null
+++ b/challenge-147/luca-ferrari/postgresql/ch-2.sql
@@ -0,0 +1,97 @@
+/*
+testdb=> select * from f_pentagons_pairs();
+INFO:  P(1020) + P(2167) = P(8602840) =  1560090
+INFO:  P(1020) - P(2167) = P(5482660) =  7042750
+n1  |  n2  |    s    |    d    |   ps    |   pd
+------+------+---------+---------+---------+---------
+1020 | 2167 | 1560090 | 7042750 | 8602840 | 5482660
+(1 row)
+
+Time: 7257,715 ms (00:07,258)
+
+*/
+
+CREATE OR REPLACE FUNCTION
+f_pentagon( n bigint )
+RETURNS bigint
+AS
+$CODE$
+        SELECT ( n * ( 3 * n - 1 ) / 2 );
+$CODE$
+LANGUAGE sql
+IMMUTABLE;
+
+
+DROP TABLE IF EXISTS pentagons;
+CREATE TABLE pentagons
+(
+        n bigint
+        , p bigint GENERATED ALWAYS AS ( f_pentagon( n ) ) STORED
+);
+
+
+
+INSERT INTO pentagons( n )
+SELECT generate_series( 1, 5000 );
+
+
+
+
+CREATE OR REPLACE FUNCTION
+f_pentagons_pairs()
+RETURNS TABLE ( n1 bigint, n2 bigint,  s bigint, d bigint, ps bigint, pd bigint )
+AS $CODE$
+DECLARE
+        current_tuple pentagons%rowtype;
+        other_tuple   pentagons%rowtype;
+        fnd           int := 0;
+BEGIN
+
+        FOR current_tuple IN SELECT * FROM pentagons ORDER BY n LOOP
+            SELECT *
+            INTO other_tuple
+            FROM pentagons pp
+            WHERE EXISTS(
+                  SELECT *
+                  FROM pentagons ps
+                  WHERE ps.p = current_tuple.p + pp.p
+                  )
+           AND EXISTS (
+               SELECT *
+               FROM pentagons ps
+               WHERE ps.p = abs( current_tuple.p - pp.p )
+           );
+
+
+           IF FOUND THEN
+              SELECT current_tuple.n
+                     , other_tuple.n
+                     , current_tuple.p
+                     , other_tuple.p
+                     , current_tuple.p + other_tuple.p
+                     , abs( current_tuple.p - other_tuple.p )
+                     , p1.n
+                     , p2.n
+              INTO n1, n2, s, d, ps, pd
+              FROM pentagons p1, pentagons p2
+              WHERE p1.p = current_tuple.p + other_tuple.p
+              AND   p2.p = abs( current_tuple.p - other_tuple.p );
+
+              RAISE INFO 'P(%) + P(%) = P(%) =  %',
+                         n1, n2, ps, s;
+
+             RAISE INFO 'P(%) - P(%) = P(%) =  %',
+                        n1, n2, pd, d;
+
+
+              fnd := fnd + 1;
+              RETURN NEXT;
+              RETURN;
+           END IF;
+
+        END LOOP;
+
+        RETURN;
+END
+$CODE$
+LANGUAGE plpgsql;
diff --git a/challenge-147/luca-ferrari/raku/ch-1.p6 b/challenge-147/luca-ferrari/raku/ch-1.p6
new file mode 100755
index 0000000000..53eb20c0c0
--- /dev/null
+++ b/challenge-147/luca-ferrari/raku/ch-1.p6
@@ -0,0 +1,17 @@
+#!raku
+
+sub MAIN( Int $limit = 20 ) {
+
+    my @primes;
+
+    for 10 .. Inf -> $current {
+        next if $current ~~ / 0 /;
+        next if ! $current.is-prime;
+        my @values.push: $current.comb[ $_ .. * - 1 ].join.Int for 0 ..^ $current.Str.chars;
+        @primes.push: $current if @values.grep( *.is-prime ).elems == @values.elems;
+        last if @primes.elems >= $limit;
+
+    }
+
+    @primes.join( "\n" ).say;
+}
diff --git a/challenge-147/luca-ferrari/raku/ch-2.p6 b/challenge-147/luca-ferrari/raku/ch-2.p6
new file mode 100755
index 0000000000..daab2b97c4
--- /dev/null
+++ b/challenge-147/luca-ferrari/raku/ch-2.p6
@@ -0,0 +1,31 @@
+#!raku
+
+ sub MAIN( Int $limit = 3000 ) {
+
+     my ( %pentagons, %inverse-pentagons );
+     %pentagons{ $_ } = ( $_ * ( 3 * $_ - 1 ) / 2 ) for 1 .. $limit;
+     %inverse-pentagons{ %pentagons{ $_ } } = $_ for %pentagons.keys.sort;
+
+
+
+     for %pentagons.keys.sort -> $index-left {
+         for %pentagons.keys.sort -> $index-right {
+             next if $index-left == $index-right;
+
+
+             my ( $sum, $diff ) = %pentagons{ $index-left } + %pentagons{ $index-right },
+                                                            abs( %pentagons{ $index-left } - %pentagons{ $index-right } );
+
+             # this is too slow, therefore I use an inverse hash!
+             # next if ! %pentagons.values.grep( * ~~ $sum );
+             # next if ! %pentagons.values.grep( * ~~ $diff );
+             next if %inverse-pentagons{ $diff }:!exists;
+             next if %inverse-pentagons{ $sum }:!exists;
+
+             "P( $index-left ) + P( $index-right ) = { %pentagons{ $index-left } } + { %pentagons{ $index-right } } = $sum = P( { %inverse-pentagons{ $sum } } )".say;
+             "P( $index-left ) - P( $index-right ) = { %pentagons{ $index-left } } + { %pentagons{ $index-right } } = $diff = P( {%inverse-pentagons{ $diff } } )".say;
+             exit;
+         }
+     }
+
+ }
diff --git a/challenge-147/mark-anderson/raku/ch-1.raku b/challenge-147/mark-anderson/raku/ch-1.raku
new file mode 100644
index 0000000000..e4dc7996fc
--- /dev/null
+++ b/challenge-147/mark-anderson/raku/ch-1.raku
@@ -0,0 +1,19 @@
+#!/usr/bin/env raku
+
+say (2, 3, { $_ + 2 } ... *).grep(&tp).head(20);
+
+multi tp(\n where *.index: 0)
+{
+    False
+}
+
+multi tp(\n where * < 10)
+{
+    n.is-prime
+}
+
+multi tp(\n)
+{
+    return False unless n.is-prime;
+    samewith(n.substr: 1);  
+}
diff --git a/challenge-147/mark-anderson/raku/ch-2.raku b/challenge-147/mark-anderson/raku/ch-2.raku
new file mode 100644
index 0000000000..e81d6177a0
--- /dev/null
+++ b/challenge-147/mark-anderson/raku/ch-2.raku
@@ -0,0 +1,24 @@
+#!/usr/bin/env raku
+
+# Through trial and error I came up with the ~2200 figure.
+
+my @p = (2200...1).map(&pentagonal);
+
+for @p.combinations: 2
+{
+    if is-pentagonal(.head + .tail) and is-pentagonal(abs(.head - .tail))
+    {
+        say .head ~ ", " ~ .tail;
+        last;
+    }
+}
+
+sub pentagonal(\n)
+{
+    n * (3 * n - 1) / 2
+}
+
+sub is-pentagonal(\n)
+{
+    ((sqrt(24 * n + 1) + 1) / 6).narrow ~~ UInt
+}
diff --git a/challenge-147/mohammad-anwar/perl/ch-1.pl b/challenge-147/mohammad-anwar/perl/ch-1.pl
new file mode 100644
index 0000000000..e61081de32
--- /dev/null
+++ b/challenge-147/mohammad-anwar/perl/ch-1.pl
@@ -0,0 +1,81 @@
+#!/usr/bin/perl
+
+=head1
+
+Week 147:
+
+    https://theweeklychallenge.org/blog/perl-weekly-challenge-147
+
+Task #1: Truncatable Prime
+
+    Write a script to generate first 20 left-truncatable prime numbers in base 10.
+
+=cut
+
+use strict;
+use warnings;
+use Test::More;
+use Test::Deep;
+
+is_deeply(
+    left_truncatable_primes(20),
+    [ 2, 3, 5, 7, 13, 17, 23, 37, 43, 47, 53, 67, 73, 83, 97, 113, 137, 167, 173, 197 ],
+    'Example'
+);
+
+done_testing;
+
+#
+#
+# METHODS
+
+sub left_truncatable_primes {
+    my ($count) = @_;
+
+    my $ltp = [];
+    my $c   = 0;
+    my $n   = 2;
+    while ($c < $count) {
+        if (($n !~ /0/) && is_prime($n)) {
+            my @n = left_truncatable_numbers($n);
+            my $found = 1;
+            if (@n >= 2) {
+                foreach my $_n (@n) {
+                    $found = 0 unless (is_prime($_n));
+                }
+            }
+            if ($found) {
+                push @$ltp, $n;
+                $c++;
+            }
+        }
+        $n++;
+    }
+
+    return $ltp;
+}
+
+sub left_truncatable_numbers {
+    my ($n) = @_;
+
+    my @n = ();
+    my $i = 0;
+    while ($i < length($n)) {
+        push @n, substr($n, $i);
+        $i++;
+    }
+
+    return @n;
+}
+
+sub is_prime {
+    my ($n) = @_;
+
+    return 0 if ($n == 1);
+
+    foreach my $i (2 .. sqrt $n) {
+        return 0 unless $n % $i
+    }
+
+    return 1;
+}
diff --git a/challenge-147/mohammad-anwar/raku/ch-1.raku b/challenge-147/mohammad-anwar/raku/ch-1.raku
new file mode 100644
index 0000000000..da23ec26f1
--- /dev/null
+++ b/challenge-147/mohammad-anwar/raku/ch-1.raku
@@ -0,0 +1,63 @@
+#!/usr/bin/env raku
+
+=begin pod
+
+Week 147:
+
+    https://theweeklychallenge.org/blog/perl-weekly-challenge-147
+
+Task #1: Truncatable Prime
+
+    Write a script to generate first 20 left-truncatable prime numbers in base 10.
+
+=end pod
+
+use Test;
+
+is-deeply(
+    left-truncatable-primes(20),
+    [ 2, 3, 5, 7, 13, 17, 23, 37, 43, 47, 53, 67, 73, 83, 97, 113, 137, 167, 173, 197 ],
+    'Example'
+);
+
+done-testing;
+
+#
+#
+# METHODS
+
+sub left-truncatable-primes(Int $count) {
+    my $ltp   = [];
+    my Int $c = 0;
+    my Int $n = 2;
+    while $c < $count {
+        if $n !~~ /0/ && $n.is-prime {
+            my @n = left-truncatable-numbers($n);
+            my Bool $found = True;
+            if @n.elems >= 2 {
+                for @n -> $_n {
+                    $found = False unless $_n.is-prime;
+                }
+            }
+            if ($found) {
+                $ltp.push: $n;
+                $c++;
+            }
+        }
+        $n++;
+    }
+
+    return $ltp;
+}
+
+sub left-truncatable-numbers(Int $n) {
+
+    my @n = ();
+    my Int $i = 0;
+    while $i < $n.codes {
+        @n.push: substr($n, $i);
+        $i++;
+    }
+
+    return @n;
+}
diff --git a/challenge-147/roger-bell-west/javascript/ch-1.js b/challenge-147/roger-bell-west/javascript/ch-1.js
new file mode 100755
index 0000000000..3ad09c3efd
--- /dev/null
+++ b/challenge-147/roger-bell-west/javascript/ch-1.js
@@ -0,0 +1,97 @@
+#! /usr/bin/node
+
+// by Frank Tan
+// https://stackoverflow.com/questions/38400594/javascript-deep-comparison
+function deepEqual(a,b)
+{
+    if( (typeof a == 'object' && a != null) &&
+        (typeof b == 'object' && b != null) )
+    {
+        var count = [0,0];
+        for( var key in a) count[0]++;
+        for( var key in b) count[1]++;
+        if( count[0]-count[1] != 0) {return false;}
+        for( var key in a)
+        {
+            if(!(key in b) || !deepEqual(a[key],b[key])) {return false;}
+        }
+        for( var key in b)
+        {
+            if(!(key in a) || !deepEqual(b[key],a[key])) {return false;}
+        }
+        return true;
+    }
+    else
+    {
+        return a === b;
+    }
+}
+
+function genprimes(mx) {
+    let primesh=new Set([2,3]);
+    for (let i = 6; i <= mx+1; i += 6) {
+        for (let j = i-1; j <= i+1; j += 2) {
+            if (j <= mx) {
+                primesh.add(j);
+            }
+        }
+    }
+    let q=[2,3,5,7];
+    let p=q.shift();
+    let mr=Math.floor(Math.sqrt(mx));
+    while (p <= mr) {
+        if (primesh.has(p)) {
+            let i=p*p
+            for (let i=p*p; i <= mx; i += p) {
+                primesh.delete(i);
+            }
+        }
+        if (q.length < 2) {
+            q.push(q[q.length-1]+4);
+            q.push(q[q.length-1]+2);
+        }
+        p=q.shift();
+    }
+    let primes=[...primesh];
+    primes.sort(function(a,b) {
+        return a-b;
+    });
+    return primes;
+}
+
+function tos(n) {
+    return n.toString();
+}
+
+function ltruncprimes(count) {
+    let out=[];
+    let lt=0;
+    let p=genprimes(500).map(tos);
+    let pp=new Set(p);
+    for (let pc of p) {
+        let l=pc.length;
+        let c=true;
+        for (let i=1;i<l;i++) {
+            if (!pp.has(pc.slice(i))) {
+                c=false;
+                break;
+            }
+        }
+        if (c) {
+            out.push(parseInt(pc));
+            lt++;
+            if (lt >= count) {
+                break;
+            }
+        }
+    }
+    return out;
+}
+
+if (deepEqual(ltruncprimes(20),[2, 3, 5, 7, 13, 17, 23, 37, 43, 47, 53, 67, 73, 83, 97, 113, 137, 167, 173, 197])) {
+    process.stdout.write("Pass");
+} else {
+    process.stdout.write("FAIL");
+}
+process.stdout.write("\n");
+
diff --git a/challenge-147/roger-bell-west/javascript/ch-2.js b/challenge-147/roger-bell-west/javascript/ch-2.js
new file mode 100755
index 0000000000..2cbfbc98a8
--- /dev/null
+++ b/challenge-147/roger-bell-west/javascript/ch-2.js
@@ -0,0 +1,38 @@
+#! /usr/bin/node
+
+function pentagon(n) {
+    return Math.floor(n*(3*n-1)/2);
+}
+
+function pentpair() {
+    let fpent=[0];
+    let rpent=new Map();
+    let mx=0;
+    let a=1;
+    while (true) {
+        while (mx < a) {
+            mx++;
+            fpent.push(pentagon(mx));
+            rpent.set(fpent[mx],mx);
+        }
+        for (b = 1; b < a; b++) {
+            let d=fpent[a]-fpent[b];
+            if (rpent.has(d)) {
+                let s=fpent[a]+fpent[b];
+                while (s > fpent[mx]) {
+                    mx++;
+                    fpent.push(pentagon(mx));
+                    rpent.set(fpent[mx],mx);
+                }
+                if (rpent.has(s)) {
+                    console.log("P(%d) + P(%d) = %d + %d = %d = P(%d)",a,b,fpent[a],fpent[b],s,rpent.get(s));
+                    console.log("P(%d) - P(%d) = %d - %d = %d = P(%d)",a,b,fpent[a],fpent[b],d,rpent.get(d));
+                    throw '';
+                }
+            }
+        }
+        a++;
+    }
+}
+
+pentpair();
diff --git a/challenge-147/roger-bell-west/kotlin/ch-1.kt b/challenge-147/roger-bell-west/kotlin/ch-1.kt
new file mode 100644
index 0000000000..a4675871d0
--- /dev/null
+++ b/challenge-147/roger-bell-west/kotlin/ch-1.kt
@@ -0,0 +1,69 @@
+import kotlin.math.*
+
+fun genprimes(mx: Int): ArrayList<Int> {
+    var primesh=mutableSetOf<Int>()
+    for (i in 2..3) {
+        primesh.add(i)
+    }
+    for (i in 6..mx+1 step 6) {
+        for (j in i-1..i+1 step 2) {
+            if (j <= mx) {
+                primesh.add(j)
+            }
+        }
+    }
+    var q=ArrayDeque(listOf(2,3,5,7))
+    var p=q.removeFirst()
+    val mr=sqrt(mx.toDouble()).toInt()
+    while (p <= mr) {
+        if (primesh.contains(p)) {
+            for (i in p*p..mx step p) {
+                primesh.remove(i)
+            }
+        }
+        if (q.size < 2) {
+            q.add(q.last()+4)
+            q.add(q.last()+2)
+        }
+        p=q.removeFirst()
+    }
+    var primes=ArrayList(primesh.distinct())
+    primes.sort()
+    return primes
+}
+
+fun ltruncprimes(count: Int): ArrayList<Int> {
+    var out=ArrayList<Int>()
+    var lt=0
+    val p=genprimes(500).map {it.toString()}
+    var pp=mutableSetOf<String>()
+    for (i in p) {
+        pp.add(i)
+    }
+    for (pc in p) {
+        val l=pc.length-1
+        var c=true
+        for (i in 1..l) {
+            if (!pp.contains(pc.slice(i..l))) {
+                c=false
+                break
+            }
+        }
+        if (c) {
+            out.add(pc.toInt())
+            lt += 1
+            if (lt >= count) {
+                break
+            }
+        }
+    }
+    return out
+}
+
+fun main() {
+  if (ltruncprimes(20) == listOf(2, 3, 5, 7, 13, 17, 23, 37, 43, 47, 53, 67, 73, 83, 97, 113, 137, 167, 173, 197)) {
+    println("Pass")
+  } else {
+    println("FAIL")
+  }
+}
diff --git a/challenge-147/roger-bell-west/kotlin/ch-2.kt b/challenge-147/roger-bell-west/kotlin/ch-2.kt
new file mode 100644
index 0000000000..165ab5ce2d
--- /dev/null
+++ b/challenge-147/roger-bell-west/kotlin/ch-2.kt
@@ -0,0 +1,41 @@
+import kotlin.system.exitProcess
+
+fun pentagon(n: Int): Int {
+    return n*(3*n-1)/2
+}
+
+fun pentpair() {
+    var fpent=ArrayList<Int>()
+    fpent.add(0)
+    var rpent=mutableMapOf<Int,Int>()
+    var mx=0
+    var a=1
+    while (true) {
+        while (mx < a) {
+            mx += 1
+            fpent.add(pentagon(mx))
+            rpent.put(fpent[mx],mx)
+        }
+        for (b in 1..a-1) {
+            val d=fpent[a]-fpent[b]
+            if (rpent.contains(d)) {
+                val s=fpent[a]+fpent[b]
+                while (s > fpent[mx]) {
+                    mx += 1
+                    fpent.add(pentagon(mx))
+                    rpent.put(fpent[mx],mx)
+                }
+                if (rpent.contains(s)) {
+                    println("P(%d) + P(%d) = %d + %d = %d = P(%d)".format(a,b,fpent[a],fpent[b],s,rpent[s]))
+                    println("P(%d) - P(%d) = %d - %d = %d = P(%d)".format(a,b,fpent[a],fpent[b],d,rpent[d]))
+                    exitProcess(0)
+                }
+            }
+        }
+        a += 1
+    }
+}
+
+fun main() {
+  pentpair()
+}
diff --git a/challenge-147/roger-bell-west/lua/ch-1.lua b/challenge-147/roger-bell-west/lua/ch-1.lua
new file mode 100755
index 0000000000..c2e65f23b0
--- /dev/null
+++ b/challenge-147/roger-bell-west/lua/ch-1.lua
@@ -0,0