Forem: Simon Green

Weekly Challenge: Group Tag

Simon Green — Wed, 15 Apr 2026 07:51:08 +0000

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:

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 #.
Sanitise the String: Strip out all characters that are not English letters (a-z or A-Z).
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!!!']

Weekly Challenge: Little, Big and Bigger

Simon Green — Sun, 12 Apr 2026 08:45:22 +0000

Weekly Challenge 368

Challenge, My solutions

Task 1: Make it Bigger

Task

You are given a given a string number and a character digit.

Write a script to remove exactly one occurrence of the given character digit from the given string number, resulting the decimal form is maximised.

My solution

As all the examples are positive integers, I've assumed that the string number is always this. Sometimes brute force is the easiest way to write a solution a task.

I start my turning the number and digit values into strings, and check the digit is in the number. I set the max_number variable to 0.

def make_it_bigger(number, digit) -> int:
    number = str(number)
    digit = str(digit)

    if digit not in number:
        raise ValueError(f"The digit {digit} is not in {number}")
    max_number = 0

I then create a loop with the variable i from 0 to one less than the length of the number. If the digit at that position is the digit value, I compute the number with that digit removed, and update max_number if required.

    for i in range(len(number)):
        if number[i] != digit:
            # Don't consider removing this digit
            continue

        new_number = int(number[:i] + number[i+1:])
        if new_number > max_number:
            max_number = new_number

    return max_number

The Perl solution follows the same logic, and uses the substr method to extract parts of the string.

Examples

$ ./ch-1.py 15456 5
1546

$ ./ch-1.py 7332 3
732

$ ./ch-1.py 2231 2
231

$ ./ch-1.py 543251 5
54321

$ ./ch-1.py 1921 1
921

Task 2: Big and Little Omega

Task

You are given a positive integer $number and a mode flag $mode. If the mode flag is zero, calculate little omega (the count of all distinct prime factors of that number). If it is one, calculate big omega (the count of all prime factors including duplicates).

My solution

For this task, I start by computing all the prime factors and storing them in the factors list (array in Perl). To do this, I start with the variable i as 2 (the smallest prime number). I have a loop that continues until the number variable is 1. For each iteration, I check if number is evenly divisible by i. If it is, I add i to the factors list, and divide number by i. If it isn't, I increment i by 1.

To avoid an endless loop, I have a safety check to see that i isn't greater than number. That should never happen, but you never know with user input, or dodgy code :)

The final part of the task is to return a number based on the mode value. If the mode is non-zero, I return the number of items in the factors list. If it is zero, I convert this to set first to count the number of unique factors.

def omega(number: int, mode: int) -> int:
    factors = []
    i = 2

    while number > 1:
        if number % i == 0:
            factors.append(i)
            number //= i
        else:
            i += 1

            if i > number:
                raise ValueError("Cannot calculate prime digits")

    return len(factors) if mode else len(set(factors))

Examples

$ ./ch-2.py 100061 0
3

$ ./ch-2.py 971088 0
3

$ ./ch-2.py 63640 1
6

$ ./ch-2.py 988841 1
2

$ ./ch-2.py 211529 0
2

Weekly Challenge: Maximum conflict

Simon Green — Sun, 05 Apr 2026 10:02:03 +0000

Weekly Challenge 367

Challenge, My solutions

Task 1: Max Odd Binary

Task

You are given a binary string that has at least one 1.

Write a script to rearrange the bits in such a way that the resulting binary number is the maximum odd binary number and return the resulting binary string. The resulting string can have leading zeros.

My solution

This task requires some number theory to implement the solution.

To make an odd binary number the last bit (less significant) needs to be a 1.
To make the largest possible number, the remaining set bits need to be the largest (left / most significant) bits.

The parts of this task are:

Use a regular expression to check the input_string variable matches the expected input. It must contain at least one 1 and any number of 0 and 1.
Count the number of zeros and ones in the string, stored as the variables zeros and ones respectively.
Return a string that was ones-1 ones, zeros zeros and the last one to make it an odd binary.

def max_odd_binary(input_string: str) -> str:
    if not re.search(r'^[01]*1[01]*$', input_string):
        raise ValueError("Input not in expected format")

    zeros = input_string.count("0")
    ones = input_string.count("1")

    return "1" * (ones-1) + "0" * zeros + "1"

The Perl solution follows the same logic. It uses the tr function to count the number of zeros and ones, and the x operator for repetition.

Examples

$ ./ch-1.py 1011
1101

$ ./ch-1.py 100
001

$ ./ch-1.py 111000
110001

$ ./ch-1.py 0101
1001

$ ./ch-1.py 1111
1111

Task 2: Conflict Events

Task

You are given two events start and end time.

Write a script to find out if there is a conflict between the two events. A conflict happens when two events have some non-empty intersection.

My solution

One of the challenges when completing these tasks is achieving the most optimal solutions. Not in terms of performance, but in terms of being the best solution. Usually it is straight forward, I'm not sure if I've hit the mark on this one.

Things get more complicated when one (or both) the times go across midnight. This is the approach I took.

Create a function hm2m to convert a time in HH:MM format to minutes after midnight. It also uses a regular expression to check that the HH:MM is in the correct format and is valid.

def hm2m(t: str) -> int:
    if not re.search(r'^([0-1][0-9]|2[0-3]):[0-5][0-9]$', t):
        raise ValueError("Input is not in the expected format (HH:MM)")

    return int(t[:2]) * 60 + int(t[3:])

Take the supplied events (although the tasks specifies two, more can be provided) and create a range object from the start time to one minute less than the stop time and store it in the event_minutes list. If the start_time is later than end_time I add two range objects, one before midnight (end time = 1440) and after midnight (start time = 0).

def conflict_events(events) -> bool:
    """Determine if there is a conflict between two or more events.

    Params:
        events(list): A list of start and end times in HH:MM format

    Returns:
        bool: Whether two events conflict (occur at the same time)
    """
    event_minutes = []
    for event in events:
        start_minute = hm2m(event[0])
        end_minute = hm2m(event[1])
        if start_minute == end_minute:
            continue

        if end_minute < start_minute:
            event_minutes.extend(
                [range(start_minute, 1440), range(0, end_minute)])
        else:
            event_minutes.append(range(start_minute, end_minute))

The final step is to take the event_minutes ranges, and see if there is any overlap. For this I have a minutes set (hash in Perl). I iterate over each minute in each item in the events_minutes list. If the minute already appears in the minutes set, I return True. If not, I added it to the minutes set, and continue the loop.

If the list is exhausted, I return False as there is no conflict. Lucky you!

    minutes = set()
    for r in event_minutes:
        for minute in r:
            if minute in minutes:
                return True
            minutes.add(minute)

    return False

The Perl solution follows the same logic. The event_minutes array stores an array of start minutes and end minutes, as it does not have a range-like object.

Examples

$ ./ch-2.py 10:00 12:00 11:00 13:00
True

$ ./ch-2.py 09:30 10:30 10:30 12:00
False

$ ./ch-2.py 14:00 15:30 14:30 16:00
True

$ ./ch-2.py 08:00 09:00 09:01 10:00
False

$ ./ch-2.py 23:00 00:30 00:00 01:00
True

Happy 7th birthday TWC!

Simon Green — Mon, 23 Mar 2026 12:34:59 +0000

Weekly Challenge 366

It was seven years ago that Mohammad sent out the first challenge to Team PWC (as it was then known). Thank you very much for all your work over the seven years.

Challenge, My solutions

Task 1: Count Prefixes

Task

You are given an array of words and a string (contains only lowercase English letters).

Write a script to return the number of words in the given array that are a prefix of the given string.

My solution

This is a one-liner in Python. It should be pretty self-explanatory. Given a list called array and a string called prefix, it counts the number of items in the list where the first letters of the prefix match the word.

def count_prefixes(array: list, prefix: str) -> int:
    return sum(1 for word in array if prefix[:len(word)] == word)

The Perl solution uses the grep function to perform the counting. In a scalar context, grep returns the number of matching items.

sub main (@array) {
    my $prefix = pop(@array);
    my $count  = grep { substr( $prefix, 0, length($_) ) eq $_ } @array;
    say $count;
}

Examples

$ ./ch-1.py a ap app apple banana apple
4

$ ./ch-1.py cat dog fish bird
0

$ ./ch-1.py hello he hello heaven he hello
4

$ ./ch-1.py "" code coding cod coding
3

$ ./ch-1.py p pr pro prog progr progra program program
7

Task 2: Valid Times

Task

You are given a time in the form HH:MM. The earliest possible time is 00:00 and the latest possible time is 23:59. In the string time, the digits represented by the ? symbol are unknown, and must be replaced with a digit from 0 to 9.

Write a script to return the count different ways we can make it a valid time.

My solution

This is an interesting challenge as the solution is not straight forward. There are a few approaches that can be taken. One option is to calculate all 1440 minutes in a day and see if it matched the expected pattern.

The approach I took was to calculate the possible hours and possible minutes, and multiplying both figures to return a result.

I start by using a regular expression to check if the time is valid. As the question mark ? is within square brackets [ ] this is taken as a literal character.

def valid_times(input_string: str) -> int:
    if not re.search(r'^([0-1?][0-9?]|2[0-3?]):[0-5?][0-9?]$', input_string):
        raise ValueError("Input is not in the expected format (HH:MM)")

The next task is calculating the number of valid hours.

If the hours is ??, then there are 24 valid hours.
If the first character is a question there are 3 valid hours if the second digit is less than four (e.g. 02 12 22), or 2 if it is 4 or greater (e.g. 04 14).
If the second character is a question mark, there are 4 valid hours if the first digit is 2, or 10 valid hours otherwise.
If hours have no questions marks, there is only one valid hour.

    # Compute the hours
    if input_string[:2] == "??":
        hours = 24
    elif input_string[:1] == "?":
        hours = 3 if int(input_string[1:2]) < 4 else 2
    elif input_string[1:2] == "?":
        hours = 4 if input_string[:1] == "2" else 10
    else:
        hours = 1

Thankfully calculating the number of valid minutes is a little easier.

If the minutes is ??, then there are sixty valid minutes.
If the first character is a question mark, then there are six valid minutes (e.g. 06 16 26 36 46 56).
If the second characters is a question mark, there are ten valid minutes (e.g. 50 51 ... 58 59).
If the minutes have no question marks, there is only one valid minute.

    if input_string[3:] == "??":
        minutes = 60
    elif input_string[3:4] == "?":
        minutes = 6
    elif input_string[4:] == "?":
        minutes = 10
    else:
        minutes = 1

    return hours * minutes

The Perl solution follows the same logic as the Python solution.

Examples

$ ./ch-2.py ?2:34
3

$ ./ch-2.py ?4:?0
12

$ ./ch-2.py ??:??
1440

$ ./ch-2.py ?3:45
3

$ ./ch-2.py 2?:15
4

Weekly Challenge: Counting the index

Simon Green — Thu, 19 Mar 2026 07:30:11 +0000

Weekly Challenge 365

Challenge, My solutions

Task 1: Alphabet Index Digit Sum

Task

You are given a string $str consisting of lowercase English letters, and an integer $k.

Write a script to convert a lowercase string into numbers using alphabet positions (a=1 … z=26), concatenate them to form an integer, then compute the sum of its digits repeatedly $k times, returning the final value.

My solution

This is a task of two parts. The first is to take the letters from input_string (as str is a reserved word in Python) to create a number. For this I use string.ascii_lowercase.index(letter)+1 to get each letter and append it to the digits variable. The +1 is because the letters start at 1, not 0.

def aid_sum(input_string: str, k: int) -> int:
    digits = ''
    for letter in input_string:
        try:
            digits += str(string.ascii_lowercase.index(letter)+1)
        except ValueError:
            raise ValueError(
                f"The character '{letter}' does not appear to be a lower case letter"
            )

The second part is to compute the sums of all the digits a specified number of times. For this I have a loop that performs this. It's a little clunky as Python treats strings and integers differently. If I have a single digit, I exit the loop early as further repetitions won't change the result.

    for _ in range(k):
        digits = str(sum(int(i) for i in digits))
        if len(digits) == 1:
            break

    return int(digits)

As Perl doesn't care about strings vs integers (with a few exceptions), the code is more straight forward. The index function is used to find the position of the letter in the alphabet.

sub main ( $input_string, $k ) {
    my $alphabet = join( "", "a" .. "z" );
    my $digits   = '';

    foreach my $letter ( split //, $input_string ) {
        my $idx = index( $alphabet, $letter );
        if ( $idx == -1 ) {
            die
              "The character '$letter' does not appear to be a lower case letter\n";
        }

        $digits .= $idx + 1;
    }

    foreach ( 1 .. $k ) {
        $digits = sum( split //, $digits );
    }

    say $digits;
}

Examples

$ ./ch-1.py abc 1
6

$ ./ch-1.py az 2
9

$ ./ch-1.py cat 1
6

$ ./ch-1.py dog 2
8

$ ./ch-1.py perl 3
6

Task 2: Valid Token Counter

Task

You are given a sentence.

Write a script to split the given sentence into space-separated tokens and count how many are valid words. A token is valid if it contains no digits, has at most one hyphen surrounded by lowercase letters, and at most one punctuation mark (!, ., ,) appearing only at the end.

My solution

This is a challenge where regular expression can be used to solve the problem. In both the Python and Perl solution, the regular expression used is ^[a-z]+(\-[a-z]+)?[!,\.]?$.

Breaking each part down:

^ indicate the start of the string
[a-z]+ means one or more lower case letters
(\-[a-z]+)? means optionally (the question mark) a hyphen and one or more lowercase letters.
[!,\.]? means optionally a exclamation mark, comma or full stop.
$ means the end of the string.

This is a one liner in Python

def valid_token_counter(input_string: str) -> int:
    return sum(
        1 for word in input_string.split()
        if re.search(r'^[a-z]+(\-[a-z]+)?[!,\.]?$', word)
    )

The Perl solution is also one line (and an extra one to display the answer). The grep function returns the number of matches in a scalar context.

sub main ($input_string) {
    my $count = grep { /^[a-z]+(\-[a-z]+)?[!,\.]?$/ } split /\s+/,
      $input_string;
    say $count;
}

Examples

$ ./ch-2.py "cat and dog"
3

$ ./ch-2.py "a-b c! d,e"
2

$ ./ch-2.py "hello-world! this is fun"
4

$ ./ch-2.py "ab- cd-ef gh- ij!"
2

$ ./ch-2.py "wow! a-b-c nice."
2

Weekly Challenge: It's all about the translation

Simon Green — Thu, 12 Mar 2026 07:29:35 +0000

Weekly Challenge 364

Challenge, My solutions

Task 1: Decrypt String

Task

You are given a string formed by digits and #. Write a script to map the given string to English lowercase characters following the given rules.

Characters a to i are represented by 1 to 9 respectively.
Characters j to z are represented by 10# to 26# respectively.

My solution

This task calls for regular expressions to be used. Both Python and Perl allow call back functions in the replacement section (i.e. you can call a function to find the new string).

For the Python solution, I have a (callback) function called replace_digits. It takes a Match object as input and returns a string.

def replace_digits(m: re.Match) -> str:
    c = m.group(0)
    return chr(96 + int(c[:2]))

The variable c has the matching string (either a single digit or two digits (10-26) followed by a hash character. Things to note:

c[:2] will remove the hash if it is present.
int(...) will convert this into a number
chr(...) will turn this into a letter of the alphabet. The ASCII code for the letter a is 97.

The main function checks that the input is valid. It then uses re.sub to perform the substitution in the replace_digits function.

def decrypt_string(input_string: str) -> str:
    if not re.search(r'^(1\d#|2[0-6]#|\d)*$', input_string):
        raise ValueError("String not in expected format")

    return re.sub(r'(1\d#|2[0-6]#|\d)', replace_digits, input_string)

The Perl solution follows the same logic, except that the replacement value can be code (not just a function call). This negates the need for a separate function. The substr function is used to remove the hash character.

sub main ($input_string) {
    if ( $input_string !~ /^(1\d#|2[0-6]#|\d)*$/ ) {
        die "String not in expected format\n";
    }

    my $output_string = $input_string;
    $output_string =~ s/(1\d#|2[0-6]#|\d)/chr(96 + substr($1,0,2))/eg;
    say $output_string;
}

In the regular expression, /e indicates that the replacement value is a expression (as opposed to the literal string), and /g means to run the regular expression globally (on all occurrences).

Examples

$ ./ch-1.py 10#11#12
jkab

$ ./ch-1.py 1326#
acz

$ ./ch-1.py 25#24#123
yxabc

$ ./ch-1.py 20#5
te

$ ./ch-1.py 1910#26#
aijz

Task 2: Goal Parser

Task

You are given a string, $str.

Write a script to interpret the given string using Goal Parser. The Goal Parser interprets G as the string G, () as the string o, and (al) as the string al. The interpreted strings are then concatenated in the original order.

My solution

For this task, I use a regular expression to check that the input_string is in the expected format. I then use the replace function to change the string to the required output.

def good_parser(input_string: str) -> str:
    if not re.search(r'^(G|\(\)|\(al\))*$', input_string):
        raise ValueError("Unexpected input received")

    return input_string.replace('()', 'o').replace('(al)', 'al')

Perl doesn't have a replace function, so I use a regular expression to perform the replacement.

sub main ($input_string) {
    if ($input_string !~ /^(G|\(\)|\(al\))*$/) {
        die "Unexpected input received\n;"
    }

    my $output_string = $input_string;
    $output_string =~s/\(\)/o/g;
    $output_string =~ s/\(al\)/al/g;

    say $output_string;
}

Examples

Parentheses have special meaning in bash, so quotes are used to handle this.

$ ./ch-2.pl "G()(al)"
Goal

$ ./ch-2.pl "G()()()()(al)"
Gooooal

$ ./ch-2.pl "(al)G(al)()()"
alGaloo

$ ./ch-2.pl "()G()G"
oGoG

$ ./ch-2.pl "(al)(al)G()()"
alalGoo

Weekly Challlenge: The subnet detector

Simon Green — Sun, 08 Mar 2026 13:43:08 +0000

Weekly Challenge 363

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: String Lie Detector

Task

You are given a string.

Write a script that parses a self-referential string and determines whether its claims about itself are true. The string will make statements about its own composition, specifically the number of vowels and consonants it contains.

My solution

This was relatively straight forward in Python. I took the following steps:

Use a regular expression to extract the necessary parts of the input_string, and store this as the value match.
Count the number of vowels and consonants in the first value and store it as vowel_count and const_count.
Use the word2num module to convert the numbers in input_string to integers, stored as expected_vowel and expected_const.
Compare the count and expected values match, and return the result.

import re
from word2num import word2num

def string_lie_detector(input_string: str) -> bool:
    match = re.match(
        r"(\w+) . (\w+) vowels? and (\w+) consonants?", input_string)
    if not match:
        raise ValueError("Input string not in expected format")

    vowel_count = 0
    const_count = 0
    for c in match.group(1).lower():
        if c in "aeiou":
            vowel_count += 1
        else:
            const_count += 1

    expected_vowel = word2num(match.group(2))
    expected_const = word2num(match.group(3))

    return vowel_count == expected_vowel and const_count == expected_const

The Perl solution is a little more complex. Maybe my Google-foo isn't up to scratch (and I don't use Copilot when working on solutions) that there doesn't appear to be a CPAN module that will convert words into numbers. As this is a coding exercise only I have a hash called %word2num that maps words to number (from zero to twenty).

The next problem is four of the examples use a long dash as the separator. This is a UTF-8 character. The result of perl -E 'say length("—")' is 3. After numerous searches of the Internet, it turns out I need to include use utf8:all in the code. With this change, I get the expected result of 1.

The rest of the code follows the same logic as the Python solution.

use utf8::all;

sub main ($input_string) {
    my %word2num = (qw/
        zero 0 one 1 two 2 three 3 four 4 five 5 six 6 seven 7 eight 8
        nine 9 ten 10 eleven 11 twelve 12 thirteen 13 fourteen 14
        fifteen 15 sixteen 16 seventeen 17 eighteen 18 nineteen 19 twenty 20
    /);

    my ( $word, $v, $c ) =
      ( $input_string =~ /(\w+) . (\w+) vowels? and (\w+) consonants?/ );

    if ( !$word ) {
        die "Input string not in expected format\n";
    }

    my $vowel_count = 0;
    my $const_count = 0;
    foreach my $c ( split //, lc($word) ) {
        if ( index( "aeiou", $c ) == -1 ) {
            $const_count++;
        }
        else {
            $vowel_count++;
        }
    }

    my $expected_vowel = $word2num{ lc $v } // die "Don't know what $v is\n";
    my $expected_const = $word2num{ lc $c } // die "Don't know what $c is\n";

    my $truth =
      ( $vowel_count == $expected_vowel and $const_count == $expected_const );
    say $truth ? 'true' : 'false';
}

Examples

There was an issue with the examples, and I raised a pull request to fix it.

$ ./ch-1.py "aa — two vowels and zero consonants"
True

$ ./ch-1.py "iv — one vowel and one consonant"
True

$ ./ch-1.py "hello - three vowels and two consonants"
False

$ ./ch-1.py "aeiou — five vowels and zero consonants"
True

$ ./ch-1.py "aei — three vowels and zero consonants"
True

Task 2: Subnet Sheriff

Task

You are given an IPv4 address and an IPv4 network (in CIDR format).

Write a script to determine whether both are valid and the address falls within the network. For more information see the Wikipedia article.

My solution

This one was the easier of the two to complete. Maybe because I have worked at many IPSs in the past :-)

Python has the ipaddress module which makes it easy to confirm if an IPv4 address is in a particular IP address block.

I use a try/except block to handle situations (like the second example) where the IP address or net block is invalid. This follows the Python philosophy of Easier to Ask for Forgiveness than Permission.

import ipaddress

def subnet_sheriff(ip_addr: str, domain: str) -> bool:
    try:
        return ipaddress.IPv4Address(ip_addr) in ipaddress.IPv4Network(domain)
    except ipaddress.AddressValueError:
        return False

Perl has the Net::IP module in CPAN that performs similar functionality. If the IP address or net block is invalid, the variable will be undef, and the else block will be used.

use Net::IP;

sub main ( $ip_addr, $domain ) {
    my $addr = Net::IP->new($ip_addr);
    my $block = Net::IP->new($domain);
    if ( $addr and $block ) {
        my $overlaps = ( $addr->overlaps($block) != $IP_NO_OVERLAP );
        say $overlaps  ? 'true' : 'false';
    }
    else {
        say 'false';
    }
}

Examples

$ ./ch-2.py 192.168.1.45 192.168.1.0/24
True

$ ./ch-2.py 10.0.0.256 10.0.0.0/24
False

$ ./ch-2.py 172.16.8.9 172.16.8.9/32
True

$ ./ch-2.py 172.16.4.5 172.16.0.0/14
True

$ ./ch-2.py 192.0.2.0 192.0.2.0/25
True

$ ./ch-2.py 1.1.1.1 10.0.0.0/8
False

Weekly Challenge: The one liners

Simon Green — Sun, 01 Mar 2026 12:57:45 +0000

Weekly Challenge 362

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: Echo Chamber

Task

You are given a string containing lowercase letters.

Write a script to transform the string based on the index position of each character (starting from 0). For each character at position i, repeat it i + 1 times.

My solution

Both of this weeks solutions are a one-liner in Python. For this task, the function is

def echo_chamber(input_string: str) -> str:
    return ''.join(
        letter * pos
        for pos, letter in enumerate(input_string, start=1)
    )

Multiplying a string (letter) by an integer (pos) will repeat the string the specified number of times.

The enumerate function in Python returns the index and the value from a iterator (in this case characters in a string). A little-used feature of this function is the start parameter which will start counting at a value other than the default of zero.

The Perl solution is a little more verbose, as I build the string a letter at a time. By using ++$cnt, the value is incremented before it is evaluated (as opposed to $cnt++). The x operator will repeat the string the required number of times.

sub main ($input_string) {
    my $output_string = '';

    my $cnt = 0;
    foreach my $letter ( split //, $input_string ) {
        $output_string .= $letter x ++$cnt;
    }

    say $output_string;
}

Examples

$ ./ch-1.py abca
abbcccaaaa

$ ./ch-1.py xyz
xyyzzz

$ ./ch-1.py code
coodddeeee

$ ./ch-1.py hello
heelllllllooooo

$ ./ch-1.py a
a

Task 2: Spellbound Sorting

Task

You are given an array of integers.

Write a script to return them in alphabetical order, in any language of your choosing. Default language is English.

My solution

Thankfully the perfectly round wheels have already been invented for converting integers into strings. To make this task a little easier on myself, I'm only using English.

Python has the num2words module. The sorted function has the key parameter to determine how the integers should be sorted.

from num2words import num2words

def spellbound_sorting(ints: list[int]) -> list[int]:
    return sorted(ints, key=num2words)

Perl has the Lingua::EN::Numbers module. The sort function in Perl also has built in features to determine the sort order.

use Lingua::EN::Numbers 'num2en';

sub main (@ints) {
    my @sorted_ints = sort { num2en($a) cmp num2en($b) } @ints;
    say join( ", ", @sorted_ints );
}

Examples

$ ./ch-2.py 6 7 8 9 10
[8, 9, 7, 6, 10]

$ ./ch-2.py -3 0 1000 99
[-3, 99, 1000, 0]

$ ./ch-2.py 1 2 3 4 5
[5, 4, 1, 3, 2]

$ ./ch-2.py 0 -1 -2 -3 -4
[-4, -1, -3, -2, 0]

$ ./ch-2.py 100 101 102
[100, 101, 102]

Weekly Challenge: Representing a celebrity

Simon Green — Mon, 16 Feb 2026 06:58:38 +0000

Weekly Challenge 361

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, GitHub 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: Zeckendorf Representation

Task

You are given a positive integer (<= 100).

Write a script to return Zeckendorf Representation of the given integer. Every positive integer can be uniquely represented as sum of non-consecutive Fibonacci numbers.

My solution

My original solution was to use a recursive function to calculate the numbers. This attempt is recorded in ch-1-recursive.py. However, I realized when looking at larger numbers, this was not required. There is a reason this is the first task and not the second :)

My solution starts with a function called generate_fibonacci which generates a list of Fibonacci numbers that are less than or equal to the target number. This is stored in a list called seq.

def generate_fibonacci(number: int) -> list[int]:
    seq = [0, 1]
    while seq[-1] <= number:
        seq.append(seq[-2] + seq[-1])

    return seq[:-1]

I create an a variable called remaining which is set to the input number, and an empty list called result which has the numbers that make up the solution.

Next I have a loop that runs until a solution is found, or it the seq list is empty (which should never happen). For each iteration, I take the last value from the list and assign it to a variable called value. If this is larger than remaining, the loop starts again with no further action.

I subtract value from remaining, and append value to the result list. If remaining is zero, the solution is found, and is returned. If the is still a remainder, I remove another value from the seq list (as we cannot use consecutive numbers), and the loop starts again.

def zeckendorf_representation(number: int) -> list[int] | None:
    if number < 1:
        raise ValueError("The number must be a positive integer")

    seq = generate_fibonacci(number)

    remaining = number
    result = []

    while seq:
        value = seq.pop()

        if value <= remaining:
            remaining -= value
            result.append(value)

            if remaining == 0:
                return result

            seq.pop()

    return None

Examples

$ ./ch-1.py 4
[3, 1]

$ ./ch-1.py 12
[8, 3, 1]

$ ./ch-1.py 20
[13, 5, 2]

$ ./ch-1.py 96
[89, 5, 2]

$ ./ch-1.py 100
[89, 8, 3]

Bonus

I'm not sure why there is a restriction on numbers less than 100. Even calculating the Zeckendorf Representation of a Googol (10¹⁰⁰) takes less than 0.2 seconds.

$ time ./ch-1.py 10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
[9216845717656874712980450562726202415567360565980794777111390850331644813674856981646960226192287360, 513637207677450246125760857023446893186481668075116373246321641937144993869266524849692790595738232, 196191955446197556957565929345772792668594307949581132632670453793550007197467505024573547039776939, 46314638123912707463692067318029823029991796402327083329291014906539951751195524576517845992591769, 17690617586682990180447203622188161240682337031027142006892310369574875779255058929007841461590953, 6757214636136263077649543548534660692055214690754342691385916202184675586569652210505678392181090, 1595161992684664972646689501703019021088600608282570556855039728226373625661856805487290962276456, 609297663643530892791951979990217206693894175329255046444641219473596270869815908465388209600595, 232730998245927705729166438267632598993081917705194582478883930194415186947590919908873666525329, 88895331094252224395547334812680590285351577786328700992010571109649289972956851261232789975392, 33954995036828967457475566170409171862972815653791520497147783134532682971279633874824703400847, 1892247019390521442608211077147886839616506438992322504018876947992022613217501281456451614651, 446698926797525733283994464723773897373051547730509482206718754667074636645528022516256487945, 170623807298553611905880623235491323624375649830112453507358412671675285005069415562415412537, 65172495098135102433647404982700073500075401759827878315356483347951218369680224170989749666, 24893677995851695395061591712608896875850555449371181438711037372178370103971256950553836461, 5876600217011727891986851402355662620898026272799849437157779835010586219504163589210317027, 2244661544603472032436332649584708114319787957314032873538930901437280496774780497748874337, 125090700579089545268174422433569433531336921195894847055310250098200676237081739043824861, 6971065820139782390806954219541689244276624212074373456653600330331675492690805039973161, 2662710205480735617346452022100755074809023407208374441801919604845563638678145849451440, 91708675472160090711036102616287632089318911882123915231537729562617689923506638302133, 35029596967131343602213497450232647402139968983372205851566400021802909132390757909314, 745648276861993189984204820755333242001144560869101973859680384188513887852280667477, 9809463517264670023038788649658295091956272699959366635620342487725314342549664567, 3746881652193013001948452031301618270087167924331813432662649918207032018665867029, 1431181439314368982806567444246559718305231073036073662367607266895781713447936520, 546662665750093946471250301438060884828525294776407554440171882480313121677942531, 129049549878268233256883381302815012467835672190109552534355121389997818506160385, 49292541820623609906583302538007088755326533087070104115801862234837985426429697, 7191684930184179482016276395611672639105248126232175323349533708710427892956421, 2746979206949941983182302875628764119171817307595766156998135811615145905740557, 648473825618649048121038413079524682351409714485519861708388359345126257210057, 58472848379039952684853851736901133239741266891456844557261755914039063645794, 22334640661774067356412331900038009953045351020683823507202893507476314037053, 1244666864935793005828156005589143096022236302705537193166716344690085611761, 475420437734698220747368027166749382927701417016557193662268716376935476241, 181594448268301656413948075911105052760867948344134387820089804440720816962, 16374361185569570355515148989381228747223756609038926650176124155306760699, 6254449428820551641549772190170184190608177514674331726439961915653414425, 1476475227036382503281437027911536541406625644706194668152438732346449273, 133133688169362819419341682354326791750874517270785300499298099495818696, 50852543833066829834000968538942350270948615962802847667687312219838755, 19423943329837670082661223262500259061971330617623242503763837163697569, 7419286156446180413982701248558426914965375890066879843604199271253952, 1751455877444438095408940282208383549115781784912085789506677971125378, 157928677948851033162880158208040021697730983590298819190379481318411, 60323387178125067141700354899227346590944200352359771993651057202793, 23041483585524168262220906489642018075101617466780496790573690289968, 8801063578447437644962364569698707634360652047981718378070013667111, 3361707149818144672666187219454104827980338677164658343636350711365, 1284057871006996373036197088663606849580363983512256652839038466984, 490466463202844446442404046536715720760753273372111614880764689587, 44225333398004061429732838340729878012027363723832270745251370289, 16892574194241670428824570378554538679120491007541580961500624834, 6452389184720949856740872794933738025334109298792472139250504213, 137347080577163115432025771710279131845700275212767467264610201, 32423247527351544763402471792982538876233052554697128188128597, 12384578529797304192493293627316781267732493780359086838016392, 690168906931029935139391829792095612517948949963798093315456, 38461794961234640015759308940939757590587318989278841661816, 14691098406862188148944207245954912110548093601382197697835, 5611500259351924431073312796924978741056961814867751431689, 2143402371193585144275731144820024112622791843221056597232, 119447720249892581203851665820676436622934188700177088360, 45624969256769882625644229676772632057353264935332782291, 6656593304481317393598839952151746590023553382130993248, 370959230771131880927453318055001997489772178180790104, 87571595343018854458033386304178158174356588264390370, 33449372971981195681356806732944396691005381570580873, 712011255569818855923257924200496343807632829750245, 271964099255182923543922814194423915162591622175362, 24522987531716273545293036474970821924473060471519, 3577855662560905981638959513147239988861837901112, 199387062373213542599493807777207997205533596336, 76159080909572301618801306271765994056795952743, 6867260041627791953052057353082063289320596021, 619220451666590135228675387863297874269396512, 236521166007575960984144537828161815236311727, 90343046356137747723758225621187571439538669, 21327100234463183349497947550385773274930109, 5034645418285014325766435419644478339818233, 173402521172797813159685037284371942044301, 25299086886458645685589389182743678652930, 9663391306290450775010025392525829059713, 1409869790947669143312035591975596518914, 538522340430300790495419781092981030533, 205697230343233228174223751303346572685, 18547707689471986212190138521399707760, 7084593923980518516849609894969925639, 244006547798191185585064349218729154, 93202207781383214849429075266681969, 35600075545958458963222876581316753, 13598018856492162040239554477268290, 5193981023518027157495786850488117, 1983924214061919432247806074196061, 757791618667731139247631372100066, 178890334785183168257455287891792, 16130531424904581415797907386349, 3807901929474025356630904134051, 555565404224292694404015791808, 131151201344081895336534324866, 659034621587630041982498215, 251728825683549488150424261, 96151855463018422468774568, 14028366653498915298923761, 3311648143516982017180081, 781774079430987230203437, 298611126818977066918552, 70492524767089125814114, 16641027750620563662096, 2427893228399975082453, 573147844013817084101, 12200160415121876738, 1100087778366101931, 259695496911122585, 99194853094755497, 37889062373143906, 14472334024676221, 3416454622906707, 806515533049393, 308061521170129, 117669030460994, 2504730781961, 365435296162, 139583862445, 4807526976, 701408733, 165580141, 63245986, 14930352, 121393, 4181, 987, 233, 55, 3]

real    0m0.017s
user    0m0.011s
sys 0m0.006s

Task 2: Celebrity list

Task

You are given a binary matrix (m × n).

Write a script to find the celebrity, return -1 when none found. A celebrity is someone, everyone knows and knows nobody.

My solution

For input from the command line, I take a JSON string, and convert it to a list of lists of integers (arrays in Perl). The first thing I do is check that the matrix is valid (each row is the same length). Even though the task suggests that m and n could be different values, it makes no sense if it is not square, so I check this as well.

I then have a loop with the index called row_idx and row as the row from the matrix. If this row has any 1 (meaning they know someone), I skip to the next row.

I then check that all other people know this person (column row_idx is 1) or is the person themselves (row_idx == col_idx). If they are, I return the current row_idx value.

If the list is exhausted, I return -1.

def find_celebrity(matrix: list[list[int]]) -> int:
    row_length = len(matrix[0])
    for row in matrix:
        if len(row) != row_length:
            raise ValueError("All rows must have the same length")

    for row_idx, row in enumerate(matrix):
        if sum(row):
            continue

        is_celebrity = all(
            col_idx == row_idx or matrix[col_idx][row_idx]
            for col_idx in range(row_length)
        )
        if is_celebrity:
            return row_idx

    return -1

Examples

$ ./ch-2.py "[[0, 1, 0, 0], [0, 0, 1, 0], [0, 0, 0, 1], [1, 0, 0, 0]]"
-1

$ ./ch-2.py "[[0, 0, 0, 0, 0], [1, 0, 0, 0, 0], [1, 0, 0, 0, 0], [1, 0, 0, 0, 0], [1, 0, 0, 0, 0]]"
0

$ ./ch-2.py "[[0, 1, 0, 1, 0, 1], [1, 0, 1, 1, 0, 0], [0, 0, 0, 1, 1, 0], [0, 0, 0, 0, 0, 0], [0, 1, 0, 1, 0, 0], [1, 0, 1, 1, 0, 0]]"
3

$ ./ch-2.py "[[0, 1, 1, 0], [1, 0, 1, 0], [0, 0, 0, 0], [0, 0, 0, 0]]"
-1

$ ./ch-2.py "[[0, 0, 1, 1], [1, 0, 0, 0], [1, 1, 0, 1], [1, 1, 0, 0]]"
-1

$ ./ch-2.py "[[0, 1, 0, 1, 0, 1], [1, 0, 1, 1, 0, 0], [0, 0, 0, 1, 1, 0], [0, 0, 0, 0, 0, 0], [0, 1, 0, 1, 0, 0], [1, 0, 1, 1, 0, 0]]"
3

Weekly Challenge: Padding and sorting

Simon Green — Mon, 09 Feb 2026 06:53:44 +0000

Weekly Challenge 360

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: Text Justifier

Task

You are given a string and a width.

Write a script to return the string that centers the text within that width using asterisks * as padding.

My solution

If the input_string length is larger or equal to the width variable, I simply return the original string, as no padding is required.

I then create a variable called asterisks which is half the difference in length. Finally, I use the floor and ceil function to add the required number of asterisks. Doing this way ensure that if there is an odd number of asterisks required, the right side will have the additional asterisk.

from math import ceil, floor

def text_justifier(input_string: str, width: int) -> str:
    string_len = len(input_string)
    if string_len >= width:
        return input_string

    asterisks = (width-string_len) / 2
    output_string = "*" * floor(asterisks) + input_string + "*" * ceil(asterisks)

    return output_string

The Perl solution follows the same logic. The floor and ceil functions come from the POSIX module.

Examples

$ ./ch-1.py Hi 5
*Hi**

$ ./ch-1.py Code 10
***Code***

$ ./ch-1.py Hello 9
**Hello**

$ ./ch-1.py Perl 4
Perl

$ ./ch-1.py A 7
***A***

$ ./ch-1.py "" 5
*****

Task 2: Word Sorter

Task

You are give a sentence. Write a script to order words in the given sentence alphabetically but keeps the words themselves unchanged.

My solution

This can be achieved as a one-liner in both Python and Perl.

The Python solution is

def word_sorter(sentence: str) -> str:
    return " ".join(sorted(sentence.split(), key=lambda x: x.lower()))

Breaking this down:

sentence.split() will split the original sentence into a list of strings. The separator is one or more white space characters.
sorted(..., key=lambda x: x.lower()) will sort the list alphabetically in a case insensitive manner.
join(" ", ...) will turn the list into a string, separated by a single space.

The Perl solution uses the same logic, but a slightly different syntax.

sub main ($str) {
    say join( " ", sort { lc($a) cmp lc($b) } split /\s+/, $str );
}

Examples

$ ./ch-2.py "The quick brown fox"
brown fox quick The

$ ./ch-2.py "Hello    World!   How   are you?"
are Hello How World! you?

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

$ ./ch-2.py "Hello, World! How are you?"
are Hello, How World! you?

$ ./ch-2.py "I have 2 apples and 3 bananas!"
2 3 and apples bananas! have I

Weekly Challenge: Digital reduction

Simon Green — Mon, 02 Feb 2026 07:10:55 +0000

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"

Weekly Challenge: Maximum Encryption

Simon Green — Tue, 27 Jan 2026 06:49:48 +0000

Weekly Challenge 358

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 Str Value

Task

You are given an array of alphanumeric string, @strings.

Write a script to find the max value of alphanumeric string in the given array. The numeric representation of the string, if it comprises of digits only otherwise length of the string.

My solution

This task can be achieved in a single line in both Python and Perl, while still maintaining readability. For the Python solution I use list comprehension to convert each string into an integer (if it is all digits) or the length of string (if it isn't). This is wrapped around the max function to return maximum (largest) of these values.

def max_string_value(input_strings: list) -> int:
    return max(int(s) if s.isdigit() else len(s) for s in input_strings)

Not to out-shinned, Perl can achieve similar functionality by using the map function, converting each string into its numeric representation or its length. Perl doesn't have a built-in max function, but it is available from the List::Util package.

sub main (@input_strings) {
    say max( map { /^\d+$/ ? $_ : length($_) } @input_strings );
}

Examples

$ ./ch-1.py "123" "45" "6"
123

$ ./ch-1.py "abc" "de" "fghi"
4

$ ./ch-1.py "0012" "99" "a1b2c"
99

$ ./ch-1.py "x" "10" "xyz" "007"
10

$ ./ch-1.py "hello123" "2026" "perl"
2026

Task 2: Encrypted String

Task

You are given a string $str and an integer $int.

Write a script to encrypt the string using the algorithm - for each character $char in $str, replace $char with the $int th character after $char in the alphabet, wrapping if needed and return the encrypted string.

My solution

For this task, I start by setting $int (called i in Python as int is a reserved word) to be the modulus (remainder) of 26. If that value is 0, I return the original string as no encryption is required.

def encrypted_string(input_string: str, i: int) -> str:
    i = i % 26

    if i == 0:
        return input_string

The next step is creating a mapping table. I start with the variable old_letters that has all the lower case letters of the English alphabet. I create a new_letters string by slicing the old_letters string at the appropriate point. I then double the length of each string by adding the upper case equivalent string. Finally, I use dict(zip()) to convert the strings to a dictionary where the key is the original letter and the value is the new letter.

    old_letters = string.ascii_lowercase
    new_letters = old_letters[i:] + old_letters[:i]
    old_letters += old_letters.upper()
    new_letters += new_letters.upper()
    mapping = dict(zip(old_letters, new_letters))

The final step is to loop through each character and use the mapping dictionary to replace the letter, or use the original character if it is not found (numbers, spaces, punctuation characters, etc).

    return "".join(mapping.get(char, char) for char in input_string)

The Perl code follows the same logic. It uses the splice method to create the new_letters variable, and both old_letters and new_letters are arrays. The mesh function also comes from the List::Util package. Perl will automatically convert a flat list to key/value pairs in the mapping hash.

sub main ( $input_string, $i ) {
    $i %= 26;

    if ( $i == 0 ) {
        say $input_string;
        return;
    }

    my @old_letters = my @new_letters = ( "a" .. "z" );
    push @new_letters, splice( @new_letters, 0, $i );

    push @old_letters, map { uc } @old_letters;
    push @new_letters, map { uc } @new_letters;
    my %mapping = mesh \@old_letters, \@new_letters;


    say join "", map { $mapping{$_} // $_ } split //, $input_string;

Examples

$ ./ch-2.py abc 1
bcd

$ ./ch-2.py xyz 2
zab

$ ./ch-2.py abc 27
bcd

$ ./ch-2.py hello 5
mjqqt

$ ./ch-2.py perl 26
perl