DEV Community: Kian Meng, Ang

Perl Weekly Challenge - 038

Kian Meng, Ang — Wed, 25 Dec 2019 16:35:06 +0000

Original published in kianmeng.org and Perl Weekly Chanllenge.

Feel free to submit a merge request or open a ticket if you found any issues with this post. We highly appreciate and welcome your feedback.

For a quick overview, go through the original tasks and recap of the weekly challenge.

Additional feedback to the our Perl Weekly Challenge’s Twitter account is much appreciated.

Task #1

CPAN modules used: Carp, Date::Calc, Date::Manip, DateTime, POSIX, Test::Exception, Test::More, Time::Local, Time::Piece, Try::Tiny, boolean, feature, strict, utf8, warnings

Another week, another date related challenge.

For this task, we observed there were two approaches in validating the 7-digits date, either using a regex or non-regex at all. Almost everyone took the former approach but some participant have put in extra effort to ensure the readability of the code, especially the regex. Yes, you can write readable and maintainable code in Perl, regardless its notorious reputation of looking like line noise.

First, look at the submission by Adam Russell. It's a straightforward approach to validate the 7-digits date. But it didn't tell us much on what being extracted or matched from the regex without checking back the requirement.

sub is_valid{
    my($x) = @_;
    $x =~ m/([1-2]{1})([0-9]{2})(0[1-9]{1}|1[012]{1})(0[1-9]{1}|1[012]{1}|2[0-9]{1})/;
    return $x, $1, $2, $3, $4;
}

Now, compare to these code submissions.

By Javier Luque.

# Regex to test date format
return "Invalid date format"
    unless $date && $date =~ /
        ^                     # start string
        ([12])                # 1 or 2
        (\d\d)                # year 00-99
        (0[1-9]|1[0-2])       # month 1-12
        (0[1-9]|[12]\d|3[01]) # day 1-31
        $                     # end string
    /x;

By Dave Jacoby.

my ( $century, $year, $month, $day ) = $string =~ m{
    ^         # start of string
    (\d)      # century value 1-2
    (\d{2})   # year value 00-99
    (\d{2})   # month value 01-12
    (\d{2})   # day value 01-31, plus
    $         # end of string
}mx;

By Andrezgz.

die 'invalid 7-digits date'.$/
    if $n !~ /^
        (?<y1>[1,2])                    # 1st: 1 or 2
        (?<y2>\d{2})                    # 2nd & 3rd: anything
        (?<m>0[1-9]|1[0-2])             # 4th & 5th: month
        (?<d>0[1-9]|[12][0-9]|3[01])    # 6th & 7th: day of the month
    $/x;

By Ryan Thompson. Yes, we do agree, the regex is the real star.

# This regex is the real star of the show
$ARGV[0] =~ /^
    (?<cent> [12]                    ) # Century, 1:1900, 2:2000
    (?<yy>   \d\d                    ) # Year (2-digit)
    (?<mm>   0[1-9] | 1[012]         ) # Month
    (?<dd>   0[1-9] | [12]\d | 3[01] ) # Day
$/x or die "usage: $0 Cyymmdd";

How about non-regex solution, as usual, E. Choroba surprised us with his submission by not using any regex at all. Compare his solution to the above mentioned regex examples, which is more readable and understandable at a quick glance?

sub validate {
    my ($number) = @_;
    die 'Invalid length' unless length $number == 7;

    my $date = {  1 => 20, 2 => 19 }->{ substr $number, 0, 1 }
      or die 'Invalid year';

    $date .= substr $number, 1;
    my $tp = eval { 'Time::Piece'->strptime($date, '%Y%m%d') };
    die 'Invalid date' unless $tp && $tp->mon == substr $number, 3, 2;

    return $tp->ymd
}

So what have we learned here from these submissions. You can write good and readable regex with good comment, split regex into multiple lines with the help of \x modifier, named captured variables, and good code indentation. The submission by Ryan Thompson was a good example of this.

Task #2

CPAN modules used: Algorithm::Combinatorics, Data::Dumper, File::Slurp, File::Slurper, Getopt::Long, LWP::Simple, List::Util, Math::Combinatorics, Memoize, Readonly, autodie, constant, enum, feature, strict, utf8, warnings

While the question did not explain it explicitly, the task is like a Scrabble game.

Let's us compare how participants initialize the character value/point/score and frequency/count.

By Ruben Westerberg which have the shortest code.

my @l=split "", "AGISUXZEJLRVYFDPWBNTOHMCKQ";
my @c=(8,3,5,7,5,2,5,9,3,3,3,3,5,3,3,5,5,5,4,5,3,3,4,4,2,2);
my @v=((1)x7, (2)x6,(3)x4,(4)x2,(5)x5,(10)x2);

By Ryan Thompson. Notice the for loop used to initialize the tile.

# Point values for each tile, as given in the challenge description:
my %val;
$val{$_} =  1 for qw< A G I S U X Z >;
$val{$_} =  2 for qw< E J L R V Y   >;
$val{$_} =  3 for qw< F D P W       >;
$val{$_} =  4 for qw< B N           >;
$val{$_} =  5 for qw< T O H M C     >;
$val{$_} = 10 for qw< K Q           >;

# Tile counts in bag. Each letter is repeated the specified number of times
# We shuffle with List::Util's shuffle(), but see perlfaq4 for Fisher-Yates
my @bag = shuffle map { my ($l, $count) = split //; ($l) x $count }
    qw< A8 G3 I5 S7 U5 X2 Z5
        E9 J3 L3 R3 V3 Y5
        F3 D3 P5 W5
        B5 N4
        T5 O3 H3 M4 C4
        K2 Q2 >;

By Andrezgz. Similar to Ruben Westerberg but more readable.

# Points for each tile
my %tile_points = (
    A => 1, G => 1, I => 1, S => 1, U => 1, X => 1, Z => 1,
    E => 2, J => 2, L => 2, R => 2, V => 2, Y => 2,
    F => 3, D => 3, P => 3, W => 3,
    B => 4, N => 4,
    T => 5, O => 5, H => 5, M => 5, C => 5,
    K => 10, Q => 10
);

# Lot of available tiles
my @lot = (
    ('K','Q','X') x 2,
    ('D','F','G','H','J','L','O','R','V') x 3,
    ('C','M','N') x 4,
    ('B','I','P','T','U','W','Y','Z') x 5,
    ('S') x 7,
    ('A') x 8,
    ('E') x 9
);

By E. Choroba. A rather elegant way of initializing the score and count of character tiles.

my %tile = (
    A => [ 8,  1 ], G => [ 3,  1 ], I => [ 5, 1 ], S => [ 7, 1 ],
    U => [ 5,  1 ], X => [ 2,  1 ], Z => [ 5, 1 ], E => [ 9, 2 ],
    J => [ 3,  2 ], L => [ 3,  2 ], R => [ 3, 2 ], V => [ 3, 2 ],
    Y => [ 5,  2 ], F => [ 3,  3 ], D => [ 3, 3 ], P => [ 5, 3 ],
    W => [ 5,  3 ], B => [ 5,  4 ], N => [ 4, 4 ], T => [ 5, 5 ],
    O => [ 3,  5 ], H => [ 3,  5 ], M => [ 4, 5 ], C => [ 4, 5 ],
    K => [ 2, 10 ], Q => [ 2, 10 ]);

my @all = shuffle(map +($_) x $tile{$_}[NUMBER], keys %tile);

Perl Weekly Challenge - 037

Kian Meng, Ang — Tue, 17 Dec 2019 12:18:04 +0000

Originally published in kianmeng.org and Perl Weekly Challenge.

Continues from previous week.

Feel free to submit a merge request or open a ticket if you found any issues with this post. We highly appreciate and welcome your feedback.

For a quick overview, go through the original tasks and recap of the weekly challenge.

Additional feedback to the our Perl Weekly Challenge’s Twitter account is much appreciated.

Task #1

CPAN modules used: Data::Dumper, Date::Manip, DateTime, DateTime::Duration, DateTime::Event::Recurrence, Function::Parameters, List::Util, Modern::Perl, POSIX, Test::More, Time::Local, Time::Moment, Time::Piece, Time::Seconds, Time::localtime, constant, feature, strict, utf8, warnings

This is a similar task to the previous challenges. Thus, we observed some participants reuse the same code with some modifications.

For a start, look at the solution by Ryan Thompson and Colin Crain which were heavily commented. This should provides us with some context and their thought on solving this tasks. Similarly but in blog post, read the write-up by Laurent Rosenfeld, E. Choroba, and Arne Sommer. They provides us with even more insight on how they approached this task.

And as usual, a few things that caught our attention.

The Date::Manip::Recur CPAN module used by Colin Crain was rather interesting and unique compare to typical CPAN modules found in most submitted solutions. The CPAN module provides a way to parse and manipulate recurrence which was used by the participant to filter out all weekdays.

    my $recur = new Date::Manip::Recur;
    $recur->parse("0:0:0:1*0:0:0*IBD","Jan 1  2019","Jan 1  2019","Dec 31 2019");
    my @date = $recur->dates();

Now, if the above recurrence modifier string was rather obscure, look at the solution by Javier Luque which use the DateTime::Event::Recurrence CPAN module. As shown below, the code is pretty much self-explanatory.

    my $working_days =
        DateTime::Event::Recurrence->weekly(
            days => [1 .. 5]
        );

For a purist solution (without using any CPAN modules), Adam Russell was the only particpant who seemed to achieve that feat.

Task #2

CPAN modules used: Astro::Coord::ECI, Astro::Coord::ECI::Sun, Astro::Coord::ECI::Utils, Astro::Sunrise, Data::Dumper, DateTime, DateTime::Duration, DateTime::Event::Sunrise, File::Slurp, Function::Parameters, Getopt::Long, HTML::Parser, HTML::TableExtract, HTTP::Tiny, LWP::Simple, LWP::UserAgent, List::Util, Modern::Perl, Mojo::UserAgent, Pod::Usage, String::Util, Syntax::Construct, Time::Local, Time::Piece, Time::Seconds, URI, WWW::Mechanize, Web::Scraper, constant, feature, integer, strict, utf8, warnings

This task reminded us of the optional third task we used to have in previous challenges in using web services or APIs.

For this task, we can group the submitted solutions into three groups. Those who scrapped the daylight gain and loss data from the Interweb, those who scrapped and pre-cached, or those who calculate dynamically.

Participants who approached this task with the first approach were Mark Anderson, Javier Luque, Adam Russell, Ruben Westerberg, Saiftynet, and E. Choroba.

Participants who pre-cached the daylight data were Laurent Rosenfeld, Andrezgz, and Colin Crain.

Participants who opted to calculate daylight details dynamically were Dave Jacoby, Roger Bell West, Lubos Kolouch, Ryan Thompson, and Duncan C White.

Again, certain solutions that caught our attentions.

The forward-looking statement or safe habour statement found in the submission by Colin Crain was rather intriguing and justifiable due to the uncertainties in predicting the daylight result.

Ryan Thompson basically wrote a console app or rather a CPAN module to calculate the difference of daylight between two months.

The solution by Mark Anderson is a short and practical demonstration of how MapReduce works.

Perl Weekly Challenge - 036

Kian Meng, Ang — Tue, 10 Dec 2019 14:24:30 +0000

Originally published in kianmeng.org and Perl Weekly Challenge.

Continues from previous week.

Feel free to submit a merge request or open a ticket if you found any issues with this post. We highly appreciate and welcome your feedback.

For a quick overview, go through the original tasks and recap of the weekly challenge.

Additional feedback to the our Perl Weekly Challenge’s Twitter account is much appreciated.

Task #1

CPAN modules used: Data::Validate::VIN, Function::Parameters, List::MoreUtils, List::Util, Readonly, Syntax::Construct, Test::Exception, Test::More, boolean, feature, strict, warnings

Read the background details on the Vehicle Identification Number (VIN) first.

Next, look at the submissions by Duane Powell and Lubos Kolouch. Try solve any problems in Perl with available CPAN module. For this task, there exists Data::Validate::VIN CPAN module. For those who are curious, you can reading the source code of the CPAN module and compare with all the submissions here.

Following that, for submissions with good readability and easy to follow code, look no further into the solution by Laurent Rosenfeld, Jaldhar H Vyas, and Javier Luque. Observe their clean coding style.

For this task, we need to predefine a set of values. Compare these submissions by Adam Russell, Ruben Westerberg, and Duncan C White. See how they declare and initialize the hash table of the valid characters, weights, check digits, country codes, and manufacturers. We're not sure how Duncan obtained the list of data, but that was a large and long list.

Now, besides reading the blog on how each participant solved this task, you can read the detail comments written in the submission by Burkhard Nickels and Colin Crain. These participants have put in great length in documenting their thoughts on solving this task.

When come to writing own test cases, look at the submission by Saiftynet, Steven Wilson, and E. Choroba. Reading these test cases will give us an idea on how the subroutines supposed to be used.

While we went through these submissions, the solution by Andrezgz caught our attention as shown below. CORE:: prefix will enforce only the built-in function, in this case, state to be used.

  CORE::state $trans_key = {
      A=> 1, B=> 2, C=> 3, D=> 4, E=> 5, F=> 6, G=> 7, H=> 8,
      J=> 1, K=> 2, L=> 3, M=> 4, N=> 5,        P=> 7,        R=> 9,
             S=> 2, T=> 3, U=> 4, V=> 5, W=> 6, X=> 7, Y=> 8, Z=> 9,
  };

Task #2

CPAN modules used: Algorithm::Combinatorics, Algorithm::Knapsack, Box::Calc, Data::Dumper, Data::PowerSet, Function::Parameters, List::Util, Math::Combinatorics, Modern::Perl, Readonly, Test::Deep, Test::More, Tie::IxHash, constant, feature, strict, warnings

To understand the task at hand, read the background details of Knapsack Problem.

Start with the submission by Duncan C White (solved by hand), Adam Russell (simplest), and Colin Crain (detail step-by-step comment) to get an initial concept on how to solve it.

Next, using similar approach but coded in more verbose style, read the solutions by Ruben Westerberg, Saiftynet, Laurent Rosenfeld, Roger Bell West, and Andrezgz.

Lastly, look into submissions which used CPAN modules (listed above) by Burkhard Nickels, Mark Anderson, and Duane Powell. See how these CPAN modules helped in generating all possible combinations to the solutions.

Most unique approach came from E. Choroba which used an indicator function approach. Read his blog post for further details.

Perl Weekly Challenge 035

Kian Meng, Ang — Mon, 02 Dec 2019 12:34:06 +0000

Originally published in kianmeng.org and Perl Weekly Challenge.

Continues from previous week.

Feel free to submit a merge request or open a ticket if you found any issues with this post. We highly appreciate and welcome your feedback.

For a quick overview, go through the original tasks and recap of the weekly challenge.

Additional feedback to the our Perl Weekly Challenge’s Twitter account is much appreciated.

Task #1

CPAN modules used: Data::Dumper, Term::ANSIColor, Term::ANSIScreen, Term::Size::Perl, Test::More, Text::Morse, Text::Trim, Time::HiRes, autodie, constant, experimental, feature, lib, strict, utf8, warnings

If you need to have a quick overview on which submitted solutions to read or study, look at the submissions by Andrezgz and Javier Luque. Both solutions were rather easy to follow and read.

Going through all the submissions, we observed two approaches used by participants to encode text into binary encoded Morse code. The first was to generate the binary form from two signal durations (dots and dashes) dynamically. Participant who preferred this way were Petr Roubicek, Javier Luque, Ruben Westerberg, Laurent Rosenfeld, Ulrich Rieke, Roger Bell West, Ryan Thompson, Andrezgz, Colin Crain, and E. Choroba.

While the second was to use a pre-generate list of characters to binary lookup table. Participants who used such approach were Duane Powell, Adam Russell, Burkhard Nickels, Jaldhar H. Vyas, Steven Wilson, Giuseppe Terlizzi, and Giuseppe Terlizzi.

As usual, selected submissions that caught our attention worth the discussions.

Only Ruben Westerberg and E. Choroba used pack and unpack function to process binary data. The default Perl tutorial on this matter will shed some light on using these two functions.

As usual, Burkhard Nickels solved this week challenges using different CPAN modules to demonstrate Morse code in a visual manner. Read his very details write-up on how he tackle this challenge. While looking at his solution, we noticed that he used the CPAN module, Term::Size::Perl to determine the width of the terminal. In comparison,Laurent Rosenfeld formatted the output to a predefined 80 characters as shown in code below.

    sub format80c {
        shift =~ s/(.{80})/$1\n/gr;
    }

Ryan Thompson was the only participant that wrote a script that download, parse, and generate the Morse code into Perl script from Wikipedia page. While the script itself was far more complex that the actual solution, we can learn a few Perl tricks.

Colin Crain solution demonstrated that writing a proper program according to a specification or standard, in this case, M.1677 : International Morse code was a tedious effort.

Task #2

CPAN modules used: Data::Dumper, Test::More, autodie, constant, experimental, feature, lib, strict, utf8, warnings

Since this task was similar to Task 1 but done in reverse way (some reverse the lookup table), most of the participants reuse the same code when decoding Morse code. However, there were a selected few submissions we can read and learn from.

Again, start with the solution by Javier Luque. Submission with error handling and correction was easy to read and understand.

Andrezgz applied the Dispatch table (in past challenge) when decoding the Morse code.

    my %morse_bin_inv = (
        '1'        => \&add_dot   ,  # dot
        '111'      => \&add_dash  ,  # dash
        '0'        => sub { }     ,  # intra-character gap
        '000'      => \&add_char  ,  # character gap
        '0000000'  => \&add_word  ,  # word gap
    );

Colin Crain, besides solving it against a specification, used a State Machine to decode the Morse signal continuously. This was probably the only comprehensive solution to handle exception with erroneous Morse code signal.

Perl Weekly Challenge 034

Kian Meng, Ang — Mon, 25 Nov 2019 12:26:25 +0000

Originally published in kianmeng.org and Perl Weekly Challenge.

Continues from previous week.

Feel free to submit a merge request or open a ticket if you found any issues with this post. We highly appreciate and welcome your feedback.

For a quick overview, go through the original tasks and recap of the weekly challenge.

Additional feedback to the our Perl Weekly Challenge’s Twitter account is much appreciated.

Task #1

CPAN modules used: Data::Dumper, Getopt::Long, List::Util, Modern::Perl, PDL, PDL::Core, PDL::IO::Image, PDL::ImageRGB, PDL::NiceSlice, feature, strict, warnings

While this may seem like a simple task, it's a good example of showing how Perl handles slicing for an Array or Hash. From all the submissions, we can group the solution into two categories of showing how slicing works in Perl language itself or through a practical example.

For the first category, start with the solution by Mark Anderson, Javier Luque, Adam Russell, Laurent Rosenfeld, and E. Choroba. Next, look into the submission by Ruben Westerberg and Steven Wilson where both demonstrated array and hash slicing using different range of values and edge cases.

For the second category, look into different examples that illustrated the usage of slicing array and/or hash. These examples include image processing by Burkhard Nickels, binary search by Jaldhar H. Vyas, superheroes names by Andrezgz, prime numbers generator by Colin Crain, sovereign states by Petr Roubicek, card shuffling by Duane Powell, and user listing by Dave Cross.

And kudos given to Dave Cross for his solution that demonstrated both list and hash slicing in one line of code as shown below.

    # Lvalue is a hash slice
    # Rvalue is a list slice
    @user{qw[user id shell]} = (split /:/)[0, 2, -1];

Lastly, for good write-up on this topic, read the comment by Colin Crain and the details blog post by both E. Choroba and Laurent Rosenfeld.

Task #2

CPAN modules used: Data::Dumper, Getopt::Long, PDL, PDL::Core, PDL::IO::Image, PDL::ImageRGB, PDL::NiceSlice, feature, strict, warnings

In the past challenges, we've discussed about Dispatch table, which is just a table with pointers to function or method. Implementation in Perl is rather easy, just a hash to function pointers.

For a quick understanding on how it being used in Perl, start with the submission by Adam Russell, Ruben Westerberg, Steven Wilson and E. Choroba.

For more complex practical examples of Dispatch table implementation, look into the solution by Dave Cross (console calculator), Javier Luque (calculator), Duane Powell (card shuffling), Burkhard Nickels (console command), Laurent Rosenfeld (dictionary), Jaldhar H. Vyas (Rock paper scissors game), Roger Bell West (expression evaluator), Andrezgz (superheroes name), and Colin Crain (another console calculator, yes this was a popular choice among participants).

Perl Weekly Challenge 033

Kian Meng, Ang — Tue, 19 Nov 2019 16:59:22 +0000

Originally published in kianmeng.org and Perl Weekly Challenge.

Continues from previous week.

Feel free to submit a merge request or open a ticket if you found any issues with this post. We highly appreciate and welcome your feedback.

For a quick overview, go through the original tasks and recap of the weekly challenge.

Additional feedback to the our Perl Weekly Challenge's Twitter account is much appreciated.

Task #1

CPAN modules used: Const::Fast, Data::Dumper, English, Getopt::Long, IO::All, List::Util, Modern::Perl, Mojo::File, feature, strict, utf8, warnings

This was similar to last week challenge but at different granularity, counting character instead of word. Hence, those participants who've submitted their solutions last week will only need to tweak their answer a bit. Is there anything we can learn or observe for this week challenge? Yes, and quite a few things. This week we will compare similar approach between two or more participants which either share similar approach in solving the task or totally using the opposite way.

Fabrizio Poggi and Dave Cross showed us the opposite way of solving the problem through either hard-coded or dynamic way. A simple example of not using a loop against a loop. The submission by Fabrizio can be further refactored using the range of alphabet characters a..z as found in solution by Duane Powell.

Duncan C. White and E. Choroba have similar approach which use double while loop to split and count the frequency of character. The different was the coding style.

Andrezgz, Colin Crain, and Bwva took the same approach of finding all characters in a line from a file, splitting it into an array of characters, and lowercase it before counting the frequency. Again, subtle differences in the personal coding style between them.

Adam Russell and Ndelucca also have a similar approach but the latter did it in a more dense and shorter version using map function.

Steven Wilson and Burkhard Nickels. Between a solution that was written in an explicit manner against a implicit Perl one-liner. For maintainable code, the former is a better approach. Laurent Rosenfeld also have a few one-liner examples.

Mark Anderson and Burkhard Nickels on using different CPAN modules to read the input file. Mojo::File and IO::All, which is the better choice or we just stick to <> then?

Some rather unique approach we noticed. The use of getc by Javier Luque to read the next character of a file handler. And the use of \P{Alpha} by Joelle Maslak and \p{XPosixLower} that matches the full range of Unicode or non-English characters that are considered as alphabetic.

Task #2

CPAN modules used: Const::Fast, Data::Dumper, Getopt::Long, Modern::Perl, PDL, PDL::NiceSlice, Perl6::Form, feature, open, strict, utf8, warnings

We've something similar and quite humourous in the past challenges, just show the result as it. And this week, that solution came from Lubos Kolouch. We can understand the difficulty of calculating, formatting, and displaying the multiplication table for this task.

For code readability (subjective view) and density, we found the solution by Duncan C. White and E. Choroba were easier to follow compare to others.

Instead of printf function to format the layout of the table, Adam Russell opted for alternative solution using the Perl6::Form CPAN module.

Look into the submission by Burkhard Nickels where he tried different approaches to generate the table. We love the use of PDL and PDL::NiceSlice CPAN module as well as his write-up on comparing different alternative ways in generating the multiplication table.

Perl Weekly Challenge 032

Kian Meng, Ang — Sun, 10 Nov 2019 15:03:03 +0000

Originally published in kianmeng.org and Perl Weekly Challenge.

Continues from previous week.

Feel free to submit a merge request or open a ticket if you found any issues with this post. We highly appreciate and welcome your feedback.

For a quick overview, go through the original tasks and recap of the weekly challenge.

Additional feedback to the our Perl Weekly Challenge's Twitter account is much appreciated.

Task #1

CPAN modules used: Const::Fast, Data::Dumper, English, Getopt::Long, Getopt::Std, List::Util, Modern::Perl, Term::Size::Perl, Text::CSV_XS, feature, open, strict, warnings

A rather common (there is even a FAQ, link via E. Chroba) task to demonstrate Perl's text manipulation capabilities. Common approach used by most participants can be break down into several steps consists of read each line from standard input, clean up each line, count the frequency of the word, sort the frequency count, and lastly show the result in both normal and CSV output. The solution by Adam Russell and Dave Cross demonstrated this succinctly with no dependencies on CPAN modules or special features. And yes, start reading these solutions first before you proceed with other.

Beside that, there were other solutions in one-liner that can quickly show the approach to solve this task as shown below.

In Bash by E. Choroba. Yes, using Unix pipe which demonstrated core concepts of Unix philosophy of writing one program to do one thing very well and make sure all can work together through text streams.

    $ cat "$@" | sort | uniq -c | sort -n

In Perl by Burkhard Nickels.

    $ perl -lne '$sum{$_}++; END { foreach( sort { $sum{$b} <=> $sum{$a} } keys %sum ) { print "$i\t$sum{$i}"; } }' example.txt

Unfortunately, we don't live in the perfect world. There is always this issue of garbage in, garbage out (GIGO) during text processing. Hence, we noticed different defensive measurements to handle possible edge cases were used by participants. And it showed that, to a certain extend, to handle numerous edges cases, Bash script may not be a convenient or suitable choice compare to Perl script.

For examples, Anton Fedotov (UTF-8 support in both input and output), Duane Powell (non-alphabet characters removal and multiple words within a line support), Dave Jacoby (accept source from file or Standard Input (stdin)), Laurent Rosenfeld (skip empty line), Prajith P (another way to skip empty line without regex and multiple source files support), E. Choroba (alternative UTF-8 support), and Athanasius (check input for different OS).

If you're new to Perl or favour to be more explicit, look into the solution by Jaldhar H. Vyas which used English CPAN module which avoid the use of ugly punctuation variables. Ovid wrote a blog post on this subject as well. For comparison, we can see the differences of those submissions which used punctuation variables like $! or $ERRNO (Anton Fedotov), $~ or $FORMAT_NAME (Fabrizio Poggi), <> or ARGV (Rage311, Roger Bell West, Andrezgz, E. Choroba, Ryan Thompson, Duncan C White), $| or $OUTPUT_AUTOFLUSH (Athanasius), and $^O or $OSNAME (Athanasius).

Another good comparison of explicit vs. implicit coding style was on reading a file by line and count the word frequency.

By Dave Cross which was quite common style among all participants.

    my %count;

    while (<>) {
        chomp;
        $count{$_}++;
    }

By Andrezgz which was short and dense code.

    my %entries;
    chomp, $entries{$_}++ while (<>); # count instances

By Steven Wilson which was more explicit.

    for my $file (@ARGV) {
        open my $fh, '<', $file or die "Can't open < $file: $!";
        while ( !eof $fh ) {
            my $word = readline $fh;
            chomp $word;
            $word_count{$word} += 1;
        }
    }

For submission with heavy used of CPAN modules but still short and simple, the solution by E. Choroba was a good example to show case this.

Lastly, once you've familiarized yourself with all the submitted solutions of this task, read the answer by Burkhard Nickels. Burkhard have submitted a comprehensive solution with numerous features for this task.

Task #2

CPAN modules used: Const::Fast, Data::Dumper, Function::Parameters, Getopt::Long, Getopt::Std, JSON::PP, List::Util, Math::Round, Modern::Perl, Moo, Term::ReadKey, Term::Size::Perl, Types::Standard, autodie, constant, experimental, feature, namespace::clean, strict, utf8, warnings

Another rather straightforward task where we need to sort the list of item by name or values and generate a histogram graph at the console. Due to similarity of this task with previous task, some participants decided to reuse and extend the existing code in task 1.

For implementing different sorting strategies, we've observed different approaches.

Duane Powell used a simple if-else to sort the output.

    # sort and print lines
    if ($by_label) {
        # sort by key
        generate_bar($_[0],$_,$format) foreach (sort {lc($a) cmp lc($b)}           (keys %{$_[0]}));
    } else {
        # sort by value
        generate_bar($_[0],$_,$format) foreach (sort {$_[0]->{$a} <=> $_[0]->{$b}} (keys %{$_[0]}));
    }

Lars Balker, Javier Luque, and Giuseppe Terlizzi used similar approach but with anonymous sorting subroutine.

For Lars Balker where the if-else have been replaced with ternary operations and anonymous subroutines.

    my $sort = $order_by_label
        ? sub { $a cmp $b }
        : sub { $data->{$b} <=> $data->{$a} || $a cmp $b };
    for my $word (sort $sort keys %$data) {
        my $pct = $data->{$word} / $sum;
        printf "%*s | %s\n", $maxlength, $word,
            "#" x int($hashes * $pct);
    }

For Javier Luque with flexibility to add more sorting fields.

    # Sorting function - just 2 for now
    $sort_func = sub { $data->{$::b} <=> $data->{$::a} }
        if ($params->{order_by} eq 'size');
    $sort_func = sub { fc($::a) cmp fc($::b) }
        if ($params->{order_by} eq 'name');

    # Print the chart
    for my $key (sort $sort_func keys %$data) {
    printf("%10s | %s \n",
        $key, '#' x int(scalar($data->{$key}) * 4));
    }

The more advance and Object-Oriented approach was seen in E. Choroba. Instead of if-else statement, a hash was used as a lookup table to delegate to different sorting strategy subroutines.

    method generate (SortBy $sort_by = 'keys') {
        my $data = $self->data;
        my $max = max(values %$data);

        my $sort = {labels    => \&_by_key,
                  values      => \&_by_value,
                  labels_desc => \&_by_key_desc,
                  values_desc => \&_by_value_desc}->{$sort_by};

        for my $key (sort { $self->$sort } keys %$data) {
          printf '%' . $self->_max_length . "s%s%s\n",
              $key,
              $self->separator,
              '#' x ($self->_bar_width / $max * $data->{$key});
        }
    }

Another thing we've noticed where participants have put extra effort in scaling the histogram due to different range of values (Ndelucca, Lars Balker, Adam Russell, Athanasius, Laurent Rosenfeld, Prajith P, Lars Thegler, Ulrich Rieke, Jaldhar H Vyas, Roger Bell West, Ryan Thompson, Duncan C White, Andrezgz, Giuseppe Terlizzi, Colin Crain, and Joelle Maslak), floating numbers (Ulrich Rieke, Colin Crain, and Joelle Maslak), and terminal width (Burkhard Nickels, Roger Bell West, Ryan Thompson, and Joelle Maslak).

DEV Community: Kian Meng, Ang

Perl Weekly Challenge - 038

Task #1

Task #2

See Also

Perl Weekly Challenge - 037

Task #1

Task #2

See Also

Perl Weekly Challenge - 036

Task #1

Task #2

See Also

Perl Weekly Challenge 035

Task #1

Task #2

See Also

Perl Weekly Challenge 034

Task #1

Task #2

See Also

Perl Weekly Challenge 033

Task #1

Task #2

See Also

Perl Weekly Challenge 032

Task #1

Task #2

See Also