Originally published at Perl Weekly 771

Hi there,

I put the 'Testing in Perl' course on hold for now. Instead of that we are going to explore the use of some of the mocking libraries we saw during the course. In the next session we'll pick one of the Perl modules used for mocking and we'll look for modules that use it. We'll try to understand how it is being used and we'll try to contribute something to at least one of the modules.

For background you can check the OSDC Perl page where we have a listing of modules for 'Code reading'.

You can also watch the recording of the Testing in Perl course. (Registration required but these videos are currently free of charge.)

Enjoy your week!

--
Your editor: Gabor Szabo.

Articles

ANNOUNCE: Perl.Wiki V 1.45 etc

TPRC Announces Post Conference Class

Steven Lembark is presenting: Teaching AI New Tricks: Perly MCP's for Claude.

Who tests the tester? Me !!!

I was just showing the participants of the 'Testing in Perl' course how to write and test a Test::* module. It is nice to see that about the same time Lichtkind wrote an article about the same topic.

Reading CPAN Testers Reports Using AI Agents

A very interesting and useful use of AI.

Discussion

sending matrix messages

Module naming vs CPAN conventions

Perl in Ubuntu 26-04 LTS (vs 24-04 LTS)

Some Perl modules need a dev package to be installed using 'apt'.

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 Marc Perry.

The Weekly Challenge - 372

Welcome to a new week with a couple of fun tasks "Rearrange Spaces" and "Largest Substring". 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 - 371

Enjoy a quick recap of last week's contributions by Team PWC dealing with the "Missing Letter" and "Subset Equilibrium" tasks in Perl and Raku. You will find plenty of solutions to keep you busy.

Perl Weekly Challenge 371: Missing Letter

Abigail gives us an efficient solution, O(n), to the missing letter problem by determining the difference between the sum of all letters in a full range of letters and the sum of the letters in the given array. This eliminates unnecessary loops, which is a big advantage over an iterative search.

Perl Weekly Challenge 371: Subset Equilibrium

This solution is a well-organised that defines the NP-complete status of this problem and also implements an efficient bitmasking solution in numerous programming languages (e.g., Perl, Python, AWK, C, etc.) and serves as an excellent reference for other programmers to learn about and use for comparison purposes.

Missing Equilibrium

The Raku Solution implements this approach using combinations to easily create subsets in an idiomatic and very readable way. It also provides an elegant way of compensating for zero-based indices when calculating the sum of the positions in each subset by the calculated subsets.

Subset Equilibrium (Just nod if you can hear me)

Bob addressed the exponential number of complex solutions from the outset and provided a practical implementation based on Algorithm::Combinatorics. The use of a positional-based iterator with zero-index compensation allowed him to effectively handle the off-by-one requirement. In addition to that, Bob supplied practical testing strategies using the Test2::Tools::Compare package.

Perl Weekly Challenge: Week 371

This solution gives a clean, efficient implementation that fulfills both the requirement of a proper subset and utilising 1-based indexing by adding + @combo.elems to the index sum. By making use of combinations from Algorithm::Combinatorics in Perl (and using built-in combinations in Raku), only the necessary subset sizes are generated; the output formatting handles both the non-empty and empty result cases in a very clean manner via a clear ternary expression.

Missing Equilibria

This new solution offers an evaluation of the subset equilibrium problem that is a new and interesting technical perspective and acknowledges the shared views of the two demonstrated examples, while not overlooking those cases where the two may have disagreement along the edges of each set of criteria. The Perl code produced using Math::Prime::Util::forcomb and List::Gather is exceptionally simple but has an artistic style as well.

Perl Weekly Challenge 371

The post describes a simple yet effective way to generate all proper subsets of a set. It uses the subset function of the Algorithm::Combinatorics module to create all proper subsets, and then filters them based on a very concise expression written as a single line. The script contains both a command-line version for easy use and a complete version that includes error handling and has been thoroughly tested.

The Missing Equilibrium

By mathematically restructuring the main condition in the problem, i.e. equality of the total values for elements and their corresponding indices. Additionally, utilising the combination iterators from Algorithm::Combinatorics with subset sizes of 2 through n-1 provides a memory efficient approach to solving this exponential complexity problem while utilizing an optimally prepared array of pre-computed offsets, or at least the offsets for an individual index, gives evidence of thoughtful programming.

My subset is-a missing a letter…

The solution has a nice, clean, multi-language implementation (Raku, Perl, Python, Elixir) and uses indexed pairs of values to keep track of the relationship between the two elements and the index position of the two elements, thus having no off-by-one errors. The solution meets the "proper subset" constraints by filtering out empty sets, singletons, and the full set as well as providing lots of detail in verbose output to help educate the user by giving exact values and sums of values for each match.

Solve the question and balance the subset

By using established neighboring letter pairs, the algorithm determines the steps $a and $b in an efficient manner by deducing which are the next alternately patterned letter combinations in relation to each of the five positions for question marks. The entire algorithm utilises a single conditional expression to account for all five possible question mark positions. Additionally, the use of the modulus operator and the mapping of the patterning logic from the analysis to the assignment of steps makes this implementation both very efficient and very easy to read.

The Weekly Challenge - 371: Missing Value

This solution requires formalization of the detection of repeating patterns through a comprehensive and well-documented approach by treating them as a repeating two-stage model (i.e., d1 = d3 and d2 = d4). Special consideration is given to both constant and alternating sequences. The use of defined-or (i.e., //=) to unify step values, along with the straightforward relationship between each possible question mark position and its simple arithmetic reconstruction, contributes to creating a code that is highly reliable and easy to follow. Additionally, the thorough input validation provided demonstrates significant consideration for actually implementing in a real world scenario.

The Weekly Challenge - 371: Subset Equilibrium

This document includes an excellent comparison of two CPAN modules (Algorithm::Combinatorics and Data::PowerSet) that correctly identifies the combinatorically generated subsets by size (2 to n) are more efficient than generating the power set and filtering out the subsets to produce the same result for this specific task. The code base is very clean and well-structured; it also does a great job of utilising list slicing (@nums[@$subset]) and map to convert from 0-based to 1-based position, while making use of the helper function print_result to ensure that all output for all test cases is consistent and easy to read.

The Weekly Challenge #371

This document offers an innovative and realistic perspective on the subset equilibrium issue by acknowledging there is no "smart" optimisation to the subset equilibrium solution and then using a simple combination-based search on the two to n-1 sizes. The solution was implemented correctly with a summation on 1-indexed values for each of those combinations.

Missing Equilibrium

Roger demonstrates a very clever way of optimizing the solution through the precomputation of one list of differences so that only the check for the sum of the selected differences equals zero must occur, which substantially reduces the amount of computing needed within the combinatorial loops. Roger does a great job of providing a perspective of how to write this in many programming languages (Raku, Kotlin, Crystal, etc.) and provides many practical examples (like sorting the list to create a consistent order for output), thereby making this solution efficient and easily transferable across many different programming languages.

Question the bits

Using bit manipulation, this solution works well to create all combinations of subsets by iterating through all integers from 1 to 2^n-2, thus avoiding the empty and full subsets. The inner loop adds pos+1 because the indices in a array have a base index of 1, while the implementation does not require any third-party modules, making it portable and easy to use for individuals who are already comfortable using bit mask manipulation.

Weekly collections

NICEPERL's lists

Great CPAN modules released last week.

Event reports

Welcome to the Perl Toolchain Summit 2026!

That's how it started

Perl Toolchain Summit in Vienna

A little review by the local orga.

Events

Exploring Perl Modules

May 7, 2026

Boston Perl Mongers virtual monthly

May 12, 2026

The Perl and Raku Conference 2026

June 26-29, 2026, Greenville, SC, USA

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.

Weekly Challenge 372

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. Unless otherwise stated, Copilot (and other AI tools) have NOT been used to generate the solution. It's a great way for us all to practice some coding.

Challenge, My solutions

Task 1: Rearrange Spaces

Task

You are given a string text of words that are placed among number of spaces.

Write a script to rearrange the spaces so that there is an equal number of spaces between every pair of adjacent words and that number is maximized. If you can’t distribute, place the extra spaces at the end. Finally return the string.

My solution

This is a little more straight forward than last weeks challenge one task. For this task, I take start by separating the words on whitespace, and count the number of spaces. This is stored in the words list (array in Perl) and spaces variable.

def rearrange_space(input_string: str) -> str:
    words = input_string.split()
    spaces = input_string.count(" ")

To avoid a division by zero error, I handle the case where there is a single word. For this I return the word followed by the required number of spaces. In Python, a string multiple by an integer will repeat the string the specified number of times.

    if len(words) == 1:
        return words[0] + " " * spaces

If there is more than one word, I calculate the spaces_between_words and spaces_at_end using the divmod function. I return the string with the spaces in the appropriate places.

    spaces_between_words, spaces_at_end = divmod(spaces, len(words)-1)
    return (" " * spaces_between_words).join(words) + " " * spaces_at_end

The Perl solution uses the same logic. As it does not have a divmod function, I calculate the two values separately. The x operator in Perl is used for repetition. The expression $#words returns one less than the length of the words array.

sub main ($input_string) {
    my @words  = grep { $_ ne "" } split /\s+/, $input_string;
    my $spaces = ( $input_string =~ tr/ / / );

    if ( $#words == 0 ) {
        say '"' . $words[0] . " " x $spaces . '"';
    }
    else {
        my $spaces_between_words = int( $spaces / $#words );
        my $spaces_at_end        = $spaces % $#words;
        say '"'
          . join( " " x $spaces_between_words, @words )
          . " " x $spaces_at_end . '"';
    }
}

Examples

$ ./ch-1.py "  challenge  "
"challenge    "

$ ./ch-1.py "coding  is  fun"
"coding  is  fun"

$ ./ch-1.py "a b c  d"
"a b c d "

$ ./ch-1.py "  team      pwc  "
"team          pwc"

$ ./ch-1.py "   the  weekly  challenge  "
"the    weekly    challenge "

Task 2: Largest Substring

Task

You are given a string.

Write a script to return the length of the largest substring between two equal characters excluding the two characters. Return -1 if there is no such substring.

My solution

For this task, I start by creating a dict (hash in Perl) called freq with the frequency of each letter. In Python, this is achieved with the Counters function from the collections module.

I then iterate through the dict. If the letter occurs more than once, I calculate the difference between position of the first and last occurrence, minus one. Both Python and Perl have the index and rindex methods to do this. I update the largest value if this is greater than previously found values.

from collections import Counter

def largest_substring(input_string: str) -> int:
    freq = Counter(input_string)
    largest = -1

    for letter, count in freq.items():
        if count > 1:
            substr = input_string.rindex(letter) - input_string.index(letter) - 1
            if substr > largest:
                largest = substr

    return largest

The Perl solution follows the same logic.

sub main ($input_string) {
    my %freq = ();
    $freq{$_}++ foreach ( split //, $input_string );
    my $largest = -1;

    while ( my ( $letter, $count ) = each %freq ) {
        if ( $count > 1 ) {
            my $substr = rindex( $input_string, $letter ) -
              index( $input_string, $letter ) - 1;
            $largest = $substr if ( $substr > $largest );
        }
    }

    say $largest;
}

Examples

$ ./ch-2.py aaaaa
3

$ ./ch-2.py abcdeba
5

$ ./ch-2.py abbc
0

$ ./ch-2.py abcaacbc
4

$ ./ch-2.py laptop
2

$ ./ch-2.py abc
-1

Introduction

Perl is often referred to as the "duct tape of the Internet,” due to its versatility and practical applications in various domains. Developed by Larry Wall in 1987, Perl is a high-level programming language that's well-suited for text processing, system administration, web development, and network programming. This article explores its unique features, practical tips, and why you should consider learning Perl today.

Key Features of Perl

Perl is known for several unique features that make it appealing for both beginners and experienced programmers:

• Easy to Learn: Perl’s syntax is flexible and forgiving, which allows new programmers to grasp concepts quickly.
• Powerful Text Processing: With robust regular expressions and string manipulation capabilities, Perl excels in tasks involving text.
• CPAN Repository: The Comprehensive Perl Archive Network (CPAN) hosts thousands of modules that simplify development.
• Cross-Platform: Perl runs on various platforms, including Unix, Linux, Windows, and macOS, increasing its usability across different environments.
• Community Support: Perl has a large, active community that creates resources, tutorials, and forums to help learners.

Practical Tips for Learning Perl

If you're interested in beginning your journey with Perl, consider the following tips:

• Start with the Basics:
  • Learn about variables, scalars, arrays, and hashes.
  • Understand control structures like loops and conditionals.
• Utilize Online Resources:
  • Explore Perl training programs or tutorials for structured learning.
  • Leverage communities such as PerlMonks and the Perl subreddit for advice and problem-solving.
• Practice Regularly:
  • Write small scripts to automate mundane tasks, such as file manipulation and text parsing.
  • Contribute to open-source projects that utilize Perl; this will boost your practical skills.
• Embrace Debugging:
  • Learn to use Perl's built-in debugging tools, such as the -d flag, to troubleshoot and enhance your scripts.
• Explore CPAN:
  • Familiarize yourself with CPAN and incorporate various modules into your projects to save time and effort.
• Read Perl Books and Documentation:
  • Books like "Learning Perl" and "Programming Perl" are solid resources for in-depth understanding.
  • Official Perl documentation provides a wealth of information on syntax and modules.

Use Cases for Perl

Understanding where Perl is commonly applied can help you focus your learning efforts:

• Web Development:
  • Perl is used in server-side programming, notably with frameworks like Catalyst and Dancer.
• System Administration:
  • Admins rely on Perl for automation scripts that manage file systems, users, and processes.
• Bioinformatics:
  • Perl’s text processing capabilities make it suitable for analyzing biological data.
• Network Programming:
  • Perl's sockets provide the tools for network communication and building client/server applications.
• Game Development:
  • Although less common, Perl can be utilized in developing games or game-related tools.

Conclusion

Perl may not be the most publicized language, but its strengths in text processing and quick script development make it invaluable in various tech fields.

By investing time in learning Perl, you equip yourself with skills that enhance your programming capabilities and open doors to diverse opportunities. Engage with communities, practice regularly, and consider structured training to master this powerful language.

Another explosive weekly challenge. And by explosive I mean exponential complexity. Let's see what we've got. First I'll adjust the background music for equilibrium ... Comfortably Numb

Relax, I'll Need Some Information First

You are given an array of numbers. Write a script to find all subsets where the sum of elements equals the sum of their indices.

# Example 1 Input: @nums = (2, 1, 4, 3)
#.          Output: (2, 1), (1, 4), (4, 3), (2, 3)
#   Subset 1: (2, 1) Values: 2 + 1 = 3 Positions: 1 + 2 = 3
#   Subset 2: (1, 4) Values: 1 + 4 = 5 Positions: 2 + 3 = 5
#   Subset 3: (4, 3) Values: 4 + 3 = 7 Positions: 3 + 4 = 7
#   Subset 4: (2, 3) Values: 2 + 3 = 5 Positions: 1 + 4 = 5
#
# Example 2 Input: @nums = (3, 0, 3, 0)
#           Output: (3, 0), (3, 0, 3)
#   Subset 1: (3, 0) Values: 3 + 0 = 3 Positions: 1 + 2 = 3
#   Subset 2: (3, 0, 3) Values: 3 + 0 + 3 = 6 Positions: 1 + 2 + 3 = 6
#
# Example 3 Input: @nums = (5, 1, 1, 1)
#           Output: (5, 1, 1)
#   Subset 1: (5, 1, 1) Values: 5 + 1 + 1 = 7 Positions: 1 + 2 + 4 = 7
#
# Example 4 Input: @nums = (3, -1, 4, 2)
#           Output: (3, 2), (3, -1, 4)
#   Subset 1: (3, 2) Values: 3 + 2 = 5 Positions: 1 + 4 = 5
#   Subset 2: (3, -1, 4) Values: 3 + (-1) + 4 = 6 Positions: 1 + 2 + 3 = 6
#
# Example 5 Input: @nums = (10, 20, 30, 40)
#           Output: ()

Just the Basic Facts, Can You Show Me Where It Hurts?

Perusing the examples, I see that there are a couple of unstated requirements. From example 1, the improper subset (1,2,3,4) should work, but it's not in the given output, so apparently that should be excluded. And in example two, the subset (3) should work, but it's not in the output, so apparently subsets have to have at least two members.

I don't see any way of doing this other than generating all possible subsets and checking if they work. My approach is going to be to number the positions, and generate all possible subsets of the positions. Extracting members from the given list will be done with a hash slice. There's going to be a little annoyance that the task numbers positions starting from 1, while Perl array indexing is based from 0.

For a set of n members, there are 2ⁿ-1 possible subsets. I know that a way to generate subsets is to count from 1 to 2ⁿ-1 and check which bits are 1s in the binary representation. I know how to generate all possible subsets, but do I want to? Because I also know that there are CPAN modules that do this, and I have Algorithm::Combinatorics hanging around from previous problems, with its convenient subsets function, so let's use that.

I Do Believe It's Working, Good

sub sseq(@nums)
{
    use Algorithm::Combinatorics qw/subsets/;
    use List::Util qw/sum0/;
    my @result;

    my $s = subsets( [0 .. $#nums] );
    while ( my $position = $s->next() )
    {
        my $size = scalar(@$position);
        # Only proper subsets of size 2 or more
        next if $size == scalar(@nums) || $size < 2;

        # Subsets are indexed at zero, but positions at 1, so compensate in sum
        my $sumPosition = $size + sum0  @$position;

        my $sumNumbers = sum0 @nums[ @$position ];

        if ( $sumNumbers == $sumPosition )
        {
            push @result, [@nums[@$position]]
        }
    }
    return \@result;
}

Your Lips Move, But I Can't Hear What You're Saying

Explanatory notes:

• use Algorithm::Combinatorics qw/subsets/ -- This function creates an iterator to generate consecutive subsets from a given list of members. We're going to pass it a list of positions, from 0 to the last index of @nums.

• use List::Util qw/sum0/ -- sum0 handles empty lists by returning zero instead of an error, as sum does. That shouldn't come up in this particular function, but I generally use sum0 as my default, because I invariably get a warning from sum about an empty array and end up changing it anyway.

• my $size = scalar(@$position) -- the size of the position array comes up repeatedly, so let's get a handle on it.

• my @sumPosition = $size + sum0(...) -- The sum we're looking for is based on using positions numbered from 1, but we have them numbered from 0. We need to add 1 to each of the positions, which is the same as adding the number of positions.

• my @sumNumbers = sum0 @nums[ @$position ] -- Here's why I wanted positions to be indexed from zero: so that they could be used in a hash slice to extract the corresponding numbers.

• push @result, [@nums[@$position]] -- the result of this function is going to be a reference to an array of arrays (it's array reference turtles all the way down). Once again, the hash slice, now encased in [] to create an array reference.

That'll Keep You Going Through the Show

This function answers the question, but it leaves two things undone.

First, the order of the lists is unspecified. There's no apparent reason for the order in the examples, and I quickly found out that the subsets iterator doesn't return subsets in the same order as the examples.

To create unit tests, I want to check that arrays contain the same members, but order doesn't matter. In the Test2 suite, this can be accomplished by putting the expected elements into a bag data structure.

sub runTest
{
    use Test2::V0;
    use Test2::Tools::Compare qw/bag item/;
    my $check;

    $check = bag { item [1,4]; item [2,1]; item [2,3]; item [4,3]; end(); };
    is( sseq(2,1,4,3), $check, "Example 1");
[...]

Our bags are checked, so ...

Come On, It's Time To Go

Second, to display the output, we have to unwrap the array references and render them as formatted strings.

say join ", ", map { "(" . join(", ", $_->@*) . ")" } sseq(@ARGV)->@*;

What's going on here?

• sseq(@ARGV)->@* -- Call our function, using the command line arguments, and dereference it (which yields an array of array references).
• map { ... } -- Transform each of the array references
• "(" . join(", ", $_->@*) . ")" -- $_ is a reference to an array, so $_->@* is the list of elements in the array. Make it a comma-separated string, encased in parentheses.
• say join ", ", ... -- output each of those parenthesized strings, separated by commas

I Have Become Comfortably Numb

Equilibrium achieved.