PWC #250

PWC 250

Disclaimer on earlier "Perl 4" attempts

In my previous challenges, I often mentioned sticking to Perl 4 syntax. I did not actually have Perl 4, so could not test on that platform. 

Recently, I did manage to find an old MS-DOS executable of Perl 4.019 that I can run in DOSBOX.

I quickly found that my "Perl 4" answers to earlier challenges will not run in Perl 4.

Particularly, my habit of using "local *xxx = sub { ...};" to create a localized sub will not work on Perl 4. Firstly, the "local" keyword must be used with a bracketed list of arguments, as local (*x, ...). The statement form "local *x," gives a syntax error. Secondly, the sub keyword cannot appear on the right-hand-side of an assignment. Syntax error again even with "local (*x)=sub {..};" .

Looks like this facility to assign a sub to a local glob only became available in Perl 5. In Perl 4, looks like subroutines always had to be global or package-level in scope.

If I get time, I will update my earlier blog posts to add this disclaimer.

Challenge 1 (Smallest Index)

We are given a list of integers ints say. We are asked to return the smallest index i such that:

(i % 10) == ints[i]

The indices start from 0, as in Perl.

If there is no index matching the condition, we return -1.

This is a quick and easy task in Perl 5. Could be a one-liner, but I opt for a longer subroutine.

Here is the key snippet:

my $smallest_index = sub {
    my $retval=
    (sort {$a<=>$b}
    (grep {($_ % 10) == ($_[$_])} (0 .. $#_))
    )[0];
    defined($retval) ? $retval : -1;
};

I use grep to extract the indices of ints that match the condition, sort these in ascending order, and then return the first (minimum) element. If there is no such element because the grep returned an empty list, I return -1.

Challenge 2 (Alphanumeric string value)

We are given a list of strings. For each string in the list, we evaluate a number using the following rule. 

  • If the string can be evaluated as a base-10 number (like "4" or "000"), the number is simply this number (4 for "4" and 0 for "000").
  • Otherwise, the number is the string length.

We return the highest of the numbers derived from each input list element.

Again, a quick and easy task in Perl 5. Potential one-liner for sure, but I prefer to stick to a longer subroutine. Here it is:

local *alphanumeric_string_value = sub {
    local *alphanumeric_string_value = sub {
        ($_[0] =~ /^[0-9]+$/) ?
        (0+$_[0]) :
        length($_[0]);
    };

    (sort {$b<=>$a}
    (map {&alphanumeric_string_value($_)} @_)) [0];
};

I use dynamic (local) scope to redefine the alphanumeric_string_value sub inside itself. The inner version applies to a scalar treated as a string, while the outer version loops over a list, calling the inner version for each element; and then returning the maximum.

The inner version checks the string to see if it consists only of digits. If it does, then we evaluate it numerically by adding it to 0, otherwise we take the length of the string. 

This only recognizes positive integers as numeric, "-1.23" or "4.5" would be treated as strings.This matches the spec which indicates that only strings consisting of digits only should be treated as numbers.

Comments

Post a Comment

Popular posts from this blog

PWC 227

PWC 227 Challenge 1 (Friday 13th) This challenge requires us to count the number of times Friday 13th occurs in a particular year. I use Date::Manip. This module probably has easier ways to do this using a Date Range, but my approach is easy enough. My &friday_13th subroutine takes the year as input, throws an exception if it is outside the specified range (1753 to 9999), and then cycles through the 13th of each month, counting the Fridays. use Date::Manip; my $dateobj=Date::Manip::Date->new(); sub friday_13th {     my ($year)=@_;     my $retval=0;     ( ($year > 9999) || ($year < 1753) ) &&         die "Year should be between 1753 and 9999";     map {         ( ($dateobj->new_date("$year-$_-13")->printf('%w') ) == 5 ) &&             $retval++;     }     1 .. 12;          $retval; }   Challenge 2 (Roman Maths) This challenge requires us to implement a calculator that parses infix math operations using roman numerals.  There
Read more

PWC 234

PWC 234 I tried to restrict to Perl 4 syntax for both challenges this week, as documented in Rex Swain's Perl 4 reference or the 1st edition of Programming perl. I do use nested subroutines, which I am not sure would actually work in Perl 4, though they comply with the syntax. My programs are tested on Perl 5.38. (The -l in the shebang line works only in Perl 5. The Perl 4 equivalent was -L012 in Unix, which is no longer available.) As I have mentioned before, my aims in using the old syntax are just mild nostalgia plus to add a bit of additional challenge to the task. I know that this is not the most efficient or idiomatic way to do things today. But I should observe that it is really cool that I am able to write code using 30-year old syntax, and run it unmodified on the latest Perl 5.38. You cannot do this with Python 3 for example. This very deep backward compatibility is one of those unsung underappreciated beauties of Perl 5. In my opinion, it is a very cool thing 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