DEV Community: Simon Green

Weekly Challenge: Joining and splitting lists

Simon Green — Tue, 12 May 2026 07:20:12 +0000

Weekly Challenge 373

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: Equal List

Task

You are given two arrays of strings.

Write a script to return true if the two given array represent the same strings otherwise false.

My solution

For input from the command line, I take a string with items concatenated by commas to generate the two lists. This seems to the easiest way to handle this, allowing for empty items as per the fourth example.

def main():
    result = equal_list(sys.argv[1].split(","), sys.argv[2].split(","))
    print("true" if result else "false")

This function is a one liner. I join the items in each list and then compare them to see if they are the same.

def equal_list(arr1: list[str], arr2: list[str]) -> bool:
    return ''.join(arr1) == ''.join(arr2)

The Perl solution has the same functionality.

sub main ( $str1, $str2 ) {
    my @arr1 = split /,/, $str1;
    my @arr2 = split /,/, $str2;

    say join( "", @arr1 ) eq join( "", @arr2 ) ? "true" : "false";
}

Examples

$ ./ch-1.py "a,bc" "ab,c"
false

$ ./ch-1.py "a,bc" "ab,c"
true

$ ./ch-1.py "a,b,c" "a,bc"
true

$ ./ch-1.py "a,bc" "a,c,b"
false

$ ./ch-1.py "ab,c," ",a,bc"
true

$ ./ch-1.py "p,e,r,l" "perl"
true

Task 2: List Division

Task

You are given a list and a non-negative integer.

Write a script to divide the given list into given non-negative integer equal parts. Return -1 if the integer is more than the size of the list.

My solution

For this task, I use the divmod function to calculate the number of items from the list each part needs, and the number of parts that require an extra item. These are stored as the variables item_length and extra_first.

I also have a variable called pos to store the position of the first letter. I have a loop i that runs n times. If i is less than extra_first, I take item_length + 1 items, otherwise item_length times, adding to pos as I go.

def list_division(input_list: list[int], n: int) -> list[list[int]] | None:
    result = []
    pos = 0

    if len(input_list) < n:
        return None

    item_length, extra_first = divmod(len(input_list), n)

    for i in range(n):
        this_length = item_length + 1 if i < extra_first else item_length
        result.append(input_list[pos:pos+this_length])
        pos += this_length

    return result

The Perl solution is similar. It doesn't have the pos variable, as it uses the splice function to remove the necessary number of items from the array. This function returns the items removed.

sub main (@list) {
    # The last value is the 'n' value
    my $n = pop(@list);
    my $length = scalar(@list);

    my @result = ();

    if ( $length < $n ) {
        say -1;
        return;
    }

    my $item_length = int( $length / $n );
    my $extra_first = $length % $n;

    foreach my $i ( 1 .. $n ) {
        my $this_length = $i <= $extra_first ? $item_length + 1 : $item_length;
        push @result, "(" . join( ",", splice( @list, 0, $this_length ) ) . ")";
    }

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

Examples

$ ./ch-2.py 1 2 3 4 5 2
((1,2,3), (4,5))

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

$ ./ch-2.py 1 2 3 2
((1,2), (3))

$ ./ch-2.py 1 2 3 4 5 6 7 8 9 10 5
((1,2), (3,4), (5,6), (7,8), (9,10))

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

$ ./ch-2.py 72 57 89 55 36 84 10 95 99 35 7 
((72,57), (89,55), (36,84), (10), (95), (99), (35))

Weekly Challenge: Distant spaces

Simon Green — Mon, 04 May 2026 07:59:07 +0000

Weekly Challenge 372

Challenge, My solutions

Task 1: Rearrange Spaces

Task

You are given a string text of words that are placed among number of spaces.

Write a script to rearrange the spaces so that there is an equal number of spaces between every pair of adjacent words and that number is maximized. If you can’t distribute, place the extra spaces at the end. Finally return the string.

My solution

This is a little more straight forward than last weeks challenge one task. For this task, I take start by separating the words on whitespace, and count the number of spaces. This is stored in the words list (array in Perl) and spaces variable.

def rearrange_space(input_string: str) -> str:
    words = input_string.split()
    spaces = input_string.count(" ")

To avoid a division by zero error, I handle the case where there is a single word. For this I return the word followed by the required number of spaces. In Python, a string multiple by an integer will repeat the string the specified number of times.

    if len(words) == 1:
        return words[0] + " " * spaces

If there is more than one word, I calculate the spaces_between_words and spaces_at_end using the divmod function. I return the string with the spaces in the appropriate places.

    spaces_between_words, spaces_at_end = divmod(spaces, len(words)-1)
    return (" " * spaces_between_words).join(words) + " " * spaces_at_end

The Perl solution uses the same logic. As it does not have a divmod function, I calculate the two values separately. The x operator in Perl is used for repetition. The expression $#words returns one less than the length of the words array.

sub main ($input_string) {
    my @words  = grep { $_ ne "" } split /\s+/, $input_string;
    my $spaces = ( $input_string =~ tr/ / / );

    if ( $#words == 0 ) {
        say '"' . $words[0] . " " x $spaces . '"';
    }
    else {
        my $spaces_between_words = int( $spaces / $#words );
        my $spaces_at_end        = $spaces % $#words;
        say '"'
          . join( " " x $spaces_between_words, @words )
          . " " x $spaces_at_end . '"';
    }
}

Examples

$ ./ch-1.py "  challenge  "
"challenge    "

$ ./ch-1.py "coding  is  fun"
"coding  is  fun"

$ ./ch-1.py "a b c  d"
"a b c d "

$ ./ch-1.py "  team      pwc  "
"team          pwc"

$ ./ch-1.py "   the  weekly  challenge  "
"the    weekly    challenge "

Task 2: Largest Substring

Task

You are given a string.

Write a script to return the length of the largest substring between two equal characters excluding the two characters. Return -1 if there is no such substring.

My solution

For this task, I start by creating a dict (hash in Perl) called freq with the frequency of each letter. In Python, this is achieved with the Counters function from the collections module.

I then iterate through the dict. If the letter occurs more than once, I calculate the difference between position of the first and last occurrence, minus one. Both Python and Perl have the index and rindex methods to do this. I update the largest value if this is greater than previously found values.

from collections import Counter

def largest_substring(input_string: str) -> int:
    freq = Counter(input_string)
    largest = -1

    for letter, count in freq.items():
        if count > 1:
            substr = input_string.rindex(letter) - input_string.index(letter) - 1
            if substr > largest:
                largest = substr

    return largest

The Perl solution follows the same logic.

sub main ($input_string) {
    my %freq = ();
    $freq{$_}++ foreach ( split //, $input_string );
    my $largest = -1;

    while ( my ( $letter, $count ) = each %freq ) {
        if ( $count > 1 ) {
            my $substr = rindex( $input_string, $letter ) -
              index( $input_string, $letter ) - 1;
            $largest = $substr if ( $substr > $largest );
        }
    }

    say $largest;
}

Examples

$ ./ch-2.py aaaaa
3

$ ./ch-2.py abcdeba
5

$ ./ch-2.py abbc
0

$ ./ch-2.py abcaacbc
4

$ ./ch-2.py laptop
2

$ ./ch-2.py abc
-1

Weekly Challenge: Question the bits

Simon Green — Sun, 03 May 2026 06:07:17 +0000

Weekly Challenge 371

Challenge, My solutions

Task 1: Missing Letter

Task

You are given a sequence of 5 lowercase letters, with one letter replaced by ‘?’. Each letter maps to its position in the alphabet (a = 1, b = 2, …, z = 26). The sequence follows a repeating pattern of step sizes between consecutive letters. The pattern is either a constant step (e.g., +2, +2, +2, +2) or a simple alternating pattern of two distinct steps (e.g., +2, +3, +2, +3).

My solution

Given this is the first task (which is usually more straight forward), my first solution was massively over engineered.

After thinking about it, I came up with the solution that is better. As a bit of an explanation, the ord function (in both Python and Perl) will convert a character to it's character number (for English characters it's ASCII code). ord("a") is 97. The chr function does the opposite, converting a character number to a letter. chr(97) is a.

I start by checking that there is four lower case letters and one question mark.

def missing_letter(seq: list[str]) -> str:
    if (
        len(seq) != 5 or
        seq.count("?") != 1 or
        any(s not in string.ascii_lowercase+"?" for s in seq)
    ):
        raise ValueError("I expected four letters and a question mark")

I then get the position of the question mark.

    pos = seq.index("?")

If this question mark is first, I take the second letter, and subtract the difference between the 4th and 3rd letter.

    if pos == 0:
        return chr(ord(seq[1]) - (ord(seq[3]) - ord(seq[2])))

If the question mark is any other position, I take the letter before it, and add the difference between the two known digits in the same odd/even position. For example if the third letter is missing, I take the second letter and add the difference between the 5th and 4th letters.

     diff_pos = [None, 2, 3, 0, 1][pos]
    return chr(ord(seq[pos-1]) + ord(seq[diff_pos+1]) - ord(seq[diff_pos]))

The Perl solution follows the same logic.

Examples

$ ./ch-1.py a c ? g i
e

$ ./ch-1.py a d ? j m
g

$ ./ch-1.py a e ? m q
i

$ ./ch-1.py a c f ? k
h

$ ./ch-1.py b e g ? l
j

Task 2: Subset Equilibrium

Task

You are given an array of numbers.

Write a script to find all proper subsets with more than one element where the sum of elements equals the sum of their indices.

My solution

The wording of this task changed since it was originally published.

The first part my solution is to find all possible subsets. For this I use bit manipulation to generate and check all possible subsets. The bits value iterates from one (to exclude an empty list) to two less than two to the power of length of the list (i.e. 2^len(seq) - 2). This excludes all the bits been set.

For each iteration, I set the digit_sum and pos_sum variables to zero, and make result an empty list. I have an inner loop through the original list and include the value if its bit is set. The least significant bit is the first number. For example if bits is 6 (binary 110), the second and third values will be used.

If the bit is set for a value, I update digit_sum, pos_sum and result value. After the inner loop completes and if the digit_sum and pos_sum are the same and result has more than one item, I append the result list into the results list.

def subset_equilibrium(nums: list[int]) -> list[list[int]]:
    results = []

    for bits in range(1, 2**len(nums)-1):
        digit_sum = 0
        pos_sum = 0
        result = []
        for pos, value in enumerate(nums):
            if 2 ** pos & bits:
                digit_sum += value
                pos_sum += pos + 1
                result.append(value)

        if digit_sum == pos_sum and len(result) > 1:
            # This matches the criteria
            results.append(result)

    return results

Examples

The order is different than that in the examples on the TWC web site.

$ ./ch-2.py 2 1 4 3
(2, 1), (1, 4), (2, 3), (4, 3)

$ ./ch-2.py 3 0 3 0
(3, 0), (3, 0, 3)

$ ./ch-2.py 5 1 1 1
(5, 1, 1)

$ ./ch-2.py 3 -1 4 2
(3, -1, 4), (3, 2)

$ ./ch-2.py 10 20 30 40 50
()

Weekly Challenge: Popular Scrambling

Simon Green — Sun, 26 Apr 2026 13:56:55 +0000

Weekly Challenge 370

Challenge, My solutions

Task 1: Popular Word

Task

You are given a string paragraph and an array of the banned words.

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

My solution

These are the steps I took to solve this challenge.

Convert the banned words list to lower case, and store this as banned_list.
Create a list called words that has all the words that aren't in the banned_list list or empty.
Create a Counter of the frequency of each word. This is stored in a dict called freq.
Create a list called sorted_freq that stores the keys of the above dict by their frequency.
Return the last item in the sorted_freq list. This is the word that appears the most that isn't banned.

def popular_word(paragraph: str, banned: list[str]) -> str:
    banned_list = list(map(lambda x: x.lower(), banned))
    words = [
        word for word in re.split('[^a-z]+', paragraph.lower())
        if word != '' and word not in banned_list
    ]
    freq = Counter(words)
    sorted_freq = sorted(freq.keys(), key=lambda x: freq[x])
    return sorted_freq[-1]

The Perl solution is very similar.

use List::Util qw(none max);
use List::MoreUtils 'first_value';

sub main (@args) {
    my ( $paragraph, @banned_words ) = @args;

    $paragraph    = lc $paragraph;
    @banned_words = map { lc } @banned_words;

    my %freq = ();
    for my $word ( split /[^a-z]+/, $paragraph ) {
        if ( $word ne '' and none { $_ eq $word } @banned_words ) {
            $freq{$word}++;
        }
    }

    my $max_freq = max( values %freq );
    my $word     = first_value { $freq{$_} == $max_freq } keys %freq;
    say $word;
}

Examples

$ ./ch-1.py "Bob hit a ball, the hit BALL flew far after it was hit." hit
"ball"

$ ./ch-1.py "Apple? apple! Apple, pear, orange, pear, apple, orange." apple pear
"orange"

$ ./ch-1.py "A. a, a! A. B. b. b." b
"a"

$ ./ch-1.py 'Ball.ball,ball:apple!apple.banana' ball
"apple"

$ ./ch-1.py "The dog chased the cat, but the dog was faster than the cat." the dog
"cat"

Task 2: Scramble String

Task

You are given two strings A and B of the same length.

Write a script to return true if string B is a scramble of string A otherwise return false.

String B is a scramble of string A if A can be transformed into B by a single (recursive) scramble operation.

A scramble operation is:

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

My solution

This is another excellent challenge from Roger. For both the Python and Perl solutions, I have a function called same_letters. It takes two strings, and returns True if they have the same frequency of letters (not necessarily in the same order). For the Python solution, I use the Counter function to get the frequency and compare if the resulting dicts are the same.

from collections import Counter

def same_letters(str1: str, str2: str) -> bool:
    return Counter(str1) == Counter(str2)

For the Perl solution, I add 1 for each letter from the first string to the %freq hash, and subtract 1 for each letter from the second string. If there are any items in the hash that aren't zero, it means they are not the same.

use List::Util 'any';

sub same_letters ( $str1, $str2 ) {
    my %freq = ();
    for my $letter ( split //, $str1 ) {
        $freq{$letter}++;
    }
    for my $letter ( split //, $str2 ) {
        $freq{$letter}--;
    }
    if ( any { $_ } values(%freq) ) {
        return undef;
    }
    return 1;
}

For the main function, I have a recursive function which also takes two strings. I start by checking if both string have the same frequency of letters. If they don't, I return False. No amount of splitting or swapping is going to produce a solution!

def scramble_string(str1: str, str2: str) -> bool:
    if not same_letters(str1, str2):
        # If they don't, there is no possible solution
        return False

If the length of the strings is one or two characters, the strings are the same or can be swapped to make them the same, so I return True.

This could be more efficient by also comparing strings of three characters. From abc, it is possible to make all six permutations of the scrambled the string by splitting and/or swapping.

    if len(str1) < 3:
        return True

The next part of the function is to split the string at all possible positions (from 1 to one less than the length of string). I call this variable split_pos.

For each position, I call the scramble_string function again on the left side and right side of the split. If a match is found, I return True.

    for split_pos in range(1, len(str1)):
        if (scramble_string(str1[:split_pos], str2[:split_pos]) and
                scramble_string(str1[split_pos:], str2[split_pos:])):
            return True

It's also possible to swap the parts. This uses negative indexing which counts from the end of the string, not the beginning.

        if (scramble_string(str1[:split_pos], str2[-split_pos:]) and
                scramble_string(str1[split_pos:], str2[:-split_pos])):
            return True

If all that fails, I return False.

    return False

The main function of the Perl solution uses the same logic, and uses the substr function to get the parts of each string.

Examples

$ ./ch-2.py abc acb
true

$ ./ch-2.py abcd cdba
true

$ ./ch-2.py hello hiiii
false

$ ./ch-2.py ateer eater
true

$ ./ch-2.py abcd bdac
false

Weekly Challenge: Group Tag

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

Weekly Challenge 369

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]