diff options
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 +1,101 @@ +#! /usr/bin/lua + +-- by Michael Anderson at +-- https://stackoverflow.com/questions/8722620/comparing-two-index-tables-by-index-value-in-lua +function recursive_compare(t1,t2) + -- Use usual comparison first. + if t1==t2 then return true end + -- We only support non-default behavior for tables + if (type(t1)~="table") then return false end + -- They better have the same metatables + local mt1 = getmetatable(t1) + local mt2 = getmetatable(t2) + if( not recursive_compare(mt1,mt2) ) then return false end + + -- Check each key-value pair + -- We have to do this both ways in case we miss some. + -- TODO: Could probably be smarter and not check those we've + -- already checked though! + for k1,v1 in pairs(t1) do + local v2 = t2[k1] + if( not recursive_compare(v1,v2) ) then return false end + end + for k2,v2 in pairs(t2) do + local v1 = t1[k2] + if( not recursive_compare(v1,v2) ) then return false end + end + + return true +end + +function genprimes(mx) + local primesh = {} + for i = 2, 3 do + primesh[i] = true + end + for i = 6, mx+1, 6 do + for j = i-1, i+1, 2 do + if j <= mx then + primesh[j]=true + end + end + end + local q={2,3,5,7} + local p=table.remove(q,1) + local mr=math.floor(math.sqrt(mx)) |