PWC 235

PWC 235

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

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.

My solutions to this week's challenges highlight the usefulness of the splice array operator.

Challenge 1 (Remove One)

We are given an array of integers and asked to verify if removing any one element will leave the remaining elements in monotonically ascending order.

A helper sub-subroutine &ascending checks if a particular array is in ascending order, by comparing it element-by-element to its sorted version. Here it is:

    local *ascending = sub {
        local @ascending=(sort {$a <=> $b} @_);
        foreach (0 .. $#_) {($_[$_]==$ascending[$_]) || (return 0)}
        return 1;
    };

Then the main part of the subroutine. This loops through the indices of the input array, using splice to delete the current element from a temporary copy of the input, and then checks if the result is in ascending order by calling &ascending. If it is, then we are through and return 1. If we have looped through the whole array without success, we return 0.

sub remove_one {
    #-- helper sub
    ...
    #-- trunk of sub
    foreach (0 .. $#_){
        local @remove_one = @_;
        splice(@remove_one,$_,1);
        &ascending(@remove_one) && (return 1);
    }
    return 0;
}

Challenge 2 (Duplicate Zeros)

We are given a list of integers of length n. We are asked to duplicate every instance of zero in the input list, and return the first n items in the resulting list.

Again, splice comes in handy. Here is my subroutine.

sub duplicate_zeros {
    local $duplicate_zeros = $#_;
    local @duplicate_zeros = ();
    foreach (0 .. $#_){($_[$_]==0) && (push @duplicate_zeros,$_) }

    foreach (0 .. $#duplicate_zeros) {
        ($_ > $duplicate_zeros) && (last);
        splice(@_,$duplicate_zeros[$_],0,0);
        foreach ($_ .. $#duplicate_zeros) {
            $duplicate_zeros[$_]++;
        }
    }
    @_[0 .. $duplicate_zeros];
}

We create a list @duplicate_zeros that stores the indices of all the zero-valued elements in the input array. Then we loop through @duplicate_zeros, at each step $_ using splice to insert an additional zero in the input array at the $_ position, and then incrementing all the remaining elements in @duplicate_zeros by 1 (to reflect the index for a zero moving to the right in the input array). Finally, we return the required sub-list. We had stored the length of the original input array at the start.

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

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 %_) &&...
Read more