PWC 196

PWC 196

Aside on Advent of Code

I have done the Advent of Code challenges in Perl 5 up to #14 so far. Here are my solutions. I probably should stop there at least for now, since I have a lot of work despite the holidays. But let's see, #15 looks intriguing, and I'm sure the later ones are too.

Back to discussing our Weekly Challenges for this week. This week, I submitted only Perl 5 and Raku solutions, not Julia.

Challenge 1 (Pattern 132)

We are given a list of at least three integers. We are required to extract one sub-list of three integers that satisfies the following restrictions:

  1. If i,j,k respectively are the indices in the original list of the extracted items, then i < j < k.
  2. If a[i], a[j], a[k] respectively are the items in the sub-list in order, then we have: a[k] > a[i], and a[j] > a[k] (similar to the ordering in the list 1,3,2 whence the name).

This is a one-liner in Raku, using the combinations operator. I did not directly implement restriction 1 above, since it seems that combinations are extracted by default in the same order as they are in the original list. So the combinations operator should take care of this automatically.

Here is my one-liner:

raku -e 'my @list=@*ARGS; (0 .. @list-1).combinations(3).map({@list[$_]}).grep({ @_[2] > @_[0] }).grep({ @_[1] > @_[2] }).head(1).flat.say' $@

From the given list (command-line @*ARGS), extract combinations of 3 elements, and then grep those that satisfy the ordering requirement. If we have more than one result, keep only the first. Flatten before printing so that the output looks nicer (it's a nested list (( ... )) before flattening).

This logic translates directly to Perl 5, with the help of the combinations operator from Algorithm::Combinatorics, though I did not attempt a one-liner in Perl 5, and I have implemented the steps in a slightly different order. In Perl 5 of course, we do not have the left-to-right chaining that we have in Raku, so the logic is constructed from right to left. Also my syntax in Perl 5 yields a flat list of all the sub-lists one after the other (in Raku, we get a list of lists), so I just return the first three elements. Like Raku, the combinations operator seems to preserve the ordering from the original list, so that there is no need to explicitly code for restriction 1 above. Here is the key snippet in Perl 5:

   ( map {@$ra_list[@$_]}
    grep { ( ($$ra_list[$_->[1]]) > ($$ra_list[$_->[2]]) )  }
    grep { ( ($$ra_list[$_->[2]]) > ($$ra_list[$_->[0]]) )  }
    combinations([0 .. @$ra_list-1],3) ) [0 .. 2];

I use Data::Dumper in Perl 5 to print out my results, avoiding the minor chore of writing a subroutine to nicely print out the array.

Challenge 2 (Range list)

We are given a list of integers, which are both sorted in ascending numerical order, and do not contain any duplicates. We are asked to report all the complete closed ranges (of the form $a .. $b in Perl) that occur in the list, and report each of them in mathematical interval format as say [1,5] (not quite mathematically correct, since these are integers only, while that notation typically represents intervals over the reals. But never mind).

As with Challenge 1, I started with Raku and then translated to Perl 5. This time, I did not attempt a one-liner (or rather I tried and gave up fast). Using a pair of subroutines, I extract the sub-lists that form complete closed ranges and store them in an array, and then loop through that array to get the boundaries of each range and print them in the [a,b] format.

Here they are in Raku.

Getting the ranges (and then calling the printing sub to print them out as desired):

sub range-list( @array) {
    my @arry=@array.sort({$^a <=> $^b}).unique; #-- just in case ...
    @arry.unshift(-Inf).push(-Inf);
    &print-edges( @arry[(1 .. @arry-2).grep({(@arry[$_]-@arry[$_-1]==1) || (@arry[$_+1]-@arry[$_]==1)})] );    
}

I wrap the input array in one which is one element longer at both ends, so that I can loop through without Raku complaining about going out of bounds. It's not very difficult to compress into a single-line subroutine, but I'll stick with this more readable version.

And here is the print subroutine.

sub print-edges( @ranges ) {
    my $return-string = "([@ranges[0],";
    for (1 .. @ranges-2) -> $i {
        ( (@ranges[$i] - @ranges[$i-1]) > 1 ) &&
            ($return-string ~= (@ranges[$i-1] ~ "],[" ~ @ranges[$i] ~ ","));
    }
    #-- end the string
    $return-string ~= (@ranges[@ranges-1] ~ "])");
    $return-string;   
}

Comments

Post a Comment

Popular posts from this blog

PWC 258

PWC 258 Last week (#257) I finished challenge 2 and my blog post for challenge 257 late last week, so had only submitted challenge 1. Here is my blog post for PWC 257 , including the full code for my challenge 2 solution. This week, I have done both challenges in perl 4.019 on DOSBOX. Both scripts also work fine on the latest Perl 5.38. I also did the challenges in Raku, where they are one-liners.  Challenge 1 (Count Even Digits Number) We are given a list of integers, and asked to count the number of elements whose base-10 representation has an even number of digits. In Raku , this is a one-liner. Here it is: raku -e 'say +@*ARGS.grep({$_.chars %% 2})' $@ It could be a one-liner in Perl 4 too, but since I run it on DOSBOX, my script would not be a bash shell script. Here is the short subroutine that does the job.  sub count_even_digits {  scalar( grep( ((length($_) % 2) == 0), @_) ); } The full code is here . Challenge 2 (Sum of values) We are given an integer k  and a list in
Read more

PWC 249

PWC 249 Challenge 1 (Equal pairs) We are given a list of integers with an even number of elements. We are asked to check if the list can be completely divided into sub-lists of size 2 with each sub-list containing the same integer repeated, like say (2,2). If so, we are asked to return the list of such sub-lists. This is straightforward in Perl 5. I use modern conveniences this time, though it could be done using only primitive Perl 4 syntax. Here is my subroutine. It returns a list of array references. local *equal_pairs = sub {     #-- return () if input is of odd length     ((scalar(@_) % 2) > 0) && (return ());          #-- count number of occurrences of each element using a hash     local %_ = ();     map {$_{$_}++} @_;          #-- if any element occurs an odd number of times, return ()     (grep {($_{$_} % 2) > 0} keys %_) && (return ());          #-- loop thru %_ keys, returning pairs of such keys     map {         my $k=$_;         my $num_pairs=( ($_{$k}
Read more

PWC 253

PWC 253 I do both challenges this week using old software on DOSBOX: perl 4.019, and for comparison, also python 1.4 beta. My solutions also work on the current versions of Perl 5 (5.38) and Python 2 (2.7.18) respectively. Challenge 1 (Split Strings) Links to code: perl4.019 python1.4b We are given a list of strings, and a single character say sep . We are asked to return the list, with the strings split into component substrings using sep as a separator. We should not include any empty strings in the output. In perl 4, I first stick a backslash in front of the separator character, so that it is escaped if entered in a regex. This is because the perl split function takes a regex as its first argument indicating the separator. If we have a character like '$' or ',', we want to escape it so that it is read literally when parsing the regex. Here is the key subroutine:   sub split_strings {  local ($separator, @words)=@_;  local (@retval)=(); #array to be returned  #  #--
Read more