DEV Community: Simon Green

Weekly Challenge: Work it

Simon Green — Sun, 28 Jun 2026 11:15:38 +0000

Weekly Challenge 379

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

The etymology of the title is the name of the song by Missy Elliot, which has the line "I put my thing down, flip and reverse it" in reverse. Seems apt for this weeks tasks.

Task 1: Reverse String

Task

You are given a string.

Write a script to reverse the given string without using standard reverse function.

My solution

There are two ways this task can be completed. For the Python solution, I have a loop called i that starts from one less than the length of the string down to zero. For each iteration, I add the character at the position and at it to the result_string variable.

def reverse_string(input_string) -> str:
    result_string = ''

    for i in range(len(input_string) - 1, -1, -1):
        result_string += input_string[i]

    return result_string

For the Perl solution, I iterate over each character in the input_string variable and prepend it to the result_string variable.

sub main ($input_string) {
    my $result_string = "";
    for my $char ( split //, $input_string ) {
        $result_string = $char . $result_string;
    }
    say $result_string;
}

Examples

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

$ ./ch-1.py "reverse the given string"
"gnirts nevig eht esrever"

$ ./ch-1.py "Perl is Awesome"
"emosewA si lreP"

$ ./ch-1.py "v1.0.0-Beta!"
"!ateB-0.0.1v"

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

Task 2: Armstrong Number

Task

You are given two integers, $base and $limit.

Write a script to find all Armstrong numbers in base $base that are less than $limit.

If raising each of the digits of a nonnegative integer to the power of the total number of digits, then taking the sum, equals the original number, it is an Armstrong number.

My solution

Lets start with the boring stuff :) The main function iterates from 0 to one less than limit. If the result of calling the armstrong_sum fuction is the same as the expected integer, I add it to the results_list list (array in Perl).

def armstrong_numbers(base: int, limit: int) -> list[int]:
    result_list = []
    for i in range(limit):
        if armstrong_sum(i, base) == i:
            result_list.append(i)

    return result_list

The armstrong_sum fuction takes the num that is to be calculated, and the base provided from the input. The first step is to calculate each of the digits that make up this number in specified base. For this I use the divmod function and add the modulus to the beginning of the digits list. I repeat the process until the number has been expanded to all digits.

For bases greater than ten, a value in the digits list might be two or more digits long. For example if base is 16, and num is 31, the list would be [1, 15].

def armstrong_sum(num: int, base: int) -> int:
    digits = []
    while True:
        i, j = divmod(num, base)
        digits.insert(0, j)

        if i == 0:
            break

        num = i

The last part is to calculate the sum of each digit to the power of the length of the list.

    l = len(digits)
    return sum(digit ** l for digit in digits)

The Perl solution follows the same logic.

Examples

$ ./ch-2.py 10 1000
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 153, 370, 371, 407]

$ ./ch-2.py 7 1000
[0, 1, 2, 3, 4, 5, 6, 10, 25, 32, 45, 133, 134, 152, 250]

$ ./ch-2.py 16 1000
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 342, 371, 520, 584, 645]

Weekly Challenge: The Second Sum

Simon Green — Mon, 15 Jun 2026 07:30:38 +0000

Weekly Challenge 378

Challenge, My solutions

Task 1: Second Largest Digit

Task

You are given an alphanumeric string.

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

My solution

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

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

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

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

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

Examples

$ ./ch-1.py aaaaa77777
-1

$ ./ch-1.py abcde
-1

$ ./ch-1.py 9zero8eight7seven9
8

$ ./ch-1.py xyz9876543210
8

$ ./ch-1.py 4abc4def2ghi8jkl2
4

Task 2: Sum of Words

Task

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

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

My solution

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

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

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

The sum_of_words function simply checks if the math is valid.

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

The Perl code follows the same logic.

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

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

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

Examples

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

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

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

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

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

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

Weekly Challenge: Existence

Simon Green — Sun, 14 Jun 2026 12:28:52 +0000

Weekly Challenge 377

Challenge, My solutions

Task 1: Reverse Existence

Task

You are given a string.

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

My solution

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

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

    return False

The Perl solution follows the same logic.

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

    say "false";
}

Examples

$ ./ch-1.py abcba
true

$ ./ch-1.py racecar
true

$ ./ch-1.py abcd
false

$ ./ch-1.py banana
true

$ ./ch-1.py hello
true

Task 2: Prefix Suffix

Task

You are given an array of strings.

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

My solution

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

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

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

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

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

}

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

use Algorithm::Combinatorics 'combinations';

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

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

    say $count;
}

Examples

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

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

$ ./ch-2.py abao ab
0

$ ./ch-2.py abab abab
1

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

Weekly Challenge: Double chessboard

Simon Green — Sun, 07 Jun 2026 12:17:33 +0000

Weekly Challenge 376

Challenge, My solutions

Task 1: Chessboard Squares

Task

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

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

My solution

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

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

import re

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

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

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

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

The Perl solution follows the same logic.

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

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

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

Examples

$ ./ch-1.py a7 f4
true

$ ./ch-1.py c1 e8
false

$ ./ch-1.py b5 h2
false

$ ./ch-1.py f3 h1
true

$ ./ch-1.py a1 g7
true

Task 2: Doubled Words

Task

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

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

The script should:

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

My solution

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

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

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

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

import re

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

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

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

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

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

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

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

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

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

    return "\n".join(different_lines)

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

Examples

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

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

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

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

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

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

The Weekly Challenge: The Common Beauty

Simon Green — Mon, 25 May 2026 13:07:54 +0000

Weekly Challenge 375

Challenge, My solutions

Task 1: Single Common Word

Task

You are given two array of strings.

Write a script to return the number of strings that appear exactly once in each of the two given arrays. String comparison is case sensitive.

My solution

For input from the command, I take two space separated strings to generate the two arrays.

For this task, I start by counting the frequency of words in each list (array in Perl).

from collections import Counter

def single_common_word(array1: list[str], array2: list[str]) -> int:
    freq1 = Counter(array1)
    freq2 = Counter(array2)

I then create two sets of words which only appear once in each list.

    unique1 = {word for word in freq1 if freq1[word] == 1}
    unique2 = {word for word in freq2 if freq2[word] == 1}

Finally, I return the length of the intersection of both sets.

    return len(unique1 & unique2)

The Perl solution follows a similar logic. Using the scalar function will return the number of items in the array.

use Array::Utils 'intersect';

sub main ( $str1, $str2 ) {
    my @array1 = split /\s+/, $str1;
    my @array2 = split /\s+/, $str2;

    my ( %freq1, %freq2 );
    $freq1{$_}++ foreach @array1;
    $freq2{$_}++ foreach @array2;

    my @unique1 = grep { $freq1{$_} == 1 } keys %freq1;
    my @unique2 = grep { $freq2{$_} == 1 } keys %freq2;

    say scalar( intersect( @unique1, @unique2 ) );
}

Examples

$ ./ch-1.py "apple banana cherry" "banana cherry date"
2

$ ./ch-1.py "a ab abc" "a a ab abc"
2

$ ./ch-1.py "orange lemon" "grape melon"
0

$ ./ch-1.py "test test demo" "test demo demo"
0

$ ./ch-1.py "Hello world" "hello world"
1

Task 2: Find K-Beauty

Task

You are given a number and a digit k.

Write a script to find the K-Beauty of the given number. The K-Beauty of an integer number is defined as the number of substrings of given number when it is read as a string has length of k and is a divisor of given number.

My solution

This is relatively straight forward. Python treats integers and strings as different types (and methods that can be called). The first thing I do is convert num to a string called s.

def k_beauty(num: int, k: int) -> int:
    s = str(num)

I then generate all possible substrings of length k and check if it is evenly divisible from the original number. If it is I increment the count variable. At the end, I return the final count value.

    count = 0
    for start in range(len(s) - k + 1):
        if num % int(s[start:start+k]) == 0:
            count += 1

    return count

Perl doesn't care (most of the times) about integers vs strings. This makes the code a little more straight forward.

sub main ( $num, $k ) {
    my $count = 0;

    foreach my $start ( 0 .. length($num) - $k ) {
        if ( $num % substr( $num, $start, $k ) == 0 ) {
            ++$count;
        }
    }

    say $count;
}

Examples

$ ./ch-2.py 240 2
2

$ ./ch-2.py 1020 2
3

$ ./ch-2.py 444 2
0

$ ./ch-2.py 17 2
1

$ ./ch-2.py 123 1
2

Weekly Challenge: Vowels and numbers

Simon Green — Tue, 19 May 2026 07:37:16 +0000

Weekly Challenge 374

Challenge, My solutions

Task 1: Count Vowel

Task

You are given a string.

Write a script to return all possible vowel substrings in the given string. A vowel substring is a substring that only consists of vowels and has all five vowels present in it.

My solution

It seems many Team PWC users sent Mohammad "so many emails" when the examples did not match the expected output. As I follow TDD when completing the challenges, I also picked this up.

For this task, I have two loops to generate all possible substrings. The variable start goes from 0 to 5 less than the length of the string. This is because a valid answer needs to have at least five letters. The variable end goes from start + 5 to the length of the string.

I then check if the substr contains each vowel and does not contain any non-vowels. If it does, I add it to the solution list.

def count_vowel(input_string: str) -> list[str]:
    l = len(input_string)
    vowels = ["a", "e", "i", "o", "u"]
    solution = []

    for start in range(l - 4):
        for end in range(start+5, l+1):
            substr = input_string[start:end]
            if (
                all(v in substr for v in vowels) and
                not any(c not in vowels for c in substr)
            ):
                solution.append(substr)

    return solution

The Perl logic uses a variable length instead of end to reflect how the substr function works.

use List::Util 'any';

sub main ($input_string) {
    my $l        = length($input_string);
    my @vowels   = (qw/a e i o u/);
    my @solution = ();

    foreach my $start ( 0 .. $l - 4 ) {
        foreach my $length ( 5 .. $l - $start ) {
            my $substr = substr( $input_string, $start, $length );

            if ( $substr !~ /^[aeiou]+$/ ) {
                next;
            }

            if ( any { index( $substr, $_ ) == -1 } @vowels ) {
                next;
            }

            push @solution, $substr;
        }
    }

    say "(" . join( ", ", map { qq{"$_"} } @solution ) . ")";
}

Examples

The order in the output differs from the examples.

$ ./ch-1.py aeiou
("aeiou")

$ ./ch-1.py aaeeeiioouu
("aaeeeiioou", "aaeeeiioouu", "aeeeiioou", "aeeeiioouu")

$ ./ch-1.py aeiouuaxaeiou
("aeiou", "aeiouu", "aeiouua", "eiouua", "aeiou")

$ ./ch-1.py uaeiou
("uaeio", "uaeiou", "aeiou")

$ ./ch-1.py aeioaeioa
()

Task 2: Largest Same-digits Number

Task

You are given a string containing 0-9 digits only.

Write a script to return the largest number with all digits the same in the given string.

My solution

I always look at the examples to fill in answers that aren't mentioned in the task description. One thing I wasn't sure if the numbers had to be consecutive or not. In this instance, the examples don't help answer that question. I made the decision that they didn't need to be.

My first thought was to sort by the frequency of the numbers and the number if it had the same frequency. But this would work with numbers like 100 (where 0 appears most often).

The solution I came up with was to count the frequency of each number using the Counter function. I then loop through the dict (hash in Perl) to find the highest number.

from collections import Counter
import re

def largest_number(input_string) -> int:
    if not re.search(r'^\d+$', input_string):
        raise ValueError("String should only contain numbers")

    largest_number = 0
    freq = Counter(input_string)

    for digit, count in freq.items():
        number = int(digit * count)
        if number > largest_number:
            largest_number = number

    return largest_number

The Perl solution follows the same logic.

Examples

$ ./ch-2.py 6777133339
3333

$ ./ch-2.py 1200034
4

$ ./ch-2.py 44221155
55

$ ./ch-2.py 88888
88888

$ ./ch-2.py 11122233
222

Weekly Challenge: Joining and splitting lists

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

Weekly Challenge 373

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