Perl Weekly Challenge 257: Post-Valentine Challenge

This post presents my solutions to the Perl Weekly Challenge 257.
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 257 - Task 1 - Raku
• PWC 257 - Task 2 - Raku
• PWC 257 - Task 1 in PostgreSQL PL/Perl
• PWC 257 - Task 2 in PostgreSQL PL/Perl
• PWC 257 - Task 1 in PostgreSQL PL/PgSQL
• PWC 257 - Task 2 in PostgreSQL PL/PgSQL
• PWC 257 - Task 1 in PL/Java
• PWC 257 - Task 2 in PL/Java
• PWC 257 - Task 1 in Python
• PWC 257 - 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 257 - Task 1 - Raku Implementation

The first task was to remap an array of integers into an array where every value was the count of elements of the array lower than the current element value. This can be sovled with a single line in Raku:

sub MAIN( *@numbers where { @numbers.elems == @numbers.grep( * ~~ Int ).elems } ) {
    @numbers.map( -> $current { @numbers.grep( * < $current ).elems } ).join( ', ' ).say;
}

PWC 257 - Task 2 - Raku Implementation

Given a matrix of integers, find out if the matrix can be reduced according to specific rules. The rules are not so clear to me, but essentially:

• every row must be either full of zero or the leftmost not zero element must be a one;
• every leftmost one in the row is called a leading one and must be rightmost of the leading ones of the above rows;
• the zero rows must be all at the bottom of the matrix.

sub MAIN() {
    my $M = [
        [1, 1, 0],
        [0, 1, 0],
        [0, 0, 0]
    ];

    my $ok = True;
    my @zero-rows;
    my @leadings;
    for 0 ..^ $M.elems -> $row {
		my $first-in-row = Nil;


		for 0 ..^ $M[ $row ].elems -> $col {
		    next if $M[ $row ][ $col ] == 0;
		    next if $first-in-row;

		    $first-in-row = $M[ $row ][ $col ] if ! $first-in-row;

		    if ( $first-in-row == 1 ) {
				# leading one
				@leadings.push: { row => $row, col => $col };
				# if not other leadings, skip any check
				next if @leadings.elems <= 1;

				$ok = False and last if ( @leadings[ * - 2 ]<col> >= $col && @leadings[ * - 2 ]<row> != ( $row - 1 ) );
		    }
		}

		if ! $first-in-row {
		    # the row was made by all zeros
		    @zero-rows.push: $row;
		    # if this is the first zero row, cannot check anything
		    next if @zero-rows.elems <= 1;
		    # this is not the first zero row, so the previous row must be also zero!
		    $ok = False if @zero-rows[ * - 2 ] != ( $row - 1 );
		}
		elsif $first-in-row != 1 {
		    $ok = False;
		}

		'0'.say and exit if ( ! $ok );
    }

    '1'.say; # here everything is fine
}

I iterate on every row and column, and keep a first-in-row element that is valued only with the leftmost non zero value. Then, if such element is a one, it is also pushed to a @leadings array that keeps track of the rows with the leading values, storing a Pair with the row and column index. On the other hand, if the first-in-row is not valued, the row is filled by zeros, so append its index to the @zero-rows arraay. Then, I check if the @zero-rows array if consistent, as well as columns in @leadings go from left to right.

PL/Perl Implementations

PWC 257 - Task 1 - PL/Perl Implementation

Really simple implementation.

PWC 257 - Task 2 - PL/Perl Implementation

The implement follows the same reasoning of that in Raku.

PostgreSQL Implementations

PWC 257 - Task 1 - PL/PgSQL Implementation

This can be sovled with a single query.



Note the usage of lateral join to evaluate the current v element for every subquery.

PWC 257 - Task 2 - PL/PgSQL Implementation

Here I cheat, and use the PL/Perl implementation directly, because PL/PgSQL is really poor at handling matrixes.

Java Implementations

PWC 257 - Task 1 - PostgreSQL PL/Java Implementation

The task needs to implement a ResultSetProvider since the function must return a single row for every evaluation.



The idea is that the function will create a Task1 object that will store the input array of numbers, and then will produce every row thru the assignRowValues() function. This function, in turn, counts the number of elements less than the current one, dependent on the currentRow passed by the result set provider.

PWC 257 - Task 2 - PostgreSQL PL/Java Implementation

Here there is a complication: PL/Java cannot handle an int[][] as a matrix, thus I use the same trick I would do with PL/PgSQL, hence passing a linear array and a column size to split the linear array into a matrix.



The logic is the same used in PL/Perl and Raku.

Python Implementations

PWC 257 - Task 1 - Python Implementation

Same implementation as PL/Perl, with a lot more clutter to convert results into lists.

PWC 257 - Task 2 - Python Implementation

The same logic in all the other implementations, with the usage of a dictionary instead of an hash.