PWC 184

PWC 184

Both the tasks for this week have narrowly defined input requirements. I don't write a function to handle them. I want to avoid input validation and error handling chores, and any self-respecting function needs both. I present throwaway scripts or one-liners with the inputs explicitly written into the script or ARGV. 

Challenge 1 (Sequence number)

We are given a list of strings, each one formatted as two lower-case alphabets (/[a-z]/) followed by 4  numeric characters (/[0-9/), e.g.,  ('ab1234', 'cd5678', 'ef1342'). We are asked to replace the starting alphabets with a two-digit string of numbers indicating their position in the list starting with zero, e.g., ('001234', '015678', '021342').

I do this with one-liners in Perl 5, Raku and Julia.

Perl 5:

perl -e 'my $ctr=0; for my $x ("00" .. "99") {print $x . substr($ARGV[$ctr++],2,4) . " "; last if $ctr >= @ARGV;} print "\n";' 'ab1234' 'cd5678' 'ef1342'

In Perl 5 (or Raku), we can loop through the strings "00" .. "99". It's then just a matter of prepending each string to the last 4 digits of each list entry, retrieved via substr.

I used a separate counter $ctr from the loop counter $x to move through the ARGV list.

Raku:

raku -e 'my $ctr=0; for ("00" .. "99") -> $x {print $x ~ @*ARGS[$ctr++].substr(2,4) ~ " "; last if $ctr >= @*ARGS }; print "\n";' 'ab1234' 'cd5678' 'ef1342'

This is a literal translation of my Perl 5 one-liner.

Julia:

julia -e 'using Printf; ctr=0; for mystring in ARGS; global ctr; @printf "%02i" ctr; print(SubString(mystring,3,6));print(" ");ctr+=1;end;println("")' 'ab1234' 'cd5678' 'ef1342'

In Julia, we use the Printf standard library,  and in particular the @printf macro.

@printf "%02i" ctr

prints ctr formatted as a zero-padded integer with width 2. Apart from this, our logic is like Perl 5 using Julia's built-in SubString function as a substitute for substr.

My Perl 5 one-liner runs in 0.01 seconds, my Raku one-liner in 0.35 seconds, and Julia is a bit slower at 0.40 seconds (it starts up slowly).

Other contributors (wow!)

As usual, looking at other contributors' solutions is humbling.  Several contributors have exploited the fact that the "++" operator can be used to step through the range "00" .. "99", in Perl 5 as well as Raku. As an example, here is Kjetil Skotheim with the lovely (Perl 5):

my $seq='00'; say s/../$seq++/er for @ARGV;

Here it is as a Raku one-liner.

raku -e 'my $seq="00"; @*ARGS.map({S/../{$seq++}/}).say' 'ab1234' 'cd5678' 'ef1342'

Challenge 2

We are given lists of strings, where each string is a stringified list of single space-separated characters that match /[a-z]/ or /[0-9]/. For each string, we are supposed to separate the numeric characters into one array and the alpha characters into another. Then we push the array of numeric characters into a bigger array containing arrays of numerics derived from other strings in the list, and ditto for the alpha array.

To give an example (the test example), given an input of ('a 1 2 b 0', '3 c 4 d'), we should return the pair of arrays of arrays: (['a','b'],['c','d']) and ([1,2],[3,4]).

In Perl 5, I loop through the list of strings, and then for each string loop through the characters, tossing them into the designated array for numbers or for alpha characters as appropriate. We use a regex to identify numeric vs alpha. 

I then toss the numeric and alpha arrays (if non-empty) into the bigger arrays that I prepared earlier to collect them.  Finally, I loop through these bigger arrays to print them out.

Raku is a literal translation. There is no need to write a loop to print out the array of arrays. Say does that directly.

In Julia I use the same logic . Instead of using a regex to identify alpha vs numeric characters, I use the membership operator in.  

if char in '0':'9'

Printing is also direct, like Raku.

Here is my Julia script.

Here is my Raku script.

Here is my Perl 5 script.

Julia runs in around 0.9 seconds, Raku in around 0.5 seconds, and Perl 5 in around 0.01 seconds. Julia is slower partly because of slow startup. My design is also inefficient because of the global variables I set up outside the loop (the input list, and the two arrays of arrays set up outside the loop). Recommended best practice is to avoid global variables.

"Global" does not mean quite the same thing in Julia as it does in Perl 5. A Julia global variable is more like a Perl-5 "my" variable declared outside any block or subroutine (file-scope lexical). Here is the Julia doc on variable scope.

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