Perl Weekly Challenge 253: not so easily handling multidimensional arrays

This post presents my solutions to the Perl Weekly Challenge 253.
I keep doing the Perl Weekly Challenge in order to mantain my coding skills in good shape, as well as in order to learn new things, with particular regard to Raku, a language that I love.
This week, I solved the following tasks:

• PWC 253 - Task 1 - Raku
• PWC 253 - Task 2 - Raku
• PWC 253 - Task 1 in PostgreSQL PL/Perl
• PWC 253 - Task 2 in PostgreSQL PL/Perl
• PWC 253 - Task 1 in PostgreSQL PL/PgSQL
• PWC 253 - Task 2 in PostgreSQL PL/PgSQL
• PWC 253 - Task 1 in PL/Java
• PWC 253 - Task 2 in PL/Java
• PWC 253 - Task 1 in Python
• PWC 253 - Task 2 in Python

The PL/Perl implementations are very similar to a pure Perl implementation, even if the PostgreSQL environment could involve some more constraints. Similarly, the PL/PgSQL implementations help me keeping my PostgreSQL programming skills in good shape.

Raku Implementations

PWC 253 - Task 1 - Raku Implementation

Given an array of strings and a separator, print out all the words that can be split from the array using the separator.

sub MAIN( $separator, *@words ) {
    @words.split( $separator, :skip-empty ).join( ',' ).say;
}

PWC 253 - Task 2 - Raku Implementation

Given a binary matrix, compute the weak rows and print the indexes of the rows from the weakenest to the strongest one. A row is considered weak if it has less 1s of another row, and in the case two rows have the same exact number of 1s, the one with the smallest index is weaker.

sub MAIN() {

    my $matrix = [
                   [1, 1, 0, 0, 0],
                   [1, 1, 1, 1, 0],
                   [1, 0, 0, 0, 0],
                   [1, 1, 0, 0, 0],
                   [1, 1, 1, 1, 1]
    ];

    my %ones;
    for 0 ..^ $matrix.elems -> $row_index {
		my $count = $matrix[ $row_index ].grep( * ~~ 1 ).elems;
		%ones{ $count }.push: $row_index;
    }


    my @rows.push: |%ones{ $_ }.sort for %ones.keys.sort;
    @rows.join( ', ').say;
}

The idea is quite simple: I use a %ones hash keyed at the count of 1s in a row, that contains an array with all the indexes of the rows with such cpount. Then I sort the keys, i.e., the counting of ones, sort the values in the rows (i.e., the indexes) and print out everything. The flatting of the list is due to the fact the Raku preseves internal lists, in this case arrays of indexes, while I want a flat list to output.

PL/Perl Implementations

PWC 253 - Task 1 - PL/Perl Implementation

Simple enough implementation: split each input array element by means of $separator specified as first argument.



There is a trick, however: I need to build a regular expression that contains the $separator into the square backets, in order to protect some particular characters (e.g., .).

PWC 253 - Task 2 - PL/Perl Implementation

Same approach as in Raku: I first classify the rows into an hash keyed by the count of 1s, and then sort the keys and return the sorted list of values.

PostgreSQL Implementations

PWC 253 - Task 1 - PL/PgSQL Implementation

For every words in the array of text, I use a query to split the values by means of the separator (again, in square brackets) and return the result set.

PWC 253 - Task 2 - PL/PgSQL Implementation

Handling multi-dimensional arrays in PL/PgSQL is a mess. Therefore I use a nested loop to examine every element of the matrix, and count the number of ones. I put the results in a table ones that is used an a lookup hash, and then return the right row indexes according to the ordering of keys and values

Java Implementations

PWC 253 - Task 1 - PostgreSQL PL/Java Implementation

An approach similar to the PL/Perl one: I iterate other all the words, and split them by means of the split method using a regular expression that contains the separator into square brackets to avoid regular expression interpolation of special characters.

PWC 253 - Task 2 - PostgreSQL PL/Java Implementation

If handling multi-dimensional arrays in PL/PgSQL is difficult, it is even mor in PL/Java: arrays are monodimensional and there is no information about the dimension. Therefore, the function accepts a size value that determines how many elements a single matrix rows has. The implementation then is the same as PL/Perl: ones is an hash keyed at the counting of ones for every row, and which values are the row indexes. Then, it is only a matter of sorting keys and values.

Python Implementations

PWC 253 - Task 1 - Python Implementation

Quite simple implementation: I split the words using a regular expression and then join everything I find.

PWC 253 - Task 2 - Python Implementation

The approach is the same as in Raku and PL/Perl: I use a dictionary keyed by the count of 1s to store an array with the indexes of the matrix rows. Then I do sort everything and get back to join into a single string.