Originally published at Perl Weekly 770

Hi there,

I like to believe that I belong to the old school of testing i.e. Test::More. That being said, every now and then I come across a magical test workflow. One of them is App::Yath. The biggest and pleasant surprise is that both were presented by none other than Chad Granum. Although I love the idea, I find it hard to adapt to it. I have to force myself otherwise it won't happen. I wrote a short blog post as a reminder to myself while working on this editorial. I can refer to it next time I am changing existing code or adding new code.

Speaking of testing, Herbert Breunung shared a blog post explaining how Test::Builder helped him create his own test suite. This reminded me how I did exactly that in 2010 to create Test::Map::Tube for my routing framework, Map::Tube. It makes me feel quite old now!

Enjoy rest of the newsletter.

--
Your editor: Mohammad Sajid Anwar.

Announcements

The London Perl and Raku Workshop 2026

Just a heads up: The next LPW is planned to be in November 2026.

PPC Summer 2026 - Call for Participation!

Brett Estrade, who is a member of the Perl Community Conference (PPC) organising committee, has released a call for participants for the Summer 2026 PPC. He notes the group's success in the areas of scientific research and community building through the use of independent Perl conferences and asks for speakers to submit proposals to present their work via the Papercall system to help keep the momentum going.

Articles

Who tests the tester? Me !!!

In the article, Lichtkind shows how to apply the Test::Builder::Tester module to check your own test functions for correctness. He shares real-life example of using the is_tuple() function that he has developed to aid in creating a test for the GTC project.

This week in PSC (222) | 2026-04-25

Ihe Perl Steering Council got together at the 2026 Perl Toolchain Summit (Vienna). During this meeting, the group discussed the current status of Perl 5.44. Most blockers have been resolved and EOL workflow has been put in place. Finalisation of details for the next stable release is currently taking place.

Importance of Repositories in Public

In this blog post, Mikko argues that keeping project repositories publicly accessible is an important practice even when no new contributions are anticipated. Having a project public on GitHub preserves historical context, serves as an example of quality work for others, and provides a source of useful data for the open-source community.

AI as a Chance - Opinion

In this article PetaMem discussed how through AI we will have access to new ways to enhance our creative processes (as opposed to replacing them), through developing a partnership with AI; allowing developers and creators alike use the technology of AI to automate repetitive processes and create opportunities for problems to be solved and new ideas developed through creative innovation.

Discussion

AI Contributions to CPAN: The Copyright Question

In his article, Todd explores some of the legal issues surrounding code that is generated by AI and available through CPAN, and whether or not these AI-generated contributions are eligible for copyright protection and/or a legal license. He also cautions maintainers about the use of black box LLMs, which do not make public their training data, and encourages the Perl community to develop guidelines for the proper protection of the Perl software ecosystem from future disputes arising from improper use of code generated by LLMs.

Web

Use Your Powers Only for Good, Clark

Dave dissects a really good looking SPAM email made by an AI LLM to show us all how the world will look in future with AI created outreach. Even though the spam had accurately scraped Dave's background and book titles, Dave believes that this creates the illusion of understanding but does not demonstrate the LLM has any real knowledge of either Dave's values or business model. Dave further states that this type of outreach is now cheaper and easier than ever though the deployment of AI to create large amounts of unsolicited SPAM.

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 - 371

Welcome to a new week with a couple of fun tasks "Missing Letter" and "Subset Equilibrium". 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 - 370

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

Perl Weekly Challenge 370: Popular Word

Abigail offers a superb example of processing text for the "Popular Word" task using the ability of Perl's regex engine to process words without considering case and complex punctuation marks. This solution is unique because it demonstrates a high-performance solution for filtering out banned words while maintaining concise and easily readable code.

Perl Weekly Challenge 370: Scramble String

Abigail used a clever recursive method to take on the challenge of the "Scramble String" problem. The use of clear base cases and logic to explore possible points to split and swap all contribute to the final solution being an excellent example of how to solve complex problems with string transformations, using a valid solution and providing a framework that can be used to solve other complex problems involving string transformations.

Popular Scramble

Arne's experience in comparing Raku's expressive power vs. Perl with respect to the solutions of these two challenges are at the heart of this review. He also demonstrates how to use Raku's built-in Bag and Any types to simplify complex logic with clean, idiomatic code. This article is a great reference for developers who want to learn how to use modern functional programming patterns effectively.

PWC 370 Scramble On, Scramblin' Man

Bob has created a detailed breakdown of the Scramble String problem, looking at the need to use memoisation to avoid redundantly calculating recursive algorithms. Bob has developed a very clearly constructed solution to the Scramble String problem using test-first development which is a perfect demonstration of how to keep performance and readability on complex branching logic.

Perl Weekly Challenge: Week 370

In this article, there is a thorough comparison made between two languages: Perl and Raku. The many modern capabilities of Raku, such as having a Bag data structure and being natively supportive of methods for manipulating strings, resulted in solving the stated problem while producing significantly less code than what is generated by using Perl to do the same thing.

Scrambled Bans

Jörg has concentrated his efforts solely on providing a high quality Perl solution to this challenge. The way he solves "Scramble String" is especially impressive because he uses a recursive solution that processes challenging partitioning and swapping of strings, using clean and idiomatic Perl programming.

Perl Weekly Challenge 370

W. Luis Mochán offers a mathematically rigorous and elegant take on Challenge 370 using Perl. For Task 1, he utilises a compact approach by normalising the input with lc and regex, then applying a frequency count. His review is particularly positive about the clarity and efficiency of using a single hash to filter out banned words while identifying the maximum frequency in one pass. For Task 2, he implements a recursive solution and highlights the technical necessity of caching results to avoid the exponential growth of possibilities in longer strings.

Scrambling Back and Forth

Matthias's submission for Task 1, he has used a concise and efficient one-liner with List::UtilsBy::max_by to count how many times words appear and in doing so stores a reference to the 'most popular' result while processing all results in a single pass. With respect to Task 2, Matthias did not limit himself to performing a simple recursive search as in previous weeks; however, he developed a Reverse Scramble algorithm, which is performing this task as a sequence of sorting in which strings become indexes of streaks representing their sorted order to allow for efficient verification of scrambling operations performed.

The scramble can not stop you / from becoming popu-ler… lar

Packy's polyglot Challenge 370 features solid code samples in Perl, Raku, Python, and Elixir that showcase how to solve the problem multiple ways using different programming languages. He shows how using Elixir's pipe operator or Raku's Bag can help efficiently transform and filter the paragraph from "Most Popular Word". He also demonstrates a consistent, recursive approach to solving the problem using the same recursive logic, with code examples in each of the four languages, while adapting to the specific syntax and idioms of each language, in his example "Scramble String".

Words and more words

Peter implements a clean regular expression approach to normalising the text and eliminating any banned words in Popular Word, while also provides a completely recursive solution in Scramble String that clearly demonstrates splitting and swapping parts of the string in order to illustrate the property of being scrambled.

The Weekly Challenge - 370: Popular Word

Reinier solution includes a simple regular expression to remove punctuation characters and a hash to count the number of occurrences of each valid word. This makes it easy to identify the most frequently used word that is not on a banned list, and provides an easily readable model from which to analyze text.

The Weekly Challenge - 370: Scramble String

Reinier's demonstrates pruning as an optimisation technique. If the characters sorted for both strings do not match (meaning they are not anagrams), the function returns false without going through all remaining recursive levels.

The Weekly Challenge #370

Robbie's high-performance Perl solutions employ algorithmic efficiency and strong input validation. In Task 1, he uses a fast normalisation method along with a hash-based frequency counting scheme to isolate the most popular word. In Task 2, Robbie's "Scramble String" implementation is notable for being a recursive Divide-and-Conquer strategy, providing an additional speedup by implementing a pre-check anagram filter to eliminate expensive recursive calls to incompatible strings.

Popular Scramble

Roger shown how to use a specialised programming tool like Counter in Rust to find popular words with only a few lines of code. In addition, the example in PostScript is an interesting concept as it shows how to create a counted hash from scratch using the examples provided in the Rust program as a reference.

Popular Scrambling

Simon demonstrates Task 1 by methodically normalising strings and counting strings using hashes in order find the word with the highest occurrence. His solution for Task 2 highlights the use of recursion when solving the problem, and optimises by checking if two strings are anagrams with a "fail-fast" method; this way, all non-anagrams can be filtered out before going through the more complex process of recursion.

Perl Tutorial

A section for newbies and for people who need some refreshing of their Perl knowledge. If you have questions or suggestions about the articles, let me know and I'll try to make the necessary changes. The included articles are from the Perl Maven Tutorial and are part of the Perl Maven eBook.

Testing in Perl

The 'slides' with all the examples that are used in the online course.

Rakudo

2026.16 Selkie TUI Framework

Training

Testing in Perl

While we are still recording the live sessions of the Testing in Perl you can also watch the previous episodes on the Code Maven Academy web site. Usually it is for paying subscribers only, but for the next couple of day you can still access it free of charge. You only need to register on the web site.

Weekly collections

NICEPERL's lists

Great CPAN modules released last week.

Events

Perl Maven online: Testing in Perl - part 5

April 30, 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.

If your girlfriend has been kidnapped by Gollum and the Evil One, and there's nothing you can do, perhaps console yourself with a small programming problem while you listen to Ramble On or Ramblin' Man'.

PWC 370 Task 2: Scramble String

The Task

You are given two strings A and B of the same length. Write a script to return true if string B is a scramble of string A otherwise return false. String B is a scramble of string A if A can be transformed into B by a single (recursive) scramble operation. A scramble operation is:

• If the string consists of only one character, return the string.
• Divide the string X into two non-empty parts.
• Optionally, exchange the order of those parts.
• Optionally, scramble each of those parts.
• Concatenate the scrambled parts to return a single string.

Examples

1. Input: $str1 = "abc", $str2 = "acb" Output: true
   • split: ["a", "bc"]
   • split: ["a", ["b", "c"]]
   • swap: ["a", ["c", "b"]]
   • concatenate: "acb"
2. Input: $str1 = "abcd", $str2 = "cdba" Output: true
   • split: ["ab", "cd"]
   • swap: ["cd", "ab"]
   • split: ["cd", ["a", "b"]]
   • swap: ["cd", ["b", "a"]]
   • concatenate: "cdba"
3. Input: $str1 = "hello", $str2 = "hiiii" Output: false
4. Input: $str1 = "ateer", $str2 = "eater" Output: true
5. Input: $str1 = "abcd", $str2 = "bdac" Output: false

The Ramblin' Scramblin' Thinkin' Part

This could go two ways: (1) generate every possible scramble of str1 and then look for str2; or (2) do a breadth-first or depth-first search for str2.

The possible number of scrambles could explode. For a length of n, there will be n-1 splits, and then the n-1 string will have n-2 splits, and so on, so we're looking at factorial complexity. Let's not generate every possible scramble unless we have to.

For a search, we'd be trying to match the front or back halves of the two strings, and then recursing on the parts that didn't match. There are finite possibilities for partial matches.

• A simple swap gets us from str1 to str2:

  str1:    ---  ++++++++++
  str2:    ++++++++++  --- 

• The head or tail of str1 matches the corresponding head or tail of str2, requiring us to recurse on the shorter string that didn't yet match.

   str1:   ===  [??????????]    ||    [???]   ==========
            |     scramble           scramble      |
            |         |                 |          |
   str2:   ===  [.*#.*#.*#.]    ||    [.*#]   ==========

• The head or tail of str1 matches the back or front of str2. Similar to the case above, except that a swap is required before we recurse.

   str1:  ===  [??????????]   ||   [???] =========
                     /               \
             scramble                 scramble
               /                              \
   str2:  [.*#.*#.*#.]  ===   ||   ========= [.*#]

A Bold Strategy, Cotton. Let's see if that works out for him.

After an embarrassing amount of trial and error (you might say I was scrambling), my solution converged on this longer-than-usual recursive function.

sub isScramble($str1, $str2, $depth = "")
{
    state %remember;
    %remember = () if $depth eq "";

    my $key = ":$str1:$str2:";
    if ( exists $remember{$key} )
    {
        $logger->debug("${depth}CACHED $key = ", ($remember{$key} ? "true":"false"));
        return $remember{$key}
    }

    my $len = length($str1);
    return ( $remember{$key} = false) if $len != length($str2);
    return ( $remember{$key} =  true) if $str1 eq $str2;

    for ( 1 .. $len-1 )
    {
        # $_ is the length of the left substring (head), $len-$_ is length of right (tail)
        my (  $head,   $tail) = ( substr($str1, 0, $_), substr($str1, $_) );
        my ($s2head, $s2tail) = ( substr($str2, 0, $_), substr($str2, $_) );

        my $s2front = substr($str2, 0, $len-$_);   # length of $tail, on left side
        my $s2back  = substr($str2, -$_);          # length of $head, on right side

        $logger->debug("${depth}Compare [$head/$tail] <> s2head/$s2tail] ($s2front/$s2back)");

        if ( "$tail$head" eq $str2 )
        {
            $logger->debug("${depth}FOUND $str2");
            return $remember{$key} = true;
        }
        elsif ( $head eq $s2head )
        {
            $logger->debug("${depth}HH, compare $tail <> $s2tail");
            return true if $remember{$key} = isScramble($tail, $s2tail, "  $depth");
        }
        elsif ( $head eq $s2back )
        {
            $logger->debug("${depth}HB, compare $tail <> s2front");
            return true if $remember{$key} = isScramble($tail, $s2front, "  $depth");
        }
        elsif ( $tail eq $s2tail )
        {
            $logger->debug("${depth}TT, compare $head <> s2head");
            return true if $remember{$key} = isScramble($head, $s2head, "  $depth");
        }
        elsif ( $tail eq $s2front )
        {
            $logger->debug("${depth}TF, compare $head <> s2back");
            return true if $remember{$key} = isScramble($head, $s2back, "  $depth");
        }
        else
        {
            $logger->debug("${depth}No pairs, recurse with $head<>$s2head and $tail<>$s2tail");
            return $remember{$key} = true if ( 
                   ( isScramble($head, $s2head, "  $depth")
                  && isScramble($tail, $s2tail, "  $depth") )
                || ( isScramble($head, $s2back, "  $depth")
                  && isScramble($tail, $s2front, "  $depth") ) );
        }
    }

    $logger->debug("${depth}NOT FOUND $key = false (caching)");
    return $remember{$key} = false;
}

Notes:

• The function starts out with setting up a cache for partial results. During development, I added this near the end of the process, but it shows up at the top of the function, so let's discuss it.

  • Recursive search algorithms usually benefit from caching known results. Our worst case is that str1 can't be scrambled into str2, in which case we'll end up doing the whole exponential tree of possibilities. I expect caching partial results would pay off.
  • The %remember hash is my cache, and it's a state variable so that it persists across recursive calls. But that means it also persists across invocations for different test cases, so it could yield wrong answers unless I initialize it at the top level of the recursion.
  • The cache is filled by using in-line assignment every time a result is returned, which is kind of cutely readable, I think.
  • Should I have used Memoize? Maybe. But that caches values based on the arguments passed to the function, and one of my arguments is the depth to which I've recursed. That means cache misses depending on how I got down the search tree, so I opted for do-it-yourself memo-ization.

• The function begins by dispensing with the easy cases: having a result in the cache, matching strings, and strings of the wrong length.

• Then, for each division of str1, let's have at hand the substrings that we might be dealing with from both str1 and str2. There's a little tour-de-force of substr uses here, splitting the strings at a midpoint, and using negative offsets.

• Most of the body of the function is testing which pairs match up, if any, and doing the appropriate recursion of what remains.

• The last case, where neither the head nor the tail of str1 has a matching complement in str2, requires us to recurse on both pieces, and in either order.

• I used logging liberally, because the function is only obvious in hindsight and took me longer than I'd like to admit. The $depth argument is mostly a convenience for indenting the log statements appropriately -- notice that it gets longer by two spaces at each recursion. My setup for logging uses Log::Log4perl in easy mode. It's part of my boilerplate for PWC solutions and looks like this:
  
  

use Getopt::Long;
my $Verbose = false;
my $DoTest  = false;

GetOptions("test" => \$DoTest, "verbose" => \$Verbose);
my $logger;
{
    use Log::Log4perl qw(:easy);
    Log::Log4perl->easy_init({ level => ($Verbose ? $DEBUG : $INFO ),
            layout => "%d{HH:mm:ss.SSS} %p{1} %m%n" });
    $logger = Log::Log4perl->get_logger();
}

Week 370

My Solutions
Task 1 : Popular Word (By M. Anwar)

You are given a string paragraph and an array of the banned words. Write a script to return the most popular word that is not banned. It is guaranteed there is at least one word that is not banned and the answer is unique. The words in paragraph are case-insensitive and the answer should be in lowercase. The words can not contain punctuation symbols.

For frequency of words I immediately plan to use a hash. My only hangup on this one was when the input paragraph was not space separated but used punctuation marks instead. This could be more robust, but that's an abnormal input. I turn everything lowercase, check for spaces, strip out the punctuation marks, and put the word count in the hash %h. Then we ignore banned words.

sub strip($w) {
    my $out;
    for my $letter (split '', $w) {
    $out .= $letter if ($letter =~ /\w/);
    }
    return $out;
}

sub proc($paragraph, @banned) {
    say "Input:  \$paragraph = $paragraph\n\t\@banned = @banned";
    my @words;
    if ($paragraph =~ /\s/) {
    @words = split ' ', lc $paragraph;
    } else {
    my $word;
    for my $letter (split '', lc $paragraph) {
        if ($letter =~ /[a-zA-Z]/) {
        $word .= $letter;
        } else {
        push @words, $word;
        $word = "";
        }
    }
    }
    my %h;
    foreach my $word (@words) {
    $word = strip($word);
    $h{$word}++;
    }
    my $max = 0;
    my $max_word;
    for my $w (keys %h) {
    my $ban = 0;
    for my $banned_word (@banned) {
        if ($w eq $banned_word) {
        $ban = 1;
        last;
        }
    }
    next if ($ban);
    if ($max < $h{$w}) {
        $max_word = $w;
        $max = $h{$w};
    }
    }
    say "Output: $max_word";
}

Task 2: Scramble String (By R. B-W)

You are given two strings $str1 and $str2 of the same length. Write a script to return true if $str2 is a scramble of $str1 otherwise return false. String B is a scramble of string A if A can be transformed into B by a single (recursive) scramble operation.

Mr. Roger Bell-West then goes on to explain what a scramble is.

• If the string consists of only one character, return the string.
• Divide the string X into two non-empty parts.
• Optionally, exchange the order of those parts.
• Optionally, scramble each of those parts.
• Concatenate the scrambled parts to return a single string.

When the task was first described, he had suggested choosing a random location for the split, and randomly deciding to perform the scrambles or swaps. I decided to embrace that approach.

I loop the scramble 10,000 times to increase the odds of success.

sub scramble($s) {
    my $len = length($s);
    if ($len == 1) {
    return $s;
    } else {
    my $pt = 1 + ($len - 1) * rand();
    my $a = substr $s, 0, $pt;
    my $b = substr $s, $pt;
    my $a_new = (int 2*rand() == 0) ? $a : scramble($a);
    my $b_new = (int 2*rand() == 0) ? $b : scramble($b);
    my $out = (int 2*rand() == 0) ? $a_new.$b_new : $b_new.$a_new;
    }
}

Originally published at Perl Weekly 769

Hi there,

Every week I see a post declaring about something being dead. Agile is dead! Testing is dead!, Algol-68 is dead! I am so fed-up with this. So I am not going to link to the article that was discussing 5 dead programming languages.

Last week finally I got home and because of the flight I had to postpone the Testing in Perl event so it will be held this Thursday. You are invited to watch the previous sessions (for now free of charge) and join the next one.

The Perl Maven WhatsApp group already has more than 70 members. Unfortunately recently we got a few spammers so I had to turn on registration-approval. This means that when you try to join I'll send you a private message asking who you are. This is the little extra step we have to do to avoid spam. Anyway, you are invited to join us!

Enjoy your week!

--
Your editor: Gabor Szabo.

Announcements

TPRC Talk Submission Deadline in 2 days!

Articles

Faster UTF-8 Validation

Way more information about UTF-8 than I can fit in my head.

Enums for Perl: Adopting Devel::CallParser and Building Enum::Declare

Compiling Google::ProtocolBuffers::Dynamic on Debian Trixie

For a long time I have been trying to encourage Perl Module authors to include installation instruction when external libraries are needed. Even if only for one or two Linux distributions. This information should be in the README of the project.

Happy sharing

How to share memory between processes? A survey of a bunch od Data::* modules.

Making an Asynchronous Clocking Drum Machine App in Perl

PDL in Rust -- Part Two

"The current PDL implementation in pperl covers roughly 3,000 assertions end-to-end: about 1,400 on the Perl-facing connector side and about 1,600 on the engine side. As of this writing roughly 98% of the connector assertions match upstream PDL 2.103 exactly, and most of the remaining couple of dozen we already know why they fail. By the time you read this the numbers will have drifted a little in our favour - give or take - but the shape is the point, not the decimal."

Discussion

parsing a csv with boms in every line

What kind of strange things people have to deal with?

A curious case of an autovivified env var

Should the documentation of autovivification be comprehensive?

Grants

Maintaining Perl 5 Core (Dave Mitchell): March 2026

PEVANS Core Perl 5: Grant Report for March 2026

Maintaining Perl (Tony Cook) March 2026

Perl

This week in PSC (221) | 2026-04-13

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 - 370

Welcome to a new week with a couple of fun tasks "Popular Word" and "Scramble String". 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 - 369

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

Perl Weekly Challenge 369: Valid Tag

This post provides multiple amazing examples of technical versatility by providing a clean and direct solution written clearly in many different programming languages with tremendous flair, it shows great elegance in presenting the elegant and simple solution to the valid tag problem using the idiomatic language of each respective programming language. Abigail shows off expert level code writing skills by using the advanced character class arithmetic features present within Perl; these advanced ways of manipulating strings show the efficiency of his coding style, while simultaneously creating visually appealing code.

Perl Weekly Challenge 369: Group Division

This post offers an extremely polished and versatile engineering design for the island program project. Abigail has shown advanced expertise by using a 'chunk-and-fill' method over many different programming languages (Perl, C, and less common languages such as sed, including details on how string slices and fill-up strings can be done with the least amount of impact. Furthermore, it highlights a creative use of string replication operators as well as very efficient use of loops that guarantee that the final incomplete group will still have the correct amount of padding added based on the requirements given in the challenge.

Tag Division

In an idiomatic Raku implementation of the Group Division problem, as shown pretty clearly here by Arne Sommer, the gather/take construct is utilised nicely to collect the data clearly, and with the use of substr-rw for in-place string manipulation and the replication operator (x) to add padding, the solution is both easily readable and aesthetically pleasing.

Perl Weekly Challenge: Week 369

By taking advantage of mathematical precision and the crispness of concise syntax through the use of "one liners", Jaldhar has developed an efficient method for solving this problem, no matter if you're using Raku or Perl. Calculating the required amount of padding to add to a split string before actually splitting it, allows for quick and accurate results. Furthermore, the clever application of native string manipulation functions adds an additional level of efficiency and clarity to handling the grouping logic.

Divided Tags

This article offers a detailed examination of the many aspects of the "Valid Tag" challenge and provides a well-defined "word" in order to enhance the accuracy of processing. The body of this technical paper describes Jorg's unique application of the Perl programming language's ability to utilise global regular expressions (regex) to solve Task 2; and also the excellent "Shape" verb from the J programming language that has provided an efficient and generalised way to reshape and pad multi-dimensional arrays.

The Weekly Challenge 369

In this post, we look at the approach both challenges in a disciplined and structured manner. The focus is on having code that is easy to maintain and easy to read. We have examples showing clean, modular Perl and Python code, and show examples of how the "Group Division" challenge is solved using efficient use of list slicing and using generator expressions to partition and pad strings in a method that's worthy of professional quality.

string indexes

Luca Ferrari exhibits an incredible degree of technical ability through his creation of five unique environments in which to accomplish the Week 369 challenges. Those five programming environments are: Raku, Python, PostgreSQL (PL/Perl, PL/PgSQL, and PL/Java). Luca's elegant use of Raku's rotor method combined with the ability of Python's list slicing to achieve the same complex logic for string padding and partitioning, as demonstrated in his application of The Group Division challenge, show how many different programming languages can utilise very diverse methods to accomplish the same technically precise logic.

Perl Weekly Challenge 369

The post demonstrates exceptional compact Perl programming by distilling complex string processing procedures into "1.5-liners" that are quite efficient. For Task 1, he builds camelCase tags from a string of input values using the split, map, and join functions in order to achieve the desired result in one pass. In addition, Luis's approach to Task 2 makes use of a brilliant "alternation" regex (.{$size}|.+) as a means of capturing both full and partial segments of an input string in an optimal manner. The use of this regex allows him to create direct array-index padding, resulting in code that is not only concise, but also very technically accurate and well-balanced between the two principles.

Good Tags and Good Chunks

Matthias Muth has written an impressive article on internationalisation (I18N) relating to pragmatic problem solving while still maintaining a strong long-term support model through thoughtful design choices such as those found within both the "Valid Tag" and "Group Division" solutions provided by Matthias's book. The use of the Text::Unidecode module was one way to create technically superior solutions that would accommodate for the presence of non-ASCII character sets and would also adhere to the rules specified in the challenge itself (e.g., valid tag). Additionally, his solution for "Group Division" is equally amazing because he accomplished this via a mathematical pad for the purpose of executing a clean single regex global match - or a single line of functional code - that could otherwise be accomplished via several iterations of code.

Strings Will Tear Us Apart

In this post, Packy gives a thorough, contemporary example of string handling in Raku, Perl, Python, and Elixir. He creates a unique solution to the "Group Division" challenge by using the Raku function .comb with integer arguments to automatically divide into chunks and by using the Perl 'unpack' function with a per-function constructed template, demonstrating how you can creatively employ language idioms to efficiently and effectively resolve a common programming issue and provide a solution for data partitioning that uses little or minimal resources.

Fun with strings

In his article, Peter presents a practical and polished approach to developing an order of operations for the sanitisation of strings. By organising the procedure so that lower case, regular expression character removal, and space & character combination are completed before the creation of camelCase, the end product meets the requirements for both camel case formatting as well as length requirements while still producing clean, effective code.

The Weekly Challenge - 369: Valid Tag

In Reinier's method, a model for defensive programming has been developed that features validation of input for real alphabetic values before processing. Also, he has taken a somewhat technical approach (transforming input to remove non-letter characters by converting them to spaces in order to apply camelCase correctly while keeping word boundaries intact) through his use of multiple accurately readable regular expressions.

The Weekly Challenge - 369: Group Division

Reinier has created a very good tutorial solution which showcases how to use the "Perl 4-argument substr function" to extract and remove data from a string using a while loop to do so iteratively and then using string replication for the final padding makes the code extremely readable and a great technical example of using efficient in-place usage of strings.

The Weekly Challenge #369

The work done by Robbie within the "Valid Tag" review indicates a very well thought out way to approach hyphenated compound words as a single entity for case adjustment, in addition to providing an innovative solution for "Group Division", by utilising the four-argument form of Perl's substr in order to easily "chop and fill" strings, while also demonstrating his superior knowledge of high-performance string manipulation.

Divided Validity

Roger's technical review offers an interesting side-by-side comparison of various string handling paradigms from multiple programming languages. The "Valid Tag" part of the review shows how Crystal's highly performant state machine implementation allows for case conversion to be accomplished in a single pass. The "Group Division" analysis of in_groups_of() in Crystal is very interesting as well, as it illustrates just how compact that library function is compared to typical iterative slicing found in Typst, demonstrating that using built-in library functions can greatly simplify the implementation of algorithmic logic through less code complexity.

Group Tag

A wonderful illustration of Test-driven development is Simon's critique of Challenge 369. He found through tests that the sanitisation step of "Valid Tag", had to be completed before performing case formatting so that example 5 is handled properly. He also provides useful technical comparisons between both languages' ecosystem strengths, such as Python using more_itertools.grouper vs Perl doing it manually by iteration.

Weekly collections

NICEPERL's lists

Great CPAN modules released last week.

Events

Perl Maven online: Testing in Perl - part 4

April 23, 2026

Perl Toolchain Summit 2026

April 23-26, 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 369

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: Valid Tag

Submitted by: Mohammad Sajid Anwar

You are given a given a string caption for a video.

Write a script to generate tag for the given string caption in three steps as mentioned below:

1. Format as camelCase Starting with a lower-case letter and capitalising the first letter of each subsequent word: Merge all words in the caption into a single string starting with a #.
2. Sanitise the String: Strip out all characters that are not English letters (a-z or A-Z).
3. Enforce Length: If the resulting string exceeds 100 characters, truncate it so it is exactly 100 characters long.

My solution

The last example - where Hour starts with a upper case letter - would suggest that the second step needs to be done before the first one. As I used TDD when writing these solutions this was picked up when running the tests.

Nothing overly tricky about the solution. I take input_string and perform the necessary operations on it.

def valid_tag(input_string: str) -> str:
    input_string = re.sub(r"[^\sa-zA-Z]", "", input_string)
    input_string = input_string.strip().lower()
    input_string = re.sub(r" +([a-z])", upper_case_letter, input_string)
    return "#" + input_string[:99]

The Perl solution is similar.

sub main ($input_string) {
    $input_string =~ s/[^\sa-zA-Z]//g;
    $input_string =~ s/^\s+//;
    $input_string =~ s/\s+$//;
    $input_string = lc $input_string;
    $input_string =~ s/ +([a-z])/uc $1/eg;
    say "#" . substr($input_string, 0, 99);

Examples

$ ./ch-1.py "Cooking with 5 ingredients!"
#cookingWithIngredients

$ ./ch-1.py the-last-of-the-mohicans
#thelastofthemohicans

$ ./ch-1.py "  extra spaces here"
#extraSpacesHere

$ ./ch-1.py "iPhone 15 Pro Max Review"
#iphoneProMaxReview

$ ./ch-1.py "Ultimate 24-Hour Challenge: Living in a Smart Home controlled entirely by Artificial Intelligence and Voice Commands in the year 2026!"
#ultimateHourChallengeLivingInASmartHomeControlledEntirelyByArtificialIntelligenceAndVoiceCommandsIn

Task 2: Group Division

Task

You are given a string, group size and filler character.

Write a script to divide the string into groups of given size. In the last group if the string doesn’t have enough characters remaining fill with the given filler character.

My solution

This is one task where the Python and Perl solutions are completely different. Python's more_itertools module has the grouper function, so I use this to separate the string into parts with the filler if required. No need to reinvent a perfectly round wheel :)

def group_division(input_string: str, size: int, filler: str) -> list[str]:
    result = []
    for g in grouper(input_string, size, fillvalue=filler):
        result.append("".join(g))
    return result

Perl does not have a similar function, that I'm aware of. I use a traditional for loop to split the string into the different parts. After that I have a command that will add the filler to the last item in the @result array if required. The x operator is the replication operator in Perl.

sub main ( $input_string, $size, $filler ) {
    my @result = ();
    for ( my $i = 0 ; $i < length($input_string) ; $i += $size ) {
        push @result, substr( $input_string, $i, $size );
    }

    $result[-1] .= $filler x ( $size - length( $result[-1] ) );

    say "(" . join( ", ", @result ) . ")";
}

Examples

$ ./ch-2.py RakuPerl 4 "#"
['Raku', 'Perl']

$ ./ch-2.py Python 5 0
['Pytho', 'n0000']

$ ./ch-2.py 12345 3 x
['123', '45x']

$ ./ch-2.py HelloWorld 3 _
['Hel', 'loW', 'orl', 'd__']

$ ./ch-2.py AI 5 "!"
['AI!!!']