Weekly Challenge 340

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: Duplicate Removals

Task

You are given a string, $str, consisting of lowercase English letters.

Write a script to return the final string after all duplicate removals have been made. Repeat duplicate removals on the given string until we no longer can.

A duplicate removal consists of choosing two adjacent and equal letters and removing them.

My solution

Thanks to regular expressions this is relatively straight forward. We can use the expression (.)\1 to get two of the same character. . will match any single letter, () will capture it, and \1 will use the capture.

For the Python solution, I run the regexp on the input_string and store it in a variable called new_string. If it is the same, I return it. If it is different (because we removed two characters), I reset input_string and call the loop again.

def duplicate_removals(input_string: str) -> str:
    while True:
        new_string = re.sub(r'(.)\1', '', input_string)
        if new_string == input_string:
            return new_string
        input_string = new_string

In Perl, calling the s function returns the number of substitutions made. Therefore the Perl solution uses this feature rather than using the new_string variable. The loop will exit when no substitutions are made.

sub main ($input_string) {
    my $changes = 1;
    while ($changes) {
        $changes = ($input_string =~ s/(.)\1+//g);
    }

    say "'$input_string'";
}

Examples

$ ./ch-1.py abbaca
'ca'

$ ./ch-1.py azxxzy
'ay'

$ ./ch-1.py aaaaaaaa
''

$ ./ch-1.py aabccba
'a'

$ ./ch-1.py abcddcba
''

Task 2: Ascending Numbers

Task

You are given a string, $str, is a list of tokens separated by a single space. Every token is either a positive number consisting of digits 0-9 with no leading zeros, or a word consisting of lowercase English letters.

Write a script to check if all the numbers in the given string are strictly increasing from left to right.

My solution

The first thing I do is extract the numbers from input_string (str is a reserved word in Python). For this I use list comprehension, along with a regular expression to return words that contain digits only.

def ascending_numbers(input_string: str) -> bool:
    number_list = [int(n) for n in input_string.split() if re.match(r'^\d+$', n)]

Perl doesn't have list comprehension, but the same functionality can be achieved by using the grep function.

sub main ($input_string) {
    my @number_array = grep { /^\d+$/ } split /\s+/, $input_string;

It's then a matter of checking that the list (array in Perl) is sorted correctly. For this I have a loop with the variable i. It starts at 1, to one less than the length of the number_list list. For each iteration, I check that the number at the position i-1 is less than the number at position i. If it isn't, I return False. If the loop is exhausted, I return True.

    for i in range(1, len(number_list)):
        if number_list[i-1] >= number_list[i]:
            return False

    return True

The Perl code follows a similar pattern.

    foreach my $i ( 1 .. $#number_array ) {
        if ( $number_array[ $i - 1 ] >= $number_array[$i] ) {
            say "false";
            return;
        }
    }
    say "true";

Examples

$ ./ch-2.py "The cat has 3 kittens 7 toys 10 beds"
True

$ ./ch-2.py 'Alice bought 5 apples 2 oranges 9 bananas'
False

$ ./ch-2.py 'I ran 1 mile 2 days 3 weeks 4 months'
True

$ ./ch-2.py 'Bob has 10 cars 10 bikes'
False

$ ./ch-2.py 'Zero is 0 one is 1 two is 2'
True

TL;DR

I built a dynamic, context-aware workspace loader for i3wm that allows me to switch between workspace groups (such as "Client" and "Personal") without losing state. It autoloads layouts and launches apps on demand. It's built with Perl, AnyEvent::I3, and YAML config. It utilizes IPC events to detect state changes and trigger actions.

Workspaces on Demand

I have been using i3 as a Window Manager for years now. And while I love working with i3, there is one thing I found annoying. And that is that it lacks context awareness. What do I mean by this? I use it in several contexts: "Client", "Company", and "Personal". Meaning, I'm in either client mode, company mode or personal mode. And 'client mode' can mean working with one or multiple clients at once. I pitched my initial idea on i3's discussion pages and someone else asked about something similar as KDE's "Activities".

Not enough workspaces == mental overload

With i3 you can create a ton of workspaces, but I found myself often using workspaces 1-3, and 8-0. These are only 6 workspaces, that are directly accessible. In most contexts I want to have three workspaces: "debug", "cli", and "misc". If we have three contexts we use 1-3, 4-6, and 7-9 plus workspace 0 as my safe haven. And I use 0 for things I want to super-quick access to regardless of context.
But what if we add a new client, or we want to have different workspaces for "personal" contexts? I didn't want to remember in which context I was, I just wanted to remember, 1-3 are where I code, 0 is where my safe haven is and everything else is just hidden from sight.

Proof of concept: zsh and jq

I needed something that could deal with these contexts while preserving state of other contexts already in use. I started out with a simple zsh script but I quickly ran into some issues where the shell wasn't really the right tool for the job. I have a love/hate relationship with jq. I love it for quick things, but I hate it for more complex things. I always forget the syntax and with Perl (or any other programming language) I can just work with the data structure.

I also looked into IPC events from i3 — you use them with i3-msg already. Now I wanted to know how I could hook into events from i3 to determine state changes. And I could.
I3 also ships a Perl module AnyEvent::I3. Big hat tip to the i3-developers.

AnyEvent::I3X::Workspace::OnDemand

First I started out with a simple subscribe method that checked for the init event to ensure I was able to see the creation of a workspace. It's important to note that while you define a workspace in i3's config, it doesn't actually create them. It is created run time when you request it.

On init things are rather simple, we append the layout using append_layout and we start up all the applications we want to use. To support this I created a couple of things:

• A constructor param that has a layout path defined. So all your layouts are stored there.
• A constructor param that has workspaces defined.
• A constructor param that defines which applications are started.
• And a constructor param that defines which groups are used.

How does this work? You configure your workspaces, groups and applications like so:

use AnyEvent::I3X::Workspace::OnDemand;
my $i3 = AnyEvent::I3X::Workspace::OnDemand->new(
    debug => 0,
    layout_path => "$ENV{HOME}/.config/i3",
    workspaces => {
        foo => {
            layout => 'foo.json',
        },
        bar => {
            layout => 'bar.json',
            groups => {
                foo => undef,
                # Override the layout for group bar
                bar => { layout => 'foo.json' },
            }
        },
        baz => {
            layout => 'baz.json',
            groups => {
                all => undef,
            }
        }
    },
    groups => [
        qw(foo bar baz)
    ],
    swallows => [
        {
            cmd => 'kitty',
            match => {
                class => '^kitty$',
            }
        },
        {
            # Start firefox on group bar
            cmd => 'firefox',
            on => {
                group => 'bar',
            }
            match => {
                window_role => '^browser$',
            }
        },
        {
            cmd => 'google-chrome',
            on => {
                group => 'foo',
            }
            match => {
                window_role => '^browser$',
            }
        }
    ],
);

Bulletproofing edge cases

Now, because of timing issues you can end up with a workspace that has a layout defined but nothing has started yet. So we also look for the focus event and here we also try to start the applications defined on the workspace.

When the user switches to a workspace, we walk the i3 tree to find any nodes that match our layout, and we spawn the apps that belong there — only if they aren’t already running.

Sending events ourselves to ourselves

So now that we have this logic defined we can go into changing groups. Group changes are sent via ticks:

i3-msg -t send_tick group:personal

This means our workspace logic needs to listen to tick events too. This meant that I needed to support multiple event types.

Supported event types

The module supports the following event types: workspace, barconfig_update (caveat emptor), tick, shutdown, output, mode, window, and binding. The most important ones for us are: workspace, tick, and shutdown. These have simple helper functions on_workspace, on_tick and on_shutdown:

$self->on_workspace($name, $type, $sub)

Subscribe to a workspace event for workspace $name of $type with $sub.

$type can be any of the following events from i3 plus any or *

$i3->on_workspace(
  'www', 'init',
  sub {
    my $self  = shift;
    my $i3    = shift;
    my $event = shift;
    $self->append_layout($event->{current}{name}, '/path/to/layout.json');
  }
);

$self->on_tick($payload, $sub)

Subscribe to a tick event with $payload and perform the action. Your sub needs to support the following prototype:

sub foo($self, $i3, $event) {
    print "Yay processed foo tick";
}
$self->on_tick('foo', \&foo)


On shutdown isn't really documented on CPAN just yet, but its rather simple:

$i3->on_shutdown(exit => sub { exit 0 });
$i3->on_shutdown(restart => sub { exit 0 });

Configuring i3

So now the only thing you need to do in your i3 config is configure them. I personally use the binding modes from i3 to organize similar commands into one grouping:

# Dynamic workspaces
bindsym $mod+w mode "Activities"
mode "Activities" {
  bindsym 0 exec i3-msg -t send_tick group:foo; mode default
  bindsym 9 exec i3-msg -t send_tick group:bar; mode default
  bindsym 8 exec i3-msg -t send_tick group:baz; mode default
  bindsym Return mode "default"
  bindsym Escape mode "default"
}

Now I can switch between almost unlimited contexts. I only use three, but you can go wild.

Layout saving and restoring

And for those who want to know how to create a layout:

i3-save-tree --workspace foo > ~/.config/i3/foo.json

You'll need to edit the JSON, eg, trim the swallow block, but I'll leave that to you and the documentation found on the i3 site.

Version 0.005

In the newest version of the module you'll be able to find the workspace on demand daemon called i3-wod. The module also ships a user guide for easier adaptation and config examples for the YAML config file used by i3-wod.

exec_always --no-startup-id "i3-wod &"

You can install the module by running:

cpanm AnyEvent::I3X::Workspace::OnDemand

AnyEvent::I3X::Workspace::OnDemand as found on MetaCPAN

A few of my recent projects—like Cooking Vinyl Compilations and ReadABooker—aim to earn a little money via affiliate links. That only works if people actually find the pages, share them, and get decent previews in social apps. In other words: the boring, fragile glue of SEO and social meta tags matters.

As I lined up a couple more sites in the same vein, I noticed I was writing very similar code again and again: take an object with title, url, image, description, and spray out the right <meta> tags for Google, Twitter, Facebook, iMessage, Slack, and so on. It’s fiddly, easy to get 80% right, and annoying to maintain across projects. So I pulled it into a small Moo role—MooX::Role::SEOTags—that any page-ish class can consume and just emit the right tags.

What are these tags and why should you care?

When someone shares your page, platforms read a handful of standardised tags to decide what to show in the preview:

• Open Graph (og:*) — The de-facto standard for title, description, URL, image, and type. Used by Facebook, WhatsApp, Slack, iMessage and others.
• Twitter Cards (twitter:*) — Similar idea for Twitter/X; the common pattern is twitter:card=summary_large_image plus title/description/image.
• Classic SEO tags — <title>, <meta name="description">, and a canonical URL tell search engines what the page is about and which URL is the “official” one.

MooX::Role::SEOTags gives you one method that renders all of that, consistently, from your object’s attributes.

For more information about OpenGraph, see ogp.me.

What it does

MooX::Role::SEOTags adds a handful of attributes and helper methods so any Moo (or Moose) class can declare the bits of information that power social previews and search snippets, then render them as HTML.

• Open Graph tags (og:title, og:type, og:url, og:image, etc.)
• Twitter Card tags (twitter:card, twitter:title, twitter:description, twitter:image)
• Standard SEO: <title>, meta description, canonical <link rel="canonical">
• A single method to render the whole block with one call
• But also individual methods to give you more control over tag placement

That’s the whole job: define attributes → get valid tags out.

Quick start

Install the role using your favourite CPAN module installation tool.

cpanm MooX::Role::SEOTags

Then, in your code, you will need to add some attributes or methods that define the pieces of information the role needs. The role requires four pieces of information – og_title, og_description, og_url and og_type – and og_image is optional (but highly recommended).

So a simple class might look like this:

package MyPage;
use Moo;
with 'MooX::Role::SEOTags';

# minimal OG fields
has og_title => (is => 'ro', required => 1);
has og_type => (is => 'ro', required => 1); # e.g. 'article'
has og_url => (is => 'ro', required => 1);
has og_description => (is => 'ro');

# optional niceties
has og_image => (is => 'ro'); # absolute URL
has twitter_card => (is => 'ro', default => sub { 'summary_large_image' });

1;

And then you create the object:

my $page = MyPage->new(
  og_title => 'How to Title a Title',
  og_type => 'article',
  og_url => 'https://example.com/post/title',
  og_image => 'https://example.com/img/hero.jpg',
  og_description => 'A short, human description of the page.',
);

Then you can call the various *_tag and *_tags methods to get the correct HTML for the various tags.

The easiest option is to just produce all of the tags in one go:

say $page->tags;

But, for more control, you can call individual methods:

say $page->title_tag;
say $page->canonical_tag;
say $page->og_tags;
# etc...

Depending on which combination of method calls you use, the output will look something like this:

<title>How to Title a Title</title>
<meta name="description" content="A short, human description of the page.">
<link rel="canonical" href="https://example.com/post/title">

<meta property="og:title" content="How to Title a Title">
<meta property="og:type" content="article">
<meta property="og:url" content="https://example.com/post/title">
<meta property="og:image" content="https://example.com/img/hero.jpg">

<meta name="twitter:card" content="summary_large_image">
<meta name="twitter:title" content="How to Title a Title">
<meta name="twitter:description" content="A short, human description of the page.">
<meta name="twitter:image" content="https://example.com/img/hero.jpg">

In many cases, you’ll be pulling the data from a database and displaying the output using a templating system like the Template Toolkit.

my $tt = Template->new;

my $object = $resultset->find({ slug => $some_slug });

$tt->process('page.tt', { object => $object }, "$some_slug/index.html");

In this case, you’d just add a single call to the

<head>

  <!-- lots of other HTML -->

[% object.tags %]

</head>

A note if you used my earlier Open Graph role

If you spotted MooX::Role::OpenGraph arrive on MetaCPAN recently: SEOTags is the “grown-up” superset. It does Open Graph and Twitter and standard tags, so you only need one role. The old module is scheduled for deletion from MetaCPAN.

SEO tags and JSON-LD

These tags are only one item in the SEO toolkit that you’d use to increase the visibility of your website. Another useful tool is JSON-LD – which allows you to add a machine-readable description of the information that your page contains. Google loves JSON-LD. And it just happens that I have another Moo role called MooX::Role::JSON_LD which makes it easy to add that to your page too. I wrote a blog post about using that earlier this year.

In conclusion

If you’ve got even one page that deserves to look smarter in search and social previews, now’s the moment. Pick a page, add a title, description, canonical URL and a decent image, and let MooX::Role::SEOTags spit out the right tags every time (and, if you fancy richer results, pair it with MooX::Role::JSON_LD). Share the link in Slack/WhatsApp/Twitter to preview it, fix anything that looks off, and ship. It’s a 20-minute tidy-up that can lift click-throughs for years—so go on, give one of your pages a quick SEO spruce-up today.

The post Easy SEO for lazy programmers first appeared on Perl Hacks.

Originally published at Perl Weekly 739

Hi there!

I used Perl Dancer for many projects, I wrote about it a lot, I even wrote a book about it, so I am quite glad that a new major version was released. Thanks to all the contributors, including Jason A. Crome, Mikko Koivunalho, Yanick Champoux, Karen Etheridge, Sawyer X!

Enjoy your week!

Happy and peacefull New Year to all our Jewish readers, Shana Tova!

--
Your editor: Gabor Szabo.

Announcements

Geizhals Preisvergleich Donates USD 10,000 to The Perl and Raku Foundation

Toronto Perl Mongers Lightning Talks Needs You

The annual Toronto Perl Mongers lightning talks will be held (virtually) this Thursday. (ps. It is also listed among all the other events at the bottomg of the newsletter.)

Announcing Dancer2 2.0.0

New major release!

Articles

Released an Inertia.js Adapter for Mojolicious

Discussion

Perl in a Monorepo

A monorepo is a software-development strategy in which the code for a number of projects is stored in the same repository. Dean is interested in hearing about tools and approaches that have been used with Perl.

confusing failed short-circuit

Have I already mentioned one my many pet peeves, that I recommend never to use $a and $b outside of sort. Not even in small examples.

How to make compilation work in Windows?

The Cache Crash

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

Welcome to a new week with a couple of fun tasks "Duplicate Removals" and "Ascending Numbers". 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 - 339

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

TWC339

The approaches for both tasks are correct under the assumptions and seem efficient for modest array sizes. The tasks are simple but the solutions are concise and cover many relevant kinds of inputs in the examples.

Diff Peak

The solutions are clear, correct and concise, making good use of Raku’s features. They’re well illustrated with examples, easy to follow and demonstrate a solid understanding of the problem.

Sorting for the win

The solution is much more efficient than brute force and strikes a good balance between simplicity and performance. It uses sound reasoning (extremes drive large products), handles special cases (negatives, zeros) and significantly improves scalability.

Perl Weekly Challenge 339

This is an excellent blog post featuring top-tier solutions. It demonstrates a deep understanding of the problems and chooses the most efficient algorithms possible. The code is not just correct but is also elegant and a pleasure to read. The solutions for both tasks are production-ready and would scale efficiently to large inputs.

Max Complication for Min Brute Force

These solutions are clear, correct and efficient. Max Diff avoids brute force by systematically covering all sign combinations, reducing the problem to a handful of candidate checks after sorting—showing solid algorithmic reasoning and thorough testing. Peak Point is expressed elegantly in a single line, making excellent use of Perl’s expressive features while remaining efficient. Together, the two tasks balance rigor and readability, demonstrating both deep problem understanding and concise, idiomatic coding style.

Points? What’s the diff?

This is an excellent, well-written technical blog post. It successfully transforms a seemingly mundane task—calculating a leaderboard diff—into an engaging narrative that showcases the power and elegance of modern Perl. The post is technically sound, pedagogically effective and demonstrates a strong software engineering mindset. It's a perfect example of how to write about code: it explains the why, not just the how.

Pair products, peak points

Solutions are technically correct, robust and well-engineered. They exemplify a pragmatic approach to problem-solving: prioritizing clarity and guaranteed correctness over premature optimization. The code is modern, idiomatic Perl and is a pleasure to read.

The Weekly Challenge #339

Solutions are technically correct and functionally complete, successfully solving both challenges. The code is structured, well-documented and demonstrates a solid understanding of the problem requirements. However, the approach to Task 1 raises significant concerns regarding efficiency and scalability, which heavily impacts the overall assessment.

The Difference has Peaked

Solutions are solid—clear, correct, straightforward and great for demonstrating the basic logic. For tasks of modest size, they’ll work fine. For larger inputs, they’d be slower than more optimized ones. His decision to trade off some performance for clarity and ease of implementation is reasonable.

Maximum climb

The code is straightforward and easy to follow, making the logic transparent even for less experienced readers. Solutions in both Python and Perl show versatility and consistency in approach. The post acknowledges the brute force nature and performance limitations, which shows awareness of algorithmic complexity.

Week 339 - Max Diff & Peak Point

Solutions are well-structured, demonstrating a solid understanding of the tasks and Perl's capabilities. They are both elegant and efficient, providing a clear and direct answer to the problem.

Weekly collections

NICEPERL's lists

Great CPAN modules released last week;
MetaCPAN weekly report.

Events

Toronto.pm - online - Lightning Talks 2025

September 25, 2025

Annual Russian Perl Conference 2025

September 27, 2025

Boston.pm - online - (2d Tuesday)

October 14, 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.

Weekly Challenge 339

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: Max Diff

Task

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).

My solution

This task has really challenged me. I've come up with a solution that works, but am not happy with it. Mohammad praised me last week with not "just brute-forcing an answer". This week I have failed :-/

The objective is to find the pairs that represent the lowest and highest product. If I take the list -4 -10 2 0, the lowest value is -8 (-4 × 2) and the highest value is 40 (-4 × -10). However this uses the -4 value twice, and thus is not going to work. I was thinking of ways to solve this, but haven't thought of any that are good. I'm going to be interested in reading how other Team PWC members solved this.

The approach I took is to find all combinations of 4 digits from the input list. In Python, this is done with the combinations function from itertools. The Algorithm::Combinatorics module provides the same functionality in Perl.

For each combination I calculate the maximum absolute difference between the three possible combinations of pairs (1 2, 3 4; 1 3, 2 4; and 1 4, 2 3). If this is higher than any previous maximum, I update the solution variable.

def max_diff(ints: list) -> int:
    solution = 0

    # Compute all combinations of 4 integers
    for c in combinations(ints, 4):
        # Calculate the maximum difference for this combination
        diff = max(
            abs((c[0] * c[1]) - (c[2] * c[3])),
            abs((c[0] * c[2]) - (c[1] * c[3])),
            abs((c[0] * c[3]) - (c[1] * c[2])),
        )
        if diff > solution:
            solution = diff

    return solution

Maybe this is the best solution. Even with a list of 100 items, there are less than 4 million combinations, which can be computed pretty quickly.

Examples

$ ./ch-1.py 5 9 3 4 6
42

$ ./ch-1.py 1 -2 3 -4
10

$ ./ch-1.py -3 -1 -2 -4
10

$ ./ch-1.py 10 2 0 5 1
50

$ ./ch-1.py 7 8 9 10 10
44

Task 2: Peak Point

Task

You are given an array of altitude gain.

Write a script to find the peak point gained.

My solution

This is relatively straight forward so doesn't need much explanation. I have two variables current_altitude records the current altitude while the peak records the highest altitude. Both values start at 0.

I then loop over the input list with a variable gain. For each iteration, I increment the current_altitude value with gain. If this is higher than the current peak variable, I update peak with the new altitude.

Finally, I return the peak value.

def peak_point(gains: list) -> int:
    current_altitude = 0
    peak = 0

    for gain in gains:
        current_altitude += gain
        if current_altitude > peak:
            peak = current_altitude

    return peak

Examples

$ ./ch-2.py -5 1 5 -9 2
1

$ ./ch-2.py 10 10 10 25
55

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

$ ./ch-2.py -1 -2 -3 -4
0

$ ./ch-2.py -10 15 5
10