Perl Weekly Challenge 202: nested loops everywhere!

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

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 202 - Task 1 - Raku Implementation

The first task was about searching for a natural sequence of odd numbers within an input array of integers.

sub MAIN( Bool :$verbose = False,
	*@list where { @list.grep( { $_ ~~ Int && $_ > 0 } ).elems == @list.elems } ) {
    my @odds;
    for @list {
		next if $_ %% 2;
		@odds.push: $_ and next if ( ! @odds );
		next if @odds.grep( $_ );
		next if $_ != ( @odds[ * - 1 ] + 2 );
		@odds.push: $_;
    }

    @odds.join( ', ' ).say if $verbose;
    '1'.say and exit if ( @odds.elems >= 3 );
    '0'.say;
}

The idea is quite simple: I iterate over the @list of numbers and add the first odd that I find into the @odds array. Then I seek for the next odd number, that is the last one I found added by 2. When I find the next odd number, I add it to the @odds array. Last I test if the @odds array has a length greater or equal to 3.

PWC 202 - Task 2 - Raku Implementation

This task is a little more complex to understand: find out the largest left valley within a number array. A valley is a sequence made by two parts, left and right, where the left is not increasing and the right is not decreasing.

sub MAIN( *@list where { @list.grep( { $_ > 0 && $_ ~~ Int } ).elems == @list.elems } ) {

    my %valleys;

    for 0 ..^ @list.elems - 1 -> $index {
	my $current = @list[ $index ];
	next if @list[ $index + 1 ] > $current;  # increasing!

	my @valley-left;
	@valley-left.push: $current;
	for $index ^..^ @list.elems {
	    my $previous = @valley-left[ * - 1 ];
	    @valley-left.push: @list[ $_ ] if ( @list[ $_ ] <= $previous );
	    last if @list[ $_ ] > $previous;
	}

	my @valley-right;

	if ( $index + @valley-left.elems  < @list.elems ) {
	    @valley-right.push: @list[ $index + @valley-left.elems ];
	    for $index + @valley-left.elems ^..^ @list.elems {
		my $previous = @valley-right[ * - 1 ];
		@valley-right.push: @list[ $_ ] if ( @list[ $_ ] >= $previous );
		last if @list[ $_ ] < $previous;
	    }
	}

	%valleys{ @valley-left.elems + @valley-right.elems } = [ |@valley-left, |@valley-right ];
    }

    %valleys{ %valleys.keys.max }.join( ', ' ).say;

}

My implementation is really verbose. The idea is that I seek for the beginning of the partitioning looking for the first two numbers where the latter is greater than the former. This clearly begins a left side partitioning. Then I loop over the list to extract the widest array where there is not an increasing set of values, and I place every value into the @valley-left array. Then I do continue from there and seek for the right partition, placing all values into the @valley-right. The result, that is the concatenation between @valley-left and @valley-right, is placed into an hash named %valleys keyed by the size of the resulting concatenation. Last, I extract the value having the highest key.

PL/Perl Implementations

PWC 202 - Task 1 - PL/Perl Implementation

A mere implementation of the Raku approach:

PWC 202 - Task 2 - PL/Perl Implementation

Same implementation as the Raku one, with the only difference that I keep track of the $largest concatenation found, so that I can lookup quickly.

PostgreSQL Implementations

PWC 202 - Task 1 - PL/PgSQL Implementation

Same implementation as in the previous tasks, with the only difference to keep in mind that in SQL arrays starts at index 1!

PWC 202 - Task 2 - PL/PgSQL Implementation

Same implementation of Raku, with the usage of a table instead of an hash.



The temporary table pwc202 is used as an hash to store the left and right partitions, and last I return the result of a query that extracts only one record with the highest size.