PWC 182

PWC 182

Challenge 1 (max index)

Given a list of numbers, we are asked to give the index of the first occurrence of the biggest number in the list.

This is easy to do via one-liners in all three languages.

Here is my Raku one-liner

raku -e 'say (0 .. @*ARGS.elems-1).grep({@*ARGS[$_] == @*ARGS.max})' 5 2 9 1 7 6

Here is my Perl 5 one-liner

perl -MList::Util='max' -E 'for (0 .. $#ARGV) {if ($ARGV[$_]==max(@ARGV)) {say;}}' 5 2 9 1 7 6
    

It would be more compact with a trailing if as in say if (...), but I think that's just a cosmetic improvement.  I'll let the uglier syntax above stand.

Julia has the convenient argmax function which returns the index of the maximum item.

Here is my Julia one-liner

julia -e 'println(argmax(ARGS)-1)' 5 2 9 1 7 6

My solutions differ slightly from the specification in that they return the indices of every occurrence of the biggest item, not just the first occurrence.

Challenge 2 (Common Path)

Given a list of Linux absolute file paths, we are asked to find the deepest common path.

In my last blog post, I said that I would do the next challenge in Perl 5 using lexical variables only, if possible. This is as a counterpoint to earlier challenges where I used Perl 4 syntax meaning only package variables.

Strictly using only lexical variables means all named subroutines must be lexical. Also arguments must be passed to subroutines using signatures, because @_ is not a lexical variable. I set 'use v5.36' to ensure that both signatures and lexical subs are available and non-experimental. (This probably violates the policy immediately, since I think it calls a non-lexical import function, but I'll ignore this. After all, I did stick a "use strict" on top of my "Perl-4-simulated" script last time, and "use strict" was definitely not available in Perl 4)

By the way,  my Challenge 1 one-liner violates a strict "only lexical variables" policy in at least two ways. ARGV is not lexical, and there is the call to the external package-variable subroutine List::Util::max.

By contrast to last week's challenge, where I used Perl 4 syntax, my Perl 5 script for this challenge is hyper-modern (in syntax, not in style). It is closer to Raku in its syntax than to Perl 4. 

But I do use the old-fashioned device of a flat hash that simulates an irregularly shaped multi-dimensional array. I find this easier than an array of arrays.

Also, I indulge a bad habit of over-using the same variable name for different things. This might dimly make sense with a symbol table, but not with lexical variables. Still, it seems harmless, and I enjoy the mantra-like effect that it creates in my code.

It was easy to port my hyper-modern Perl 5 solution to Raku, needing just minor edits. Raku forces me to correct the bad habit a bit as you may notice.

I did not do this challenge in Julia. It can be done of course, as Robert diCicco shows.

One can learn a lot from fellow-contributors. James Smith has a compact way to do this in Perl 5 using the bitwise xor operator on strings combined with a regex (his blog here). Certainly something useful to add to my toolkit. 

Why bother to try Perl 4 syntax?

Our good reviewer Colin Crain has expressed bemusement on why anyone would want to look back to Perl 4 given the huge game-changing advantages that 5.0 brought (CPAN for starters). Let me attempt a rationale for why I sometimes bring on Perl 4 syntax in a challenge.

Many of my fellow-contributors use the challenge to try out experimental new features in the latest version, or to demonstrate how something like a functional idiom can be used. That is certainly a very useful way to handle a challenge.

But just for contrast, it might be interesting to answer a different and somewhat orthogonal question: how well can one meet this challenge using just a minimal core subset of the syntax? (Of course, as long as this does not require re-writing Math::Prime::Util or Date::Manip!). Perl 4 syntax is a good candidate for that minimal core subset in Perl 5. It is smaller than microperl. It does have that pesky lack of lexical variables or references, but it's a good question as to whether these are needed in a minimal subset.

Like Colin, I certainly wouldn't want to turn back the clock to pre-5.0. But sometimes it is just fun and interesting to play with some retro toys.

Comments

Post a Comment

Popular posts from this blog

PWC 215

PWC 215 I have attempted the Perl Weekly Challenge after a hiatus of several weeks, as I was too busy at work. Still busy, so I have just attempted the current challenge in Perl 5. Like I like to do, I have restricted myself to perl 4 syntax as specified in the first edition of Programming perl. Update and disclaimer : These programs will not work on Perl 4 as I discovered later when I found and installed a Perl 4.019 executable. For one thing, the ability to assign a subroutine to a locally scoped typeglob was not available in Perl 4. Challenge 1 (Odd one out) In this challenge, we are given a list of alphabetic strings, and asked to return the list without the strings in which the characters are not sorted (I assume that this means sorted in lexical ascending order). We are also asked to print the number of strings that were removed (i.e., that were not sorted).  I use a subroutine &odd_one_out(@words) with a nested helper sub-sub-routine to check if a string is sorted. Here i
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 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