Perl Weekly Challenge 176: scrumbled numbers

It is sad that, after more than three 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 176.

• 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

Last, the solutions in PostgreSQL PL/PgSQL:

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

PWC 176 - Task 1

Find the first and lowest integer number so that the equivalent numbers multiplied by a factor ranging from 2 to 6 are composed by the very same digits. The idea is quite simple:

• grab a number;
• compute the multiplied @values;
• compute the @permutations of the original number and make them integers;
• see if the number of $found permutations that are in the @values multiplied is the right number.

sub MAIN() {

    for 1 .. Inf -> $current {
        my @values = (1 .. 6).map: { $current * $_ };
        # compute the permutations of the current number
        my @permutations = $current.comb.permutations.map: *.join.Int;

        my $found = 0;
        for @values {
            $found++ if $_ == any(@permutations);
        }

        $current.say and last if $found == @values.elems;
    }
}

PWC 176 - Task 2

Find out all reversable numbers up to 100: a number that summed with its mirrored version provides a value made only by odd digits. Quite simple to implement:

sub MAIN( Int $limit = 100 ) {

    for 1 .. $limit {
        $_.say if ! ( $_ + $_.flip.Int ).comb.grep( * %% 2 );
    }
}

But my first implementation was wrong: I used reverse instead of flip, so I got more numbers than those I was expected to get!

PWC 176 - Task 1 in PostgreSQL PL/Perl

The same Raku solution, with a little more work due to chaining split (to get the digits), sort and join:



The idea is the same: I do map the original number multiplying it by a factor, then use split to get the digits, sort to place them in the same order, and join to make it a number again. If two numbers undergoing this chain of methods result in the same value, it means they have the same digits!

PWC 176 - Task 2 in PostgreSQL PL/Perl

The idea is similar to the Raku implementation, with some extra work due to method chaining:

PWC 176 - Task 1 in PostgreSQL PL/PgSQL

In the beginning I thought about simply calling the PL/Perl implementation, than I implemented it with a pure PL/PgSQL function:



For any given number i I do compute its multiplication by a factor m and store it into v. Then I execute a query to see if all digits (via regexp_split_to_table()) of v are within the digits of i: I do count and place into c the number of digits that do not correspond. Therefore, if c is not zero, the current number has a multiple that has not the same digits, so I can restart (or continue) the loop with a next i.

PWC 176 - Task 2 in PostgreSQL PL/PgSQL

Simple enough to be implemented with a check done by a query: for a given number i I do compute the sum with its mirrored part and count how many even digits are there in the resulting sum. If the count is not zero, the number is not reversable, otherwise I can return it within the result set.