Weekly Challenge 378

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: Second Largest Digit

Task

You are given an alphanumeric string.

Write a script to find the second largest distinct digit in the given string. Return -1 if none found.

My solution

For this task I use a set called digits to store the digits found in the input_string. By using a set, duplicate digits are only counted once. If this set has at least two values (unique digits), I return the second higest number. If it is shorter, I return -1.

def second_largest_digit(input_string) -> int:
    digits = set(int(c) for c in input_string if c.isdigit())
    return sorted(digits)[-2] if len(digits) > 1 else -1

As Perl does not have sets, I use a hash to achieve the same functionality.

sub main ($input_string) {
    my %digits = ();
    for my $char ( split //, $input_string ) {
        if ( $char =~ /[0-9]/ ) {
            $digits{$char} = 1;
        }
    }

    if ( scalar( keys(%digits) ) < 2 ) {
        say -1;
    }
    else {
        my @sorted_digits = sort { $a <=> $b } keys %digits;
        say $sorted_digits[-2];
    }
}

Examples

$ ./ch-1.py aaaaa77777
-1

$ ./ch-1.py abcde
-1

$ ./ch-1.py 9zero8eight7seven9
8

$ ./ch-1.py xyz9876543210
8

$ ./ch-1.py 4abc4def2ghi8jkl2
4

Task 2: Sum of Words

Task

You are given three strings consisting of lower case English letters a to j only. The letter value of a = 0, b = 1, c = 3, etc.

Write a script to find if sum of first two strings return the third string.

My solution

For this task I have a function called words_to_number that converts a word to an integer. It also checks that the word only contains the letters a to j. The ord function gives the integer representing the Unicode code point of that character. The letter a has the integer 97, while j is 106.

def word_to_number(word: str) -> int:
    if not re.search('^[a-j]+$', word):
        raise ValueError(f"String '{word}' contains invalid characters")

    number_string = "".join(str(ord(c) - ord('a')) for c in word)
    return int(number_string)

The sum_of_words function simply checks if the math is valid.

def sum_of_words(str1, str2, str3) -> bool:
    return word_to_number(str1) + word_to_number(str2) == word_to_number(str3)

The Perl code follows the same logic.

sub word_to_number($str) {
    if ( $str !~ /^[a-j]+$/ ) {
        die "String '$str' contains invalid characters\n";
    }

    my $number_string = join( "", map { ord($_) - ord('a') } split //, $str );
    return int($number_string);
}

sub main ( $str1, $str2, $str3 ) {
    say word_to_number($str1) + word_to_number($str2) == word_to_number($str3)
      ? 'true'
      : 'false';
}

Examples

$ ./ch-2.py acb cba cdb
true

$ ./ch-2.py aab aac ad
true

$ ./ch-2.py bc je jg
false

$ ./ch-2.py a aaaa aa
true

$ ./ch-2.py c d h
false

$ ./ch-2.py gfi hbf bdhd
true

Originally published at Perl Weekly 777

Hi there!

In the recent weeks I looked at a lot of MetaCPAN profiles (aka. author pages) such as that of MANWAR. If I could also find their LinkedIn profile I invited them to connect via LinkedIn. (If I have not sent you an invitation yet, then I guess I missed your profile. I'd be glad to get a connect request via LinkedIn.)

I noticed that a large percentage of the people still have their @cpan.org email address listed. Despite the fact that cpan.org email forwarding has been shut down 6 weeks ago. That means people will get annoyed if hey try to contact you using that address.

You could replace that address or hide it and offer other ways for people to contact you. Either of them is better than having a bad address.

In addition, I noticed that some of the links people have there are not working. (e.g. incorrect link to their LinkedIn profile, or to their home page etc.)

In order to fix these you probably first need to check and update your PAUSE account. After logging in look for the Edit Account Info menu option. There you can list your email address and you can even decide if you'd like to have a visible address or not.

Then you could take a look at your MetaCPAN profile. For this visit MetaCPAN. Login in the top-right corner. If you don't remember whether you used GitHub or Google, don't worry. Inside you can connect them in the Identities menu point. Then go to the Profile menu point and update the fields there.

Finally, if you have updated your profile after reading this, I'd be glad if you sent me an email so I'll know this messaged had some positive impact.

Oh, and if you don't have a CPAN account and you have not uploaded anything yet, then what are you waiting for?

Enjoy your week!

--
Your editor: Gabor Szabo.

Articles

Time::Str - Time Zones and Leap Seconds

Time::Str parses and formats date/time strings across 20+ standard formats, with an optional C/XS backend and nanosecond precision. The previous post, Introducing Time::Str, covered parsing and formatting. This one covers two additions, time zones and leap seconds, and ends with a note on the new C parsers. (Reddit)

Discussion

Confused about a few parts of the new Core OOP

Memory sharing between scripts

First record in implicit -n loop behaves differently than the rest. Hoping to find an explanation.

Grants

PEVANS Core Perl 5: Grant Report for May 2026

Perl

This week in PSC (228) | 2026-06-08

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

Welcome to a new week with a couple of fun tasks "Second Largest Digit" and "Sum of Words". 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 - 377

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

Prefixed Existence

This article offers a great introduction to the Raku language through its implementation of the The Weekly Challenge #377, specifically the use of native Raku functions, such as .flip and .combinations. The code is well-written, typical of Raku, and fully supported with an extensive breakdown of each line of code, detailed run-time logs, and references to helpful documentation.

Perl Weekly Challenge: Week 377

The article compares Perl and Raku solutions for Week 376 of the Challenge and illustrates how the two languages are different in terms of their evolution. Specifically, it illustrates how Raku provides a more modern set of high-level features (e.g., built-in support for substrings and pairs) compared to the equivalent structural features in Perl, which require additional code to implement.

From Start to End and Back

Jorg takes a multi-paradigm approach to solving The Weekly Challenge #377 in both Perl and J (the array-processing language). This article showcases Jorg's technical knowledge because he generalises the first task from its minimum definition and well-organises the second task's input by length to optimise the process. Additionally, Jorg's complete walkthrough of the functional, tacit programming techniques found in language J is well presented, allowing for the easy comprehension of complex manipulations of Arrays and RegEx optimisations.

Perl Weekly Challenge 377

W. Luis Mochan employs the expressive capabilities of the Perl language in order to create solutions that exhibit exceptional brevity with no extra syntax or words. This will definitely capture the interest of developers looking for clean and functional solutions.

They run and hide their heads / They might as well be dead…

This post provides a great, multi-lingual breakdown of the challenge with clean idiomatic solutions in Perl, Raku, Python and Elixir. By demonstrating how each of the programming paradigms handle the same logic, Packy provides educational value beyond measure while maintaining interest with a clever Beatles-style music theme.

Strings within strings

Peter offers a refreshingly simple and useful way to accomplish this task using only Perl. He places an emphasis on keeping the code readable, ensuring UTF-8 characters can safely contain more than one byte, and maintaining a high level of performance in real-world applications. There is no ambiguity or sacrifice made in developing an easy-to-interpret solution to a hard problem and accommodating corner cases.

The Weekly Challenge - 377: Reverse Existence

In this article, Reinier discusses how to efficiently leverage Perl's string manipulation and logical checks to confirm if input strings share overlapping character sequences with the least amount of code. This article is an excellent resource for learning to write perl code that efficiently performs substring matching in a clear, idiomatic manner with minimal additional complexity.

The Weekly Challenge - 377: Prefix Suffix

Reinier made use of Perl's built-in string matching capabilities to efficiently find all pairs where one of the strings serves as both the beginning and end of one of the other strings. This showcases a great example of writing efficient, clear code to solve a complex logic problem of substring containment in as little code as possible.

A Suffix to Existence

Roger's article provides an excellent comparison between different programming languages by demonstrating how language paradigms solve the same algorithms for sliding windows and substring matches, thereby providing significant educational value to the reader by making comparisons between high-level built-in functions with manual implementations for the same problem.

Existence

In this post, Simon analysed the issue into smaller pieces/steps made it easier for implementation to remain very readable and maintainable. A strong resource for developers wishing to observe how simple, idiomatic methods can more elegantly achieve string manipulating constraints.

Weekly collections

NICEPERL's lists

Great CPAN modules released last week.

Events

Perl development using AI (online)

June 17, 2026

Berlin.pm - Naumanns Biergarten

June 24, 2026

Toronto.pm - June Social Evening

June 25, 2026

The Perl and Raku Conference 2026

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

Paris.pm monthly meeting

July 8, 2026

Purdue Perl Mongers (HackLafayette) - TBA

July 08, 2026

Boston Perl Mongers virtual monthly

July 14, 2026

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 377

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: Reverse Existence

Task

You are given a string.

Write a script to find whether any substring of length 2 is also present in the reverse of the given string.

My solution

This is relatively straight forward. I create a variable reversed_string which is the string reversed. I then have a loop called start_pos that goes from 0 to 2 less than the length of the string. At each position, I check if the two letters at that position are in the original string.

def reverse_existence(input_string: str) -> bool:
    reversed_string = input_string[::-1]
    for start_pos in range(len(input_string)-1):
        if reversed_string[start_pos:start_pos+2] in input_string:
            return True

    return False

The Perl solution follows the same logic.

sub main ($input_string) {
    my $reversed_string = reverse($input_string);
    foreach my $start_pos ( 0 .. length($input_string) - 2 ) {
        if (
            index( $input_string, substr( $reversed_string, $start_pos, 2 ) )
            != -1 )
        {
            say "true";
            return;
        }
    }

    say "false";
}

Examples

$ ./ch-1.py abcba
true

$ ./ch-1.py racecar
true

$ ./ch-1.py abcd
false

$ ./ch-1.py banana
true

$ ./ch-1.py hello
true

Task 2: Prefix Suffix

Task

You are given an array of strings.

Write a script to find if the two strings (str1, str2) in the given array such that str1 is prefix and suffix of str2. Return the total count of such pairs.

My solution

In Python, this is a one line solution. I use the combinations function from the itertools module to produce all combinations of pairs of str1 and str2. For each pair, I use the startwith and endswith function on the strings to see if the criteria is met.

def prefix_suffix(array: list[str]) -> int:
    return sum(
        1
        for str1, str2 in combinations(array, 2)
        if (str1.startswith(str2) and str1.endswith(str2)) or
           (str2.startswith(str1) and str2.endswith(str1))
    )

The Perl solution is a little more complex. I have a function called is_prefix_suffix that checks that s1 starts with an ends with s2.

sub is_prefix_suffix ( $s1, $s2 ) {
    my $l = length($s2);

    return ( substr( $s1, 0, $l ) eq $s2 and substr( $s1, 0 - $l ) eq $s2 )
      ? 1
      : 0;

}

The main function uses the combinations function from the Algorithm::Combinatorics module to generate all possible pairs. It then calls the above function on each order of the pair to see if it is true.

use Algorithm::Combinatorics 'combinations';

sub main (@array) {
    my $count = 0;

    my $iter = combinations( \@array, 2 );
    while ( my $c = $iter->next ) {
        my ( $str1, $str2 ) = @$c;
        if (   is_prefix_suffix( $str1, $str2 )
            or is_prefix_suffix( $str2, $str1 ) )
        {
            ++$count;
        }
    }

    say $count;
}

Examples

$ ./ch-2.py a aba ababa aa
4

$ ./ch-2.py pa papa ma mama
2

$ ./ch-2.py abao ab
0

$ ./ch-2.py abab abab
1

$ ./ch-2.py ab abab ababab
3

Originally published at Perl Weekly 776

Hi there,

Recently, I came across an article, The Day I Decided Never to Learn Python by Randal L. Schwartz. Well, Randal doesn't need an introduction. He took us back to 2001, the same era when I first started learning Perl in 1999. He was a major guiding force during my early programming days.

Last week, I joined a live session by Gabor focussed on FalkorDB. It was fun watching him code and talk while I sat back as a silent spectator. You can learn a lot just by watching how he approaches coding. It reminded me of many years ago when I did pair programming with him and submitted a pull request to the Dancer2 project. Those were the golden days, when I had so much energy and time. That being said, I am still actively learning Perl and discovering how to do new things with it. These concepts may not be new to everyone, but they are new to me. For example, I recently played with GraphQL for the first time, and I've also been experimenting with RAG and JSON-RPC. I have shared my recent experiments down below.

The process of learning never stops. A few days ago, I noticed an update for HTTP::Message v7.02. Since it was released by Olaf Alders, I was curious to see what had changed. It turned to be something, I hadn't realised for all these years. While I am well-acquainted with HTTP methods like GET, POST, and PUT, I didn't know "0" could actually be a valid HTTP method name if you wanted it to be. This release added support for exactly that, thanks to contributor, Karen Etheridge. Amidst all of this, I am still trying to find time for my upcoming book on DBIx::Class. I recently shared a blog post demonstrating the power of DBIC components, and I am trying my best not to lose focus.

You might find that this edition is full of my own personal posts, as there was unfortunately very little community news to report this week. Regardless, I hope you enjoy the rest of the newsletter.

--
Your editor: Mohammad Sajid Anwar.

Announcements

This week in PSC (227) | 2026-06-01

This week we were back to full strength. We have now dealt with all of the belated issues and all of the blockers. Paul will be shipping 5.43.11 very shortly. With the amount of changes we have had to merge, we will not be able to rush the .11 cycle, but we intend to start the work on the 5.44 RC early, to ensure that we can release with as little additional delay as possible.

Articles

Result Class - Components

Continue with the series post on DBIx::Class, in this post I am showing the power of DBIC components dealing with date/timestamp column.

RAG with Perl

In this post, I try to decode what RAG is and how we can implement RAG engine in Perl talking to LLM and Vector database in a docker container.

CPAN Debian Package

First time managed to build a debian package for DBIx::Class::Async with step by step instructions.

JSON-RPC with Perl

After dealing with gRPC, next in line was JSON-RPC. The motivation was to explore MCP after getting to know JSON-RPC. It turned out to be too easy demonstrate.

Mojo meets GraphQL

The post is meant for beginners as I am exploring GraphQL for the first time as well. The best part is the use of GraphiQL for building and testing the API.

DBIx::Class and GraphQL

In this post, I shared how to integrate DBIx::Class with GraphQL. Having played with GraphQL, I can say it is not for weak heart. If you are coming from REST API background then it will take some time to get your head around it. I am telling this from my personal exprience.

CPAN and GraphQL

After DBIx::Class integration with GraphQL, my immediate task was to make the process easy as it doesn't have to this complicated. In the process, I released brand new CPAN distribution: DBIx::Class::Schema::GraphQL.

CPAN

FalkorDB

Perl client module for FalkorDB. This code was mostly generated using AI tools and has not been checked manually yet.

DBIx::Class::Schema::GraphQL

It was created while working on the DBIx::Class integration with GraphQL. Using this module, it is so easy to build GraphQL API.

Grants

Maintaining Perl (Tony Cook) May 2026

Maintaining Perl 5 Core (Dave Mitchell): May 2026

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

Welcome to a new week with a couple of fun tasks "Reverse Existence" and "Prefix Suffix". 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 - 376

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

Doubled Chessboard

The post offers an orderly, aesthetically pleasing way of solving the Weekly Challenge problems using the modern-day features of Raku syntax. With the use of well-defined subset custom types to strongly validate input and a simple, tokenising object-oriented class structure for text processing, Arne creates a solution that is easy to read and maintain and takes care of the complex edge cases such as applying a look behind that crosses over multiple lines.

Doubled Words

Bob presents a creative solution to a challenging text processing issue by using a well known yet little used built-in feature of the Perl. The result is an elegant mechanism for bypassing tokens through a clearly documented and separated mechanism of backtracking while retaining context about the structure through the use of captured groups in the split regex.

Chess Solo

Jorg provides a very concise and mathematically elegant solution for the colorisation of a chessboard. By recognising that under mod 2 operations the coordinate bases are completely annihilated, implementations can be created in both Perl and J using only one line of code and they are both efficient and structurally minimalist.

The Weekly Challenge 376

An unusually clear yet detailed solution is provided in this blog post, as it combines clean, idiomatic code examples with short technical explanations about how to use regex to parse doubled words and how to compare two mathematical coordinates. Complex logic is presented so anyone can read easily and learn from.

Perl Weekly Challenge 376

The excellent demonstration of the capabilities of Perl as a function-based programming language is shown through this post with extremely short and idiomatic solutions. Luis Mochán has used expressive, single-line statements to convert complicated constraints into small, clean, logical data flows in an extraordinary manner with Perl.

A 1-Bit Chessboard and Fancy Separators

Matthias presents an analytical and well-defined solution to the difficulties presented by Challenge 376 through the use of well-separated parsing and formatting, clear comments on the use of regular expressions, and the submission of a clear and clean solution suitable for production.

You might think I’m crazy, but I don’t even care

A well-structured and very interesting review of Perl Weekly Challenge 376 is presented with a reference to principles from a popular culture item. Packy clearly illustrates the elegant way to process text in the real world while exhibiting outstanding technical expertise by explaining the complexity of lookahead logic and the constraints of the boundary in a way that allows for simple, idiomatic, and highly maintainable solutions.

Squares and pairs

This solution offers a very neat, simple, and mathematically pleasing method for solving the chessboard parity problem. Peter has effectively utilised the ASCII values (ord) of the column letters as well as the numeric row values to reduce a spatial coordinate problem to a quick and efficient calculation of a bitwise parity (& 1). The source code is formatted well, clearly commented, and takes advantage of the mathematics behind the solution so as to avoid unnecessary conditional barriers.

The Weekly Challenge - 376: Chessboard Squares

This post gives a very clear, well-organized, and visually intuitive representation of how to solve the programming challenge "Chessboard Squares". Explicitly laying out the grid coordinates with their appropriate color will provide an excellent foundation for developing an accurate and efficient lookup algorithm.

The Weekly Challenge #376

By using an elegant mathematical approach to the parity of squares on a chessboard, along with an incredibly efficient, single-pass regular expression, this code shows immense technical skill. The code also uses multi-line lookaheads, HTML tags, and back references, all handled by a simple subroutine (double_double_toil_and_trouble), that is suitable for use at production level.

Half a Chessboard

A general description of a previously completed task, this post shows a real-life application of code reuse. Roger created a nice, modular solution to decode coordinate mathematics (on the basis of (x+y) mod 2) by cleanly wrapping the existing helper function from the previous task. Therefore, through this implementation, he provides a concise representation of the solution and eliminates any duplicate logic.

Double chessboard

In this blog post, Simon's clever use of the bitwise XOR operator (^) as a parity check for a chess board is very creative. Additionally, he shows a well-organised and simple method of utilising re.split and list comprehensions to find the position of words while also overcoming some challenging lookahead and HTML boundary situations.

Rakudo

2026.22 Some AST Fruit

Weekly collections

NICEPERL's lists

Great CPAN modules released last week.

The corner of Gabor

A couple of entries sneaked in by Gabor.

FalkorDB client in Perl using CLI AI Agents

This is the first hour of the live coding session using AI to write Perl we had last week. (Free, registration required)

FalkorDB using Perl

This is the second hour of the live coding session using AI to write Perl we had last week. (Free, registration required)

Next: Perl development using AI

The next session in which each participant will have the opportunity to show how s/he is using AI to write Perl code. I am sure we will learn a lot from each other!

Growing Pains: Scaling AI Coding across Team and Repo Boundaries with Graham Knapp

Video recordings from the session yesterday. It is not Perl specific, but helps you understand things. For more such event, sign up to the Code Mavens Meetup group

Events

Boston Perl Mongers virtual monthly

June 9, 2026

Paris.pm monthly meeting

June 10, 2026

Purdue Perl Mongers (HackLafayette) - TBA

June 11, 2026

Perl development using AI (online)

June 17, 2026

Berlin.pm - Naumanns Biergarten

June 24, 2026

Toronto.pm - June Social Evening

June 25, 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 376

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: Chessboard Squares

Task

You are given two coordinates of a square on 8x8 chessboard.

Write a script to find the given two coordinates have the same colour.

My solution

This - like most first tasks - is relatively straight forward. I have a function called is_black and it takes a cell variable as a parameter.

After checking the square is valid (first letter a-g, second number 1-8), it then uses the exclusive xor operator ^ to determine if a square is black.

import re

def is_black(cell: str) -> bool:
    if not re.search('^[a-h][1-8]$', cell):
        raise ValueError(f"Cell {cell} is not valid!")

    return bool((cell[0]in "aceg") ^ (int(cell[1]) % 2))

The same_color function simply checks if the two specified squares are the same.

def same_color(c1: str, c2: str) -> bool:
    return is_black(c1) == is_black(c2)

The Perl solution follows the same logic.

sub is_black($cell) {
    if ( $cell !~ /^[a-h][1-8]$/ ) {
        die "Cell '$cell' is not valid!\n";
    }

    return ( index( "aceg", substr( $cell, 0, 1 ) ) == -1 ? 0 : 1 )
      ^ ( substr( $cell, 1, 1 ) % 2 );
}

sub main ( $c1, $c2 ) {
    say is_black($c1) == is_black($c2) ? 'true' : 'false';
}

Examples

$ ./ch-1.py a7 f4
true

$ ./ch-1.py c1 e8
false

$ ./ch-1.py b5 h2
false

$ ./ch-1.py f3 h1
true

$ ./ch-1.py a1 g7
true

Task 2: Doubled Words

Task

You are given a string (which may contain embedded newlines) which is taken from a page on a website. The string will not contain brackets qw{ [ ] }.

Write a script that will find doubled words (such as "this this") and highlight (wrap in brackets) each doubled word.

The script should:

• Work across lines, even finding situations where a word at the end of one line is repeated at the beginning of the next.
• Find doubled words despite capitalization differences, such as with 'The the...', as well as allow differing amounts of white-space (spaces, tabs, newlines, and the like) to lie between the words.
• Find doubled words even when separated by HTML tags. For example, to make a word bold: '...it is very very important...'. Only show lines containing doubled words.

My solution

For input from the command line I replace a literal \n (i.e. a backslash followed by the letter 'n') with a new line character. The output replaces new lines with a literal \n. This ensures that I can copy and paste the examples. The Python test suite calls the function directly, so does not need this functionality.

Wow. This one is really tricky. To me an English word is some letters, optionally with a hyphen or apostrophe in the middle (e.g. one-sided or don't). Annoyingly apostrophes can also be used before or after a word to indicate a quote.

My first attempt at solving this was so bad, I went back to the drawing board for my second attempt. I have a solution that words (all five tests pass), but I'm sure that there is a more efficient solution.

I start this task by separating HTML (regular expression <[^>]+>, an open angle bracket, multiple characters that aren't a close angle bracket, and a close angle bracket) and words (regular expression [a-z0-9]+(?:['-][a-z0-9]+)*, letters optionally with hyphen or apostrophe in the middle) from other content (white space, punctuation, etc). As the first parameter to re.split is surround by parentheses, the words and HTML are also returned.

import re

def doubled_words(input_string: str) -> str:
    regexp = r"(<[^>]+>|[a-z]+(?:['-][a-z]+)*)"
    words_and_html = re.split(regexp, input_string, flags=re.IGNORECASE)

The next step is to find the position of all words only. This uses list comprehension to exclude even (0-based) elements (white space and punctuation) and HTML elements.

    parts = [
        i
        for i, word in enumerate(parts)
        if i % 2 == 1 and word[0] != "<" and word[-1] != ">"
    ]

Next I go through the word_positions list and replace words that are the same as the next word (case insensitive). It should be noted that triple words will only have the first two occurrences replaced.

    for pos in range(len(word_positions)-1):
        this_pos = word_positions[pos]
        next_pos = word_positions[pos+1]
        if parts[this_pos].lower() == parts[next_pos].lower():
            parts[this_pos] = f"[{parts[this_pos]}]"
            parts[next_pos] = f"[{parts[next_pos]}]"

With that done, I then separate the original input and new parts into two lists separated by new lines.

    input_lines = re.split(r"[\r\n]+", input_string)
    output_lines = re.split(r"[\r\n]+", "".join(parts))

Finally, I find the lines that are different (using list comprehension again) and return only the lines that are different, separated by new lines.

    different_lines = [
        output
        for i, output in enumerate(output_lines)
        if output != input_lines[i]
    ]

    return "\n".join(different_lines)

The Perl solution follows the same logic, and uses map and grep to mimic list comprehension.

Examples

$ ./ch-2.py "you're given the job of checking the pages on a\nweb server for doubled words (such as 'this this'), a common problem\nwith documents subject to heavy editing."
"web server for doubled words (such as '[this] [this]'), a common problem"

$ ./ch-2.py "Find doubled words despite capitalization differences, such as with 'The\nthe...', as well as allow differing amounts of whitespace (spaces,\ntabs, newlines, and the like) to lie between the words."
"Find doubled words despite capitalization differences, such as with '[The]\n[the]...', as well as allow differing amounts of whitespace (spaces,"

$ ./ch-2.py "to make a word bold: '...it is <B>very</B> very important...'."
"to make a word bold: '...it is <B>[very]</B> [very] important...'."

$ ./ch-2.py "Perl officially stands for Practical Extraction and Report Language, except when it doesn't."
""

$ ./ch-2.py "There's more than one one way to do it.\nEasy things should be easy and hard things should be possible."
"There's more than [one] [one] way to do it."

$ ./ch-2.py "I can't can't do this"
"I [can't] [can't] do this"