This week's task turned out to be one of those that are easy to state and more challenging to do efficiently. Let's look at it.

Task 1: Max Diff

You are given an array of integers having four
or more elements. Write a script to find two
pairs of numbers from this list (four numbers
total) so that the difference between their
products is as large as possible. In the end,
return the max difference. With Two pairs
(a, b) and (c, d), the product difference is
(a * b) - (c * d).

• Example 1:

  • Input: @ints = (5, 9, 3, 4, 6)
  • Output: 42
    • Pair 1: (9, 6) Pair 2: (3, 4)
    • Product Diff: (9 * 6) - (3 * 4) => 54 - 12 => 42

• Example 2:

  • Input: @ints = (1, -2, 3, -4)
  • Output: 10
    • Pair 1: (1, -2) Pair 2: (3, -4)

• Example 3:

  • Input: @ints = (-3, -1, -2, -4)
  • Output: 10
    • Pair 1: (-1, -2) Pair 2: (-3, -4)

• Example 4:

  • Input: @ints = (10, 2, 0, 5, 1)
  • Output: 50
    • Pair 1: (10, 5) Pair 2: (0, 1)

• Example 5:

  • Input: @ints = (7, 8, 9, 10, 10)
  • Output: 44
    • Pair 1: (10, 10) Pair 2: (7, 8)

Thought processes

Using the canard that developer time is more valuable than computer time, we might go after this through brute force. We'll need to examine every combination of four elements from the array. I can foresee that that could have horrible performance implications -- it's O(n⁴) if we do it with nested loops. But let's try it anyway.

sub maxDiff_BF(@int)
{
    my $max = 0;
    for my $w ( 0 .. $#int ) {
        for my $x ( 0 .. $#int ) {
            next if $x == $w;
            for my $y ( 0 .. $#int ) {
                next if $y == $x || $y == $w;
                for my $z ( 0  .. $#int ) {
                    next if $z == $y || $z == $x || $z == $w;

                    my ($a, $b, $c, $d) = @int[$w,$x,$y,$z];

                    my $diff = max( $a*$b - $c*$d, $c*$d - $a*$b );
                    $max = $diff if $diff > $max;
                }
            }
        }
    }
    return $max;
}

Notes:

• next if $x == $w -- At the start of each loop, we can't reuse elements.
• my ($a, $b, $c, $d) = @int[$w,$x,$y,$z] -- Use an array slice to access four elements at a time and translate the variables to the language of the problem.

More thought process

As expected, the performance is awful. It doesn't show on the simple examples, but give this a list of 75 numbers and my laptop has to chug along for 12 to 15 seconds to get an answer. With AI data centers devouring the world's electric capacity, I don't want to be a contributor to the coming collapse of the grid.

One thing I notice quickly is that I want a maximal product magnitude, which I'm going to get by multiplying the two largest elements of the array. If that product is negative, I'll make it the (c,d) pair, so it gets added to the difference.

How can I quickly get the largest elements? Well, if the array were sorted, then the biggest magnitudes would be at the ends of the arrays (left end for negative numbers, right end for positives). Then the biggest product would be achieved by multiplying either the two most negative numbers, the two most positive numbers, or the biggest negative times the biggest positive.

After I have the biggest possible contribution, then I'll want to throw out the pair of numbers that we used, and examine the rest for the other product. We'll get back to that in moment, but let's do the first part.

sub maxDiff(@int)
{
    @int = sort { $a <=> $b } @int;

    my $nn = $int[ 0] * $int[ 1];
    my $pp = $int[-1] * $int[-2];
    my $np = $int[ 0] * $int[-1];
    my $largest;
    if ( abs($nn) > abs($pp) ) {
        if ( abs($nn) > abs($np) ) {
            $largest = $nn;
            shift @int; shift @int;
        } else {
            $largest = $np;
            shift @int; pop @int;
        }
    }
    else { # pp >= nn
        if ( abs($pp) > abs($np) ) {
            $largest = $pp;
            pop @int; pop @int;
        } else {
            $largest = $np;
            shift @int; pop @int;
        }
    }

That's an annoying number of lines of code, but hopefully clear. After we determine which of the three possibilities applies, we delete the elements from the left (shift) or right (pop) to work on the rest. Sorting probably costs us O(n log n), but that's way better than O(n⁴).

Now we have two possibilities. If $largest is negative, then we want to make it the (c,d) pair, so that subtracting it adds a big number to the difference. And we also want the (a,b) pair to be as big as possible so that (ab-cd) is as large as possible. The biggest product is once again found by multiplying the biggest numbers on the ends of the array (which now excludes the two numbers we already used).

    if ( $largest < 0 )
    {
        my $aXb = max( $int[0]*$int[1], $int[0]*$int[-1], $int[-2]*$int[-1] );
        return $aXb - $largest;
    }

What about the case that $largest is positive? In that case we'll want to subtract away the smallest possible positive product.

One way to find it is to examine every pair. Straightforward, but once again we're looking at a less desirable complexity of O(n²). It's easy enough to write, though.

        my $cXd = $int[0] * $int[1];
        while ( defined(my $c = shift @int) )
        {
            for my $d ( @int )
            {
                my $prod = $c * $d;
                $cXd = $prod if ( $prod >= 0 && $prod < $cXd );
            }
        }

But what if we could play the same trick we did the first time? Could we sort the list to put the small numbers at the ends of the array? Yes, we could. We can sort by the inverse of the numbers.

   @int = sort { ($a == 0 ? 2 : 1/$a) <=> ($b == 0 ? 2 : 1/$b) } @int;

A larger denominator moves closer to 0, and a bigger one moves closer to 1. There is an anomaly for 0, which would cause a divide-by-zero error. To solve that, map 0 to the extreme end of the array so that it always ends up on the right end. We're exploiting the specification that says the list contains integers; if there were fractional numbers in the input, we'd have an annoying complication to explicitly account for zero to put it on the end of the array.

# Sort (-4, -3, -2, -1, 0, 1, 2, 3, 4): 
# -1/1  -1/2  -1/3  -1/4  1/4  1/3  1/2  1/1 2(0)
# --|-----|-----|-----|----|----|----|----|---|
# --> (-1, -2, -3, -4, 4, 3, 2, 1, 0)

For the price of another sort, we can now find the smallest product in constant time:

my $cXd = min( $int[0]*$int[1], $int[0]*$int[-1], $int[-2]*$int[-1] );

and the maximum difference in this case is just $largest - $cXd.

Final thoughts

One alternative we didn't consider is that there are ways to cheaply generate the combinations of n things taken k at a time. The Algorithm::Combinatorics module has one such function. Still, to consider all the combinations, that becomes a lot very quickly (75 things taken 4 at a time has 75!/(71!)(4!) = 7,292,700 combinations).

By rearranging the data to put extreme values on the ends of the array, we can access those values in constant time. Perl makes it easy to access either end of the array, using negative indexes. The cost is sorting the array twice, with each sort having a most likely complexity of O(n log n). Two of those is still (on average) much more efficient than a stack of nested loops.

All the code fragments above combined into a coherent function:

sub maxDiff(@int)
{
    @int = sort { $a <=> $b } @int;

    # Possibilities for maximum product: biggest positive numbers, biggest
    # negative numbers, or biggest positive X biggest negative.
    # Find the biggest magnitude, then discard that pair from the list.
    my $nn = $int[0] * $int[1];
    my $pp = $int[-1] * $int[-2];
    my $np = $int[0] * $int[-1];
    my $largest;
    if ( abs($nn) > abs($pp) )
    {
        if ( abs($nn) > abs($np) )
        {
            $largest = $nn;
            shift @int; shift @int;
        }
        else
        {
            $largest = $np;
            shift @int; pop @int;
        }
    }
    else # pp >= nn
    {
        if ( abs($pp) > abs($np) )
        {
            $largest = $pp;
            pop @int; pop @int;
        }
        else
        {
            $largest = $np;
            shift @int; pop @int;
        }
    }

    if ( $largest < 0 )
    {
        # Make it the second pair (because negating it will add a big number),
        # and find the largest product for the first pair. Again, because the
        # list is sorted, the largest magnitude must come from the pairs on
        # the ends of the list.
        my $aXb = max( $int[0]*$int[1], $int[0]*$int[-1], $int[-2]*$int[-1] );
        return $aXb - $largest;
    }

    # Use largest as the first pair for maximum positive contribution.
    # Find the smallest product pair to subtract away.

=begin  BlockComment  # BlockCommentNo_1
    my $cXd = $int[0] * $int[1];
    while ( defined(my $c = shift @int) )
    {
        for my $d ( @int )
        {
            $cXd = $c*$d if ( $c*$d < $cXd );
        }
    }

=end    BlockComment  # BlockCommentNo_1

=cut
    # Sort so smallest integers are on the outside of the array.
    # Zero has to be on the edge (all numbers are integers, so
    # mapping 0 to 2 will accomplish that).
    @int = sort { ($a == 0 ? 2 : 1/$a) <=> ($b == 0 ? 2 : 1/$b) } @int;

    my $cXd = min( $int[0]*$int[1], $int[0]*$int[-1], $int[-2]*$int[-1] );
    return $largest - $cXd;
}

Hi, I'm kobaken.

I've released an adapter for using Inertia.js with Mojolicious, a Perl backend framework. Inertia.js is a bridging library that connects backend frameworks with components written in React, Vue, and other frameworks.

https://metacpan.org/pod/Mojolicious::Plugin::Inertia

What is Inertia.js?

Inertia.js is a framework that connects backend frameworks with React or Vue components. It allows you to use modern frontend components while maintaining a traditional backend approach.

I figure this is an approach that fits well when you have substantial assets on the backend side, but replacing everything would be too costly, and you want to start by improving the client-side experience.

When using components written in React, Vue, etc. with backend frameworks like Mojolicious, I believe there are two approaches. One is to mix JavaScript code into the backend framework's proprietary template engine. The other is to call backend APIs and handle rendering with CSR or SSR. Both approaches result in more complex architecture compared to the days when you could simply select a template on the backend and pass values to it.

With Inertia.js, you can use React and other components while maintaining the good old way of writing code. Specifically, it works as follows: by writing $c->inertia(COMPONENT, PROPS) on the backend side, Inertia.js will connect with the component.

Inertia.js is the simple protocol

Another point I found appealing is that the protocol for this connection is simple. It's remarkably simple.

For example, if you write it like this...

$c->inertia('Index', {
   user => { name => 'Mojolicious' }
})

It returns this JSON:

{
   "component": "Index",
   "props": { "user": { "name": "Mojolicious" } },
   "url": "/",
   "version": "c53bc3824540ea95b1e9b495c7a01a9d"
}

So straightforward!

In fact, looking at Inertia.js's protocol, it's content you can finish reading in about 10 minutes, and Mojo's plugin is less than 100 lines, so I think it would be easy to port to other Perl frameworks.

Recently, in another project, I made React Server Components usable with Hono, but understanding that in 10 minutes is difficult for me 😅 Since Inertia.js becomes CSR, I think React Server Components is better if you're looking for user experience and SEO, but I believe there are situations where Inertia.js is sufficient.

https://zenn.dev/kfly8/articles/hono-meets-vite-rsc (Japanese)

Please give it a try if you'd like!

Weekly Challenge 338

Each week Mohammad S. Anwar sends out The Weekly Challenge, a chance for all of us to come up with solutions to two weekly tasks. My solutions are written in Python first, and then converted to Perl. It's a great way for us all to practice some coding.

Challenge, My solutions

Task 1: Highest Row

Task

You are given a m x n matrix.

Write a script to find the highest row sum in the given matrix.

My solution

For input from the command line, I take a JSON-formatted string and turn it into a list of list of integers (arrays in Perl).

This is a one liner in Python, using the sum function to calculate the sum of each row, and the max function to return the highest (maximum) sum.

def highest_row(matrix: list[list[int]]) -> int:
    return max(sum(row) for row in matrix)

While Perl does not have a built-in max and sum function, they are provided by the List::Util module. Therefore the solution is similar.

use List::Util qw(max sum);

sub main ($matrix) {
    my $max = max( map { sum @$_ } @$matrix );
    say $max;
}

Examples

$ ./ch-1.py "[[4, 4, 4, 4], [10, 0, 0, 0], [2, 2, 2, 9]]"
16

$ ./ch-1.py "[[1, 5], [7, 3], [3, 5]]"
10

$ ./ch-1.py "[[1, 2, 3], [3, 2, 1]]"
6

$ ./ch-1.py "[[2, 8, 7], [7, 1, 3], [1, 9, 5]]"
17

$ ./ch-1.py "[[10, 20, 30], [5, 5, 5], [0, 100, 0], [25, 25, 25]]"
100

Task 2: Max Distance

Task

You are given two integer arrays, @arr1 and @arr2.

Write a script to find the maximum difference between any pair of values from both arrays.

My solution

For input from the command line, I take two strings and separate them on non-digit characters to turn them into two lists (arrays in Perl).

There are at least two possible ways to solve this, each with pros and cons.

I could extract the minimum and maximum values of each array, and compare the minimum of one list with the maximum of the other. The advantage of this is we only scan each list once, and do three additional calculations. The con is that it is significantly more code than the other solution.

The solution that I did write is a one liner in Python, by using double list comprehension and the abs and max function.

def max_distance(arr1: list[int], arr2: list[int]) -> int:
    return max(abs(a - b) for a in arr1 for b in arr2)

Perl does not have list comprehension (it does have map, but double mapping is asking for a world of pain). Therefore I use two foreach loops to get the same result.

sub main (@arrays) {
    my @arr1 = split /\D+/, $arrays[0];
    my @arr2 = split /\D+/, $arrays[1];

    my $max = 0;
    for my $a1 (@arr1) {
        for my $a2 (@arr2) {
            my $dist = abs( $a1 - $a2 );
            $max = $dist if $dist > $max;
        }
    }
    say $max;
}

Examples

$ ./ch-2.py "4 5 7" "9 1 3 4"
6

$ ./ch-2.py "2 3 5 4" "3 2 5 5 8 7"
6

$ ./ch-2.py "2 1 11 3" "2 5 10 2"
9

$ ./ch-2.py "1 2 3" "3 2 1"
2

$ ./ch-2.py "1 0 2 3" "5 0"
5

As I'm writing this, I'm watching a crew install a fence and once again thanking my high school guidance counselor, Mr. Bencini, for yelling at me to get my ass in gear and quit procrastinating on those college applications if you don't want to spend your life digging post holes and living in a van down by the river.

This week's challenges must have come from Cybertruck drivers in Texas, because they are overcompensating for something with an obsession about being the biggest.

Our musical accompaniment: Take it to the Limit by the Eagles, 1975 (coincidentally about the time that Mr. Bencini was yelling at me).

Task 1: Highest Row

You are given a m x n matrix. Write a script to 
find the highest row sum in the given matrix.
Example: Input: @matrix = ([4,  4, 4, 4],
                           [10, 0, 0, 0],
                           [2,  2, 2, 9])
Output: 16
    Row 1: 4  + 4 + 4 + 4 => 16
    Row 2: 10 + 0 + 0 + 0 => 10
    Row 3: 2  + 2 + 2 + 9 => 15

If every row can be reduced to its sum, then it's a one-liner. We'll lean on list utilities.

use List::Util qw/sum0 max/;
sub highestRow(@matrix)
{
    return max map { sum0 $_->@* } @matrix
}

Notes:

• map {...} @matrix -- Each element in @matrix is a reference to an array. Do something to every row.
• sum0 $_->@* -- De-reference a row ($_) to get its list of numbers. Use sum0 instead of sum to handle the possibility of an empty matrix.

Task 2: Max Distance

# You are given two integer arrays, @arr1 and @arr2.  Write a script to
# find the maximum difference between any pair of values from both arrays.
# Example 1 Input: @arr1 = (4, 5, 7)
#                  @arr2 = (9, 1, 3, 4)
#           Output: 6
#   With element $arr1[0] = 4   | 4 - 9 | = 5
#                               | 4 - 1 | = 3
#                               | 4 - 3 | = 1
#                               | 4 - 4 | = 0
#           max distance = 5
#   With element $arr1[1] = 5   | 5 - 9 | = 4
#                               | 5 - 1 | = 4
#                               | 5 - 3 | = 2
#                               | 5 - 4 | = 1
#           max distance = 4
#   With element $arr1[2] = 7   | 7 - 9 | = 2
#                               | 7 - 1 | = 6
#                               | 7 - 3 | = 4
#                               | 7 - 4 | = 4
#           max distance = 6
#   max (5, 4, 6) = 6

This example is trying to scare us by implying that we have to do some atrocious examination of every possible pair, an O(n²) algorithm. But let's cut through the fog: if we reduce each array to a range from its minimum to its maximum, it can be visualized like sliding @arr2 past @arr1, with five different possibilities for how they overlap.

                min1                   max1
                +-------------------------+
 +--------+  +--------+  +--------+  +--------+  +--------+
 min2  max2  min2  max2  min2  max2  min2  max2  min2  max2

The maximum distance will be from the extreme of one line to the extreme of the other. At the left side of the figure, that's the distance from min2 to max1; at the right side, it's from min1 to max2.

sub maxDist($arr1, $arr2)
{
    use List::MoreUtils qw/minmax/;
    use List::Util qw/max/;

    my ($min1, $max1) = minmax($arr1->@*);
    my ($min2, $max2) = minmax($arr2->@*);

    return max( $max1-$min2, $max2-$min1 );
}

Notes:

• List::MoreUtils::minmax -- this convenient function finds the minimum and maximum in an array with only one pass, exploiting Perl's ability to return more than one thing at a time.

Well, that was almost too easy. Let's apply Parkinson's Law ("Work expands to fill the time available"). We should do some error checking for the case that one of the arrays is empty. Because I can't think of a sensible result for that case, I'll throw an exception.

    die "ERROR empty array" if ( not ( @$arr1 and @$arr2) );

• @$arr1 and @arr2 -- the value of an array in a scalar context is its size; compact and useful, and easy to trip up beginners.
• I'm using not and and for readability, rather than ! and &&. It's a simple conditional expression, so there's no problem with the low precedence of not and and.

That's nice, but now we have a function that could possibly throw an exception. We should check for that. Classic Perl had the eval syntax, but there have been variations on a try/catch feature for decades. Perl finally acquired a native try/catch syntax as an experimental feature in release 5.34, and it became a stable language feature in 5.40, so let's embrace the future.

For command-line usage, I'm going to pass the script a pair of comma-separated lists.

perl ch-2.pl  1,2,3,4  3,6,9

The Perl code to handle the arguments and call maxDist will look like:

my @ARR1 = split(",", shift // "");
my @ARR2 = split(",", shift // "");
try          { say maxDist(\@ARR1, \@ARR2); }
catch ( $e ) { say STDERR "Problem: $e" }

Notes:

• shift -- the implicit argument for shift is @ARGV, so this takes the next available command-line argument.
• shift // "" -- If there isn't an argument, avoid a warning message by defaulting to an empty string.
• say STDERR "..." -- Not trying very hard to inform or recover, but at least use conventional streams.

The final piece is to add a unit test for catching an exception. Using the Test2::V0 testing module, check for throwing an appropriate exception like this:

    like( dies { maxDist([], []) }, qr/empty/i, "Empty arrays");

• like(...) -- test that the result of some code matches a regular expression
• dies {...} -- evaluate some code that is expected to throw an exception (note braces instead of parentheses).

Originally published at Perl Weekly 737

Hi there!

There is a new episode of Underbar, the Perlish podcast, part 3 of the Vibe-coding with Perl series came out, and there is an article whether one should learn Perl in 2025.

Regarding that. My son became a programmer a while ago mostly writing in Python and some fron-end stuff when necessary. He also knows how to use vim and he is definitely not lost on the Linux command-line. I don't think there is a lot of value for him to learn Perl in general, but being able to write one-liner to help with various small tasks could be really usefule. So I started to put together a bunch of oneliners in Perl and converted it into a book. It is still only in its infancy, but to go with the tradition I decided to release early.

Thus you can already read it for free or if you'd like to also support my efforts then you can buy an epub/pdf version of it via Leanpub. You can even pick the price.

Enjoy the book and enjoy your week!

--
Your editor: Gabor Szabo.

Podcast

The Underbar, episode 4: The Cyber Resilience Act

BooK wrote: I've just published the latest episode of The Underbar. This time we're having a long conversation with Salve Nilsen about the Cyber Resilience Act and it consequences for Perl and CPAN.

Articles

Installing DarkPAN Perl modules via GitLab

Thomas wrote: This week Farhad and me finally found some time to improve a part of our build pipeline that was nagging me for years. We can now release our DarkPAN modules via CI/CD into a GitLab generic packages repository and install them from there into our app containers, also via CI/CD pipelines.

Vibe coding a Perl interface to a foreign library - Part 3

CVE-2025-40927

Re-creating the vulnerability CVE-2025-40927 in an isolated docker container.

Taking VelociPerl for a ride.

VelociPerl is a closed source fork of Perl that claims performance gains of 45% over the stock.

A Quiz about Operator Priorities

Should You Learn Perl in 2025?

Annual Russian Perl Conference 2025

Discussion

question about class design with Object::Pad

object inheritance in xs

order of SvXXOK in xs

The Weekly Challenge

The Weekly Challenge by Mohammad Sajid Anwar will help you step out of your comfort-zone. You can even win prize money of $50 by participating in the weekly challenge. We pick one champion at the end of the month from among all of the contributors during the month, thanks to the sponsor Lance Wicks.

The Weekly Challenge - 338

Welcome to a new week with a couple of fun tasks "Highest Row" and "Max Distance". If you are new to the weekly challenge then why not join us and have fun every week. For more information, please read the FAQ.

RECAP - The Weekly Challenge - 337

Enjoy a quick recap of last week's contributions by Team PWC dealing with the "Smaller Than Current" and "Odd Matrix" tasks in Perl and Raku. You will find plenty of solutions to keep you busy.

TWC337

This is a solid, practical and highly efficient blog post that showcases a competitive programming mindset. The approach is characterized by a focus on performance, concise code and leveraging the powerful built-in functions of Perl.

Oddly Current

This is a high-quality, technically sound blog post that perfectly exemplifies the spirit of Raku programming. It successfully demonstrates how to tackle a classic algorithmic problem (Eulerian Circuits) by leveraging Raku's unique and powerful features, such as its sophisticated grammar (regex) engine and functional programming constructs.

I Never Go Far Without A Little Big Star

This post is a well-written, technically sound and engaging exploration of two weekly code challenges in Perl. Overall, it's a solid contribution that balances clarity, correctness and style.

Smaller Oddities

Both tasks move beyond naive solutions to offer significantly more scalable alternatives. The use of sorting, indexing, and run-length encoding reflects expert-level proficiency in PDL. Despite the technical depth, the code remains compact and well-organized.

Perl Weekly Challenge 337

Solutions are elegant, efficient (thanks to PDL), and provide precise results. They shine when used in a context where PDL is acceptable.

Small Numbers, and No Matrix at All

Both tasks avoid brute-force solutions in favor of counting, sorting, and parity logic. Code is concise, modern, and idiomatic Perl. Commentary is pedagogical, explains not only the "how" but also the "why".

Small, but Oddly Current

This is an exceptionally well-written and insightful post. It successfully transcends a simple "how I solved these coding puzzles" write-up and instead delivers a compelling narrative about the enduring relevance of Perl, the value of community-driven challenges and the universal benefits of sharpening one's problem-solving skills with constrained tools.

One and two dimensions

Solutions are clear, idiomatic Perl, well explained and great for educational/demo purposes. They emphasize readability and correctness over raw efficiency, which is often the right trade-off in The Weekly Challenge.

The Weekly Challenge #337

The solutions are excellent. They are correct, efficient, readable and well-structured. The post has a clear, pragmatic coding style that focuses on simplicity and directly solving the problem at hand. The code is thoroughly documented and follows good practices. This is production-quality code for this type of algorithmic problem.

The Odd Current

The post is a masterclass in technical writing and scientific computing. It successfully transforms a seemingly simple programming challenge into a deep, insightful exploration of numerical methods and performance optimization.

Oddly small

This is a well-written, engaging and technically sound solution to a coding challenge. It stands out by focusing on clarity, educational value and algorithmic elegance rather than just brute-forcing an answer.

Weekly collections

NICEPERL's lists

Great CPAN modules released last week.

Events

Boston.pm - online - monthly meetings resume (2d Tuesday)

September 9, 2025

Paris.pm - Michelangelo - monthly meeting

September 10, 2025

Toronto.pm - online - Lightning Talks 2025

September 25, 2025

Annual Russian Perl Conference 2025

September 27, 2025

Toronto.pm - online - How SUSE is using Perl

December 6, 2025

You joined the Perl Weekly to get weekly e-mails about the Perl programming language and related topics.

Want to see more? See the archives of all the issues.

Not yet subscribed to the newsletter? Join us free of charge!

(C) Copyright Gabor Szabo
The articles are copyright the respective authors.