Perl Weekly Challenge 156: Pernicious weirdness

It is sad that, after more than two years of me doing Raku, I still don’t have any production code project to work on. Therefore, in order to keep my coding and Raku-ing (is that a term?) knowdledge, I try to solve every Perl Weekly Challenge tasks.

In the following, the assigned tasks for Challenge 156.

• Task 1
• Task 2

and for the sake of some Perl 5, let’s do some stuff also in PostgreSQL Pl/Perl:

• Task 1 in PostgreSQL Pl/Perl
• Task 2 in PostgreSQL Pl/Perl

COVID-19

Yes, I’ve Covid-19 and I’ve done this PWC late because I was sick. I’m not scared, at the moment I’m almost fine.

PWC 156 - Task 1

Produce the first ten pernicious numbers, that are numbers that have the sum of their binary representation that is prime number. It is quite easy to implement this in Raku:

sub MAIN( Int $limit where { $limit > 0 } = 10 ) {
    my @pernicious = lazy gather {
	for 1 .. Inf {
	    take $_ if $_.base( 2 ).comb.sum.is-prime;
	}
    };

    @pernicious[ 0 .. $limit - 1 ].join( ', ' ).say;
}

I use a lazy gather block to generate the array of required numbers. Every number is translated into its binary form by means of base( 2 ), separated into its digits by means of comb and the sum of all the binary digits is made up by sum. If the result is a prime number, i.e., is-prime, the result is taken into the array.
In the end I print the slice of the array.

PWC 156 - Task 2

Weird numbers this time: numbers that have a sum of divisors that is greater than the number itself and that cannot be obtained by any sum of any divisors.

sub MAIN( Int $n where { $n > 0 } ) {
    my @divisors = ( 1 .. $n - 1 ).grep( $n %% * );
    '0'.say and exit if @divisors.sum <= $n
		     || @divisors.combinations.map( *.sum ).grep( * == $n ).elems > 0;
    '1'.say;
}

As first step, I compute the @divisors by means of grepping all the values that are divisors of the given number. Then, I inspect the sum of the @divisors to see if it is greater than the number itself, and then use all combinations of the divisors to see if any of the sum provides the number itself, in such case the number is not weird.

PWC 156 - Task 1 in PostgreSQL

An implementation with a couple of PL/Perl functions and a single query. Pure Pl/Perl implementation, with a single function (that has nested anonymous subs).



The first function is the usual is_prime, built to return the right values for the given input.
The sumbits function accepts an array of digits and returns its sum. It is interesting to note that the PostgreSQL ARRAY is not the same as a Perl list, and in fact is managed by PL/Perl by a specific object that can be used as an array reference, hence @{ $_[0] }.
The query does all the work:

• generate_series provides the first thousand integers;
• the cast to ::bit(10) converts the integer into its binary representation;
• regexp_slit_to_array converts the text binary representation into an array of integers;
• sumbits computes the sum of the bits;
• is_prime sees if the sum is a prime number.

PWC 156 - Task 2 in PostgreSQL

Here I decided to use a library, hence the need for plperlu to load an external module. The module is Algorithm::Knapsack that can provide a brute force implementation of the knapsack problem. The idea is that you can initialize the knapsack with a capacity and a set of weights, and the system computes all possible solutions that fill the bag at its maximum. The idea therefore is to see if any of these solutions fill the whole capacity, in our case the input number.



The weird function does everything:

• computes the array of the @divisors;
• initializes the $knapsack and computes the solutions;
• then inspect every solution to see if the sum of the divisors provides back the input number.

The query does everything, testing the implementation.