Perl Weekly Challenge 138: split working days

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 138.

• Task 1
• Task 2

And this week, as for the previous PWC, I had time to quickly implement the tasks also on PostgreSQL plpgsql language:

• Task 1 in plpgsql
• Task 2 in plpgsql

PWC 138 - Task 1

The first task was about computing how many working days there are in a given year. A working day is a day that is not either a Sunday or a Saturday.
I decided to implement it as huge loop:

sub MAIN( Int $year where { $year ~~ / \d ** 4 / } && $year > 1900,
        Bool :$verbose = False ) {
    my Date $date .= new: year => $year, day => 1, month => 1;
    my Date $stop .= new: year => $year, day => 31, month => 12;
    my $work-days = 0;
    while ( $date <= $stop ) {
        $work-days += 1 if $date.day-of-week != any( 6, 7 );
        $date = $date + 1;
    }

    "$year has $work-days work days".say if $verbose;
    $work-days.say if ! $verbose;
}

The idea is that $date contains the current date, starting from the very first day of the year. I don’t take into account holidays. The $stop represents the last day of the year, so my idea is to iterate one day at time from $start to $stop. If $date represents a weekly day that is not either 6 or 7 (the Raku Date representation of Saturday and Sunday), I increment the $work-days counter. Note that I use a junction to quickly test a double expressed condition.

PWC 138 - Task 2

The second task was assigning a perfect square number, and the program has to find out if the square of the number can be split as a combination of the digits of the number itself.
My solution is not ideal, but should work in many cases.

sub MAIN( Int:D $n where { $n > 0 } ) {
    my $qrt = $n.sqrt;
    my @digits = $n.split( '', :skip-empty );

    # short circuit: esay case
    1.say and exit if @digits.sum == $qrt;

    # try to aggregate from left to right
    for 1 ..^ @digits.elems {
        last if @digits[ 0 .. $_ ].join.Int > $qrt;
        '1'.say and exit if @digits[ 0 .. $_ ].join + @digits[ $_ + 1 .. * - 1 ].sum == $qrt;
    }
    
}

I compute the sqrt of the given input number, that I assign to the $qrt variable (there is no s because the $ sigil appears as an s). I then extract every @digits and look if the sum of single digits provides the square root, and this case I can stop the program.
Otherwise, I try to aggregate the digits from left to right only (thus, this is not ideal) and see if the sum of the slices of the @digits array provides me the searched for result.

PWC 138 - Task 1 in PostgreSQL plpgsql

The implementation in sql is not a mirror of the Raku solution because PostgreSQL provides a generate_series() function that can be used to generate a range of dates, in this case from the very beginning to the very end of the year incrementing one day at a time.

CREATE OR REPLACE FUNCTION
  f_working_days_per_year( yy int default extract( year from current_date ) )
  RETURNS int
AS $CODE$
  SELECT count( v )
  FROM generate_series( make_date( yy, 01, 01 ),
                       make_date( yy, 12, 31 ),
                       '1 days' ) v
  WHERE
     extract( dow from v ) NOT IN ( 0, 6 );
  $CODE$
  LANGUAGE sql;
                                                             
                                                             

It does then suffice to count all the resulting rows (i.e., days) that are not Sundays or Saturdays (respectively 6 and 0 in DOW) to get the final result.

PWC 138 - Task 2 in PostgreSQL plpgsql

The second task is a plpgsql re-implementation of the Raku solution.

CREATE OR REPLACE FUNCTION
  f_split_numbers( n int default 9801 )
  RETURNS int
AS $CODE$
  DECLARE
  sqrt int := sqrt( n );
  digits int[] := regexp_split_to_array( n::text, '' );
  aggregation int := 0;
  sum_left int := 0;
  sum_right int := 0;
BEGIN
  RAISE DEBUG 'Operating for % (sqrt = %)', n, sqrt;

  FOR aggregation IN 1 .. length( n::text ) LOOP
    RAISE DEBUG 'Aggregation index %', aggregation;

    SELECT array_to_string( digits[1:aggregation], '' )::int
           , sum( r )
      FROM ( SELECT unnest( digits[ aggregation + 1: length( n::text ) ] ) AS r ) rr
      INTO sum_left, sum_right;

    RAISE DEBUG '% + %', sum_left, sum_right;

    IF ( sum_left + sum_right ) = sqrt THEN
      RETURN 1;
    END IF;
  END LOOP;

  RETURN 0;
END
  $CODE$
  LANGUAGE plpgsql;


                                                                                                                                                                                          

There is a cast here and there from int to text and viceversa to make the whole thing work, but the idea is to split the given number into its digits (text) and then aggreate them from left to right. The difference from the Raku implementation is that, in SQL, arrays start at index 1. Please note also the use of unnest, that translates an array into a tabular data, so that the sum function can be used.