Weekly Challenge 359

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: Digital Root

Task

You are given a positive integer, $int.

Write a function that calculates the additive persistence of a positive integer and also return the digital root.

• Digital root is the recursive sum of all digits in a number until a single digit is obtained.
• Additive persistence is the number of times you need to sum the digits to reach a single digit.

My solution

Starting this week, I'm going to turn off VS Code Copilot when completing the challenge. As AI takes over the task of code completion, it's still a good exercise to do things by hand so as I don't depend on it.

For this tasks, I create two variables. The first is called persistence and starts at 0. The second variable is called digital_root and starts with the supplied integer. This is called number in Python, as int is a reserved word.

I then have a loop that continues until digital_root is a single digit. Breaking down the line:

• str(digital_root) will convert the digital_root integer to a string
• d for d in will convert each character to a single digit
• map(int(... will convert the digit back to an integer
• sum(... will add the single digit

I also increment the persistence value by one. I end by returning the two values. The main function is responsible for displaying the text as per the examples.

def get_digital_root(number: int) -> tuple[int, int]:
    if number <= 0:
        raise ValueError("You must provide a positive integer")

    persistence = 0
    digital_root = number

    while len(str(digital_root)) > 1:
        digital_root = sum(map(int, (d for d in str(digital_root))))
        persistence += 1

    return persistence, digital_root

The Perl solution follows the same logic. Perl doesn't make a distinction between string and integers (yes, there are some exceptions to this rule), but does require the split function to break the digital_root value into individual digits.

use List::Util 'sum';

sub main ($int) {
    my $persistence  = 0;
    my $digital_root = $int;

    # Keep iterating until we have a single digital
    while ( length($digital_root) > 1 ) {
        $digital_root = sum( split( //, $digital_root ) );
        $persistence++;
    }

    say "Persistence  = $persistence";
    say "Digital Root = $digital_root";

Examples

$ ./ch-1.py 38
Persistence  = 2
Digital Root = 2

$ ./ch-1.py 7
Persistence  = 0
Digital Root = 7

$ ./ch-1.py 999
Persistence  = 2
Digital Root = 9

$ ./ch-1.py 1999999999
Persistence  = 3
Digital Root = 1

$ ./ch-1.py 101010
Persistence  = 1
Digital Root = 3

Task 2: String Reduction

Task

You are given a word containing only alphabets.

Write a function that repeatedly removes adjacent duplicate characters from a string until no adjacent duplicates remain and return the final word.

My solution

This is a duplicate (albeit slightly re-worded) of the first task in week 340. Therefore I copy and pasted that code, and renamed the function. See my original blog post on how this was solved.

Examples

$ ./ch-2.py aabbccdd
""

$ ./ch-2.py abccba
""

$ ./ch-2.py abcdef
"abcdef"

$ ./ch-2.py aabbaeaccdd
"aea"

$ ./ch-2.py mississippi
"m"

Originally published at Perl Weekly 758

Hi there,

The upcoming Perl Toolchain Summit (PTS) in Vienna is more than just a conference, it's an important event at which to maintain, discuss, and improve on the CPAN toolchain, which is the fundamental foundation of the Perl ecosystem. Through their commitment to volunteerism, the volunteers who attend this gathering can provide significant amounts of personal time and expertise towards supporting the efforts of others in the Perl community, benefiting every single person and company that utilises Perl.

A recent article by Philippe Bruhat reports on the true cost associated with collaborating to support the PTS. The article provides a new paradigm for companies wanting to provide sponsorship for their employees who will be attending on paid time: consider "paying it forward". Estimate the cost of your employee's participation and provide that amount to the PTS in the form of a monetary sponsorship. By doing this simple action of doubling your company's investment, your company will directly provide the funding for another deserving attendee of the PTS to benefit as well, thus increasing the overall impact of the PTS.

This proposed model transforms how a company supports the employee(s) attending, creating a ripple effect through the Perl community by providing additional funding to support a more diverse, larger pool of contributors, which will serve to support the continued viability and innovation of the tools that are relied upon by everyone within the community, regardless of whether or not they attend the PTS.

This isn't simply charity, it's a wise business strategy for investing in the foundation of the Perl community. Through "pay it forward" sponsorship opportunities, companies have access to those developing the guidelines for developing and supporting the future of Perl. This creates visibility for them as true community supporters while helping the PTS remain the innovative, viable engine that brings Perl into a current competitive position. Let's continue to support all those that also support us.

Last year, I was lucky enough to attend the event as I received a surprise invitation by the organisers. From this experience, I can say it was the best of all Perl events I have been to. Contributing in any small way was a great feeling and made it worthwhile. One of the highlights was observing how committed all the top individuals in the Perl community were. They worked together on multiple projects simultaneously, with maximum efficiency, to achieve all that they could during the event.

Keep your spirits up and stay healthy. Enjoy rest of the newsletter.

--
Your editor: Mohammad Sajid Anwar.

Announcements

Sydney February Meeting! 2025

Sydney Perl continues regular meetings with our next in February

This week in PSC (213) | 2026-01-26

Perl Steering Council, discussing topics like improvements to Perl's random number generator and integrating TLS functionality into the core.

A new sponsorship model

A new sponsorship model for the 2026 Perl Toolchain Summit. It encourages employers sending staff to the event to "pay it forward" by also providing monetary sponsorship to help cover costs for other attendees.

ANNOUNCE: Perl.Wiki V 1.39 & Mojolicious.Wiki V 1.13

Articles

What I learned from being an editor/reviewer for the 2025 Perl Advent Calendar

Marc contemplates on having a wonderful experience reviewing for the Perl Advent Calendar 2025. He noted that through writing and editing articles about other peoples' articles and writing with CPAN, he learned about many new things (CPAN modules) as well as found renewed interest in various community activities such as The Weekly Perl Challenge.

Lock and unlock hash using Hash::Util

The post demonstrates how to use the Hash::Util module's lock_hash function in Perl to prevent accidental modifications to a hash, protecting it from changes, deletions, or new key additions. By unlocking the hash with unlock_hash, the program regains the ability to modify its structure, which is shown with practical code examples.

Podlite comes to Perl: a lightweight block-based markup language for everyday use

The article introduces Podlite, a new lightweight, block-based markup language that brings the readability and structure of Raku's documentation format (Pod) to the Perl ecosystem. It highlights how Podlite offers three interchangeable block styles for writing documentation within Perl code and announces its arrival via a CPAN module, positioning it as a modern tool for everyday use.

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

Welcome to a new week with a couple of fun tasks "Digital Root" and "String Reduction". 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 - 358

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

/Stringed Max

In addition to providing an intuitive method of handling both numeric and non-numeric strings, this solution illustrates Raku's syntax for implementing pattern matching and type-converting through the use of cleanly written code.

Perl Weekly Challenge: Week 358

Jaldhar is using both Raku and Perl versions in order to demonstrate an accurate solution and make the language-specific optimizations (e.g., using map and the modulo operator) obvious by showing how he was able to arrive at a practical solution in one line of code.

Maximum Encryption

An in-depth study of technical solutions where unique implementations are provided for both Perl as well as J. Jorg used sophisticated methods, such as the String::Compile::Tr module, to translate from one programming language to another at runtime and explores more unusual 'under' conjunctions in J.

using brute force!

Explicitly calling methods such as "brute force", Luca particularly favours a try-catch approach (as in Java and Python) for converting strings into integers. This method is an interesting and practical alternative to the regular expression check that most people use.

Perl Weekly Challenge 358

This blog post offers a concise and efficient one-liner approach to both tasks of Weekly Challenge 358, with a particular focus on Perl's command-line capabilities.

nbyqyyefswbuffyhay

Matthias Muth's solutions are exemplary for their elegant use of Perl's functional features and their practical robustness. They achieve maximum effect with minimal code, a hallmark of expert Perl programming.

It’s What You Value

This solution from Packy is both distinctive and highly educational. It provides a fantastic comparative study across four languages (Raku, Perl, Python, and Elixir), showcasing how to solve the same problems with each language's unique idioms and strengths. The author's thoughtful explanations make it a great learning resource.

A number of strings

This approach places emphasis on clarity, detail, and practical (real-life) use of the code to solve the problem at hand as opposed to using clever short phrases (i.e., making it well-engineered). An example of properly designed, production focused,

The Weekly Challenge #358

Robbie Hatley's Perl provided an easy to follow solution which employed procedural programming techniques for the two tasks. The approach is reasonable and aligns closely with the specifications given in the problem statement.

Encrypted Max

The practical programming method and mathematically careful design are what makes this solution stand out. It puts its emphasis on correctness and safety and places particular emphasis on how the modulo function and character encodings are handled; therefore, it is a well-thought-out and robust implementation.

Maximum Encryption

Simon Green's solutions stand out for their practical efficiency, clear idiomatic code, and a smart pre-computation strategy that differentiates them from the more common inline calculation methods.

When Strings Become Numbers and Letters Start Shifting

The main factor separating this solution from others is its pedagogical quality, not the code itself. The explanation of how the algorithms (digit validation, ASCII rotation) work is clear, and demonstrates Perl's suitability for these types of tasks. Additionally, this solution emphasizes the importance of writing testable code, which provides valuable insight.

Rakudo

2026.04 Hello, Goodbye

Weekly collections

NICEPERL's lists

Great CPAN modules released last week.

The corner of Gabor

A couple of entries sneaked in by Gabor.

Add META data, .gitignore and GitHub Actions to Common::CodingTools

This is the video recording from December 2025. It includes some explanation on how to find a Perl module to contribute to and we also make some small contributions. For similar events check out the OSDC Perl page.

Perl-related GitHub organizations

There are now some 40 organization listed, thanks in no small part to the people in the Perl community who suggested them.

WhatsApp

Join the Perl Maven chat group on WhatsApp!

Telegram

Join the Perl Maven chat group on Telegram!

Events

Perl Maven online: Code-reading and Open Source contribution

February 10, 2025

Boston.pm - online

February 10, 2025

Paris.pm monthly meeting

February 11, 2025

Paris.pm monthly meeting

March 11, 2025

German Perl/Raku Workshop 2026 in Berlin

March 16-18, 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.

One of the things I enjoy about the Weekly Perl Challenge (WPC) is how small problems often hide neat programming ideas.
This week, I solved two challenges that look simple at first glance but beautifully showcase Perl’s strengths in:

• String handling
• Regex usage
• Numeric/string duality
• ASCII manipulation
• Writing clean, testable code

Let’s walk through both problems and the approach I used.

Challenge 1 — When Strings Become Numbers

Problem
You are given a list of strings. For each string:

• If it contains only digits, treat it as a number
• Otherwise, treat its length as its value From these values, return the maximum.

Example

Key Observation
The heart of the problem is deciding:

“Is this string purely numeric, or not?”
Perl makes this very easy with a simple regex.

Solution

use List::Util qw(max);

sub get_value {
    my $str = shift;

    return length($str) unless $str =~ /^\d+$/;
    return 0 + $str;
}

A tiny function does all the work:

• ^\d+$ → checks if the string is fully numeric
• length($str) → used when it’s not
• 0 + $str → converts "0012" into number 12 Then finding the maximum is trivial with map and max:

my $max = max(map { get_value($_) } @strings);

This is where Perl shines — very little code, very clear intent.

Challenge 2 — Caesar Cipher (Letter Shifting)

Problem
Implement a Caesar Cipher:

• Shift every lowercase letter by N
• Wrap around from z to a
• Leave other characters unchanged

Key Observation
This problem is a perfect use case for ASCII arithmetic.
Instead of thinking in terms of alphabets, think in numbers from 0 to 25.

sub caesar_encrypt {
    my ($str, $int) = @_;
    $int %= 26;

    my $result = '';
    for my $char (split //, $str) {
        if ($char =~ /[a-z]/) {
            $result .= chr(
                (ord($char) - ord('a') + $int) % 26 + ord('a')
            );
        } else {
            $result .= $char;
        }
    }
    return $result;
}

This one line does the magic:

chr((ord($char) - ord('a') + $int) % 26 + ord('a'))

Steps:

1. Convert letter → ASCII (ord)
2. Normalize to 0–25 range
3. Add the shift
4. Use modulo to wrap around
5. Convert back to character (chr)
6. No lookup tables. No special cases. Just math.

Testing the Solutions
For both challenges, I wrote small test cases and printed PASS/FAIL results.
This is a habit I’ve picked up from solving WPC regularly — even small scripts deserve tests.

Why I Loved These Challenges
These problems highlight why Perl is still a joy for problem solving:

• Regex makes validation trivial
• Numeric and string contexts work naturally
• Character manipulation is straightforward
• Functional tools like map make code concise
• Very expressive in very few lines

Final Thoughts
At first glance, these look like beginner problems.
But they actually touch on important concepts:

• Data interpretation
• Input validation
• ASCII math
• Writing minimal, readable logic And Perl handles all of this elegantly.

That’s what makes the Weekly Perl Challenge so enjoyable — small puzzles, big learning.

Back in 2024 I took the plunge, and submitted my first ever contribution to that year's "Perl Advent Calendar." For the past few years this has been organized/coordinated by a member of the Toronto Perl Mongers (TPM), Olaf Alders. I wrote about a solution to a challenge I had encountered at my work, and presented it as a great (simple) application of the Perl programming language. But to be honest, I believe any popular scripting language could probably have been used. I was originally a biochemist, carrying out biomedical research in a wet lab, but since retraining as a bioinformatician in 2008, Perl has almost always been the first tool that I reach for when tackling something new. The post dealt with creating phylogenetic trees for Respiratory Syncytial Virus (RSV) sequences from patients.

For the 2025 Calendar I had a couple of ideas percolating, but never found the wherewithal or gumption to actually create a new blog post. Instead, I volunteered to be a reviewer for submissions (Olaf had mentioned he could use some extra hands). Mind you, I had almost no idea what would be involved, but I figured I could teach myself.

As you may know, Advent lasts 24 days (perhaps you have enjoyed a conventional, chocolate Advent calendar in the past?) As it turned out, I think I reviewed five articles. In each case I had to teach myself about a CPAN module that the author was writing about. In all of these drafts the subject matter was outside my area of expertise, and also, outside my "comfort zone." In fact, as I mentioned to Olaf, as a sometime reader of articles and posts about Perl, I very likely would have skipped over these same blog posts. Perhaps, if I recognized the author as a prolific and popular Perl author (a celebrity), I might've thought, "I really should come back and read this over if so-and-so is writing about it . . .".

However, as I dove deep into the subject matter, read up on the relevant Perl modules, and learned about the specific "itch" that the code "scratched," I realized that it was like a mini-tutorial on something interesting, and important, that was expanding my horizons (always fun). It was very stimulating (for me), and time well spent (YMMV). In the past I have taught Scientific Writing courses for both undergrads and graduate students, but in most cases I provided very little feedback about the main content, and similarly very little feedback about the code itself. My main goal was to see if I could understand the gist of the post, and then see if I could get their code examples to run as advertised. In some cases this required installing a new Perl module (and all of its dependencies), and in other cases I also needed to install a non-Perl App, etc. These were all good things, AND revealed that I had inadvertently created a so-called "mixed" installation of different Perl versions on my MacBook Pro. Fortunately, my newfound friend, Claude AI, came to the rescue and helped me to diagnose, clear up, and clean up such glitches.

To summarize, I look forward to being an editor (reviewer) for future Perl Advent Calendars (if needed). Since helping with the 2025 Calendar, I suddenly renewed my interest in participating in "The Perl Weekly Challenge", another fun community coding activity. So from my perspective, agreeing to write that first blog post back in 2024 was basically the "gateway drug" that opened the door to learning more Perl-ish things.

A Perl transpiler that converts Jinja2 templates to Template Toolkit 2 (TT2) syntax.

Source: https://github.com/lucianofedericopereira/jinja2tt2

Description

Jinja2 is deeply integrated with Python, making a direct port impractical. However, since TT2 and Jinja2 share similar concepts and syntax patterns, this transpiler performs a mechanical translation between the two template languages.

Why TT2?

TT2 and Jinja2 share:

• Variable interpolation: {{ var }} maps to [% var %]
• Control structures: {% if %} / {% for %} map to [% IF %] / [% FOREACH %]
• Filters: {{ name|upper }} maps to [% name | upper %]
• Includes, blocks, and inheritance (conceptually similar)
• Expression grammar close enough to map mechanically

Installation

No external dependencies beyond core Perl 5.20+.

git clone https://github.com/lucianofedericopereira/jinja2tt2
cd jinja2tt2

Usage

Command Line

# Transpile a file to stdout
./bin/jinja2tt2 template.j2

# Transpile with output to file
./bin/jinja2tt2 template.j2 -o template.tt

# Transpile in-place (creates .tt file)
./bin/jinja2tt2 -i template.j2

# From stdin
echo '{{ name|upper }}' | ./bin/jinja2tt2

# Debug mode (shows tokens and AST)
./bin/jinja2tt2 --debug template.j2

Programmatic Usage

use Jinja2::TT2;

my $transpiler = Jinja2::TT2->new();

# From string
my $tt2 = $transpiler->transpile('{{ user.name|upper }}');
# Result: [% user.name.upper %]

# From file
my $tt2 = $transpiler->transpile_file('template.j2');

Supported Constructs

Variables

{{ foo }}           →  [% foo %]
{{ user.name }}     →  [% user.name %]
{{ items[0] }}      →  [% items.0 %]

Filters

{{ name|upper }}              →  [% name.upper %]
{{ name|lower|trim }}         →  [% name.lower.trim %]
{{ items|join(", ") }}        →  [% items.join(', ') %]
{{ name|default("Guest") }}   →  [% (name || 'Guest') %]

Conditionals

{% if user %}          →  [% IF user %]
{% elif admin %}       →  [% ELSIF admin %]
{% else %}             →  [% ELSE %]
{% endif %}            →  [% END %]

Loops

{% for item in items %}    →  [% FOREACH item IN items %]
{{ loop.index }}           →  [% loop.count %]
{{ loop.first }}           →  [% loop.first %]
{{ loop.last }}            →  [% loop.last %]
{% endfor %}               →  [% END %]

Blocks and Macros

{% block content %}        →  [% BLOCK content %]
{% endblock %}             →  [% END %]

{% macro btn(text) %}      →  [% MACRO btn(text) BLOCK %]
{% endmacro %}             →  [% END %]

Comments

{# This is a comment #}    →  [%# This is a comment %]

Whitespace Control

{{- name -}}               →  [%- name -%]
{%- if x -%}               →  [%- IF x -%]

Other Constructs

• {% include "file.html" %} → [% INCLUDE file.html %]
• {% set x = 42 %} → [% x = 42 %]
• Ternary: {{ x if cond else y }} → [% (cond ? x : y) %]
• Boolean literals: true/false → 1/0

Filter Mapping

Some filters require TT2 plugins (e.g., tojson needs Template::Plugin::JSON).

Loop Variable Mapping

Limitations

• Template inheritance ({% extends %}) requires manual adjustment for TT2's WRAPPER pattern
• Autoescape is not directly supported in TT2
• Some filters need custom TT2 plugins or vmethods
• Complex Python expressions may need review

Running Tests

prove -l t/

Architecture

1. Tokenizer: Splits Jinja2 source into tokens (text, variables, statements, comments)
2. Parser: Builds an Abstract Syntax Tree (AST) from the token stream
3. Emitter: Walks the AST and generates equivalent TT2 code

Credits

• Luciano Federico Pereira - Author

License

This is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License (LGPL) version 2.1 as published by the Free Software Foundation.