DEV Community: Simon Green

Weekly Challenge: An average reflection

Simon Green — Sun, 01 Nov 2026 02:28:44 +0000

Weekly Challenge 397

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: Absent Smallest Positive

You are given an array of integers.

Write a script to return the smallest absent positive integer such that it is strictly greater than the average of all elements in the given array.

My solution

This is relatively straight forward. I start by calculating the average and storing it in the variable average. The result variable one more than the average or 1 if the average is less than 1. I then have a loop that increments result if it is in the ints list (array in Perl).

def asp(ints: list[int]) -> int:
    average = sum(ints) // len(ints)
    result = max(1, average + 1)

    while result in ints:
        result += 1

    return result

The Perl code follows similar logic, using some functions from the List::Util module.

use List::Util qw(any max sum);

sub main (@ints) {
    # Calculate the average
    my $average = sum(@ints) / scalar(@ints);
    my $result = max( 1, int($average) + 1 );
    ++$result while ( any { $_ == $result } @ints );
    say $result;

Examples

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

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

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

$ ./ch-1.py 2 3 7 8
6

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

Task 2: Binary Reflection

You are given an array of integers.

Write a script to sort the given array in ascending order based on the binary reflection of each element. If two different numbers have the same binary reflection, the smaller original number should appear first.

My solution

For this task, I create a function called calc_binary_reflection. Given an integer i, it will convert it to a binary value ([2:] strips the 0b in that string), reverses it and converts to back to an integer.

def calc_binary_reflection(i: int) -> int:
    b = bin(i)[2:]
    return int(b[::-1], 2)

The main function does a double sort. The inner sort ensures that integers with the same reflection integer are sorted numerically, while the outer sort uses the above function.

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

For the Perl solution, I can achieve the same functionality with a single call to the sort function.

sub calc_binary_reflection($i) {
    my $b = sprintf "%b", $i;
    return oct( "0b" . reverse($b) );
}

sub main (@ints) {
    my @sorted_ints = sort {
        calc_binary_reflection($a) <=> calc_binary_reflection($b) || $a <=> $b
    } @ints;

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

Examples

$ ./ch-2.py 3 6 12
(3, 6, 12)

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

$ ./ch-2.py 7 8 9 10
(8, 10, 7, 9)

$ ./ch-2.py 5 9 15 17
(5, 9, 15, 17)

$ ./ch-2.py 11 13 14 19
(14, 13, 11, 19)

The complex square

Simon Green — Sun, 18 Oct 2026 06:53:24 +0000

Weekly Challenge 395

Challenge, My solutions

Task 1: Complex Number

You are given two complex numbers as string.

Write a script to return the multiplication of the given complex numbers. Using the formula: (a + bi) x (c + di) = (ac - bd) + (ad + bc)i.

My solution

The last time I used complex numbers was high school. As a quick refresher, a complex number has two parts: 1) a real number and 2) an imaginary number (square root of -1).

Python has builtin support for complex numbers. I have a function called to_complex which converts the provided value to a complex number.

def to_complex(s: str) -> complex:
    if m := re.search(r"^(-?\d+)\+(\d+)i$", s):
        return complex(int(m.group(1)), int(m.group(2)))
    if m := re.search(r"^(-?\d+)\+\((-\d+)\)i$", s):
        return complex(int(m.group(1)), int(m.group(2)))
    raise ValueError("Unexpected input: %s", s)

The main function converts the two strings into complex numbers, performs the multiplication, and returns the string in the expected format.

def complex_number(num1: str, num2: str) -> str:
    c1 = to_complex(num1)
    c2 = to_complex(num2)

    result = c1 * c2
    result_real = int(result.real)
    result_imag = int(result.imag)

    return (
        f"{result_real}+{'('+str(result_imag)+')' if result_imag < 0 else result_imag}i"
    )

For the Perl solution, I went old school and performed the multiplication manually.

sub to_complex($s) {
    if ( $s =~ /^(-?\d+)\+(\d+)i$/ ) {
        return $1, $2;
    }
    if ( $s =~ /^(-?\d+)\+\((-\d+)\)i$/ ) {
        return $1, $2;
    }
    die "Unexpected input: $s\n";
}

sub main ( $num1, $num2 ) {
    my ( $r1, $i1 ) = to_complex($num1);
    my ( $r2, $i2 ) = to_complex($num2);

    my $result_real = $r1 * $r2 - $i1 * $i2;
    my $result_imag = $r1 * $i2 + $i1 * $r2;
    if ( $result_imag >= 0 ) {
        say "$result_real+${result_imag}i";
    }
    else {
        say "$result_real+($result_imag)i";
    }
}

Examples

$ ./ch-1.py 1+1i 1+1i
0+2i

$ ./ch-1.py "1+(-1)i" "1+(-1)i"
0+(-2)i

$ ./ch-1.py 0+3i 0+4i
-12+0i

$ ./ch-1.py 3+4i "3+(-4)i"
25+0i

$ ./ch-1.py "50+(-20)i" -10+30i
100+1700i

Task 2: Word Squares

You are given a list of equal lengths words.

Write a script to arrange a set of words into a grid that reading across any row gives the exact same word as reading down its corresponding column

My solution

My solution for this task has a recursive function called find_word_squares, it takes two lists (array in Perl). The first list is called words which has the list of words provided by the user. The second parameter is words_so_far which is a list of words that make up the solution.

I start by setting the words_so_far variable as an empty list on the first call. If a valid solution is found, I return that to the calling function.

def find_word_squares(
    words: list[str], words_so_far: list[str] | None = None
) -> list[str] | None:
    if words_so_far is None:
        words_so_far = []

    length = len(words[0])
    if len(words_so_far) == length:
        return words_so_far

The next step is to find possible next words. For this I generate the starts_with value with the letters the next word must start with. I also exclude any words already used. For each possible word (if any), I call the function again with an update words_so_far value.

    this_pos = len(words_so_far)
    starts_with = "".join(word[this_pos] for word in words_so_far)
    possible_next_words = [
        word
        for word in words
        if word not in words_so_far and word.startswith(starts_with)
    ]

    for word in possible_next_words:
        result = find_word_squares(words, words_so_far + [word])
        if result:
            return result

If no solution is found, I return None.

    return None

The main function checks that all words are the same length and calls the recursive function for the first time.

def word_squares(words: list[str]) -> list[str] | None:
    # Check all words are the same length
    if any(len(word) != len(words[0]) for word in words):
        raise ValueError("All words must be the same length")

    # Call a recursive function to find the correct word order
    return find_word_squares(words)

The Perl solution follows the same logic.

Alternate solution

An alternative option would be to calculate all permutations and see if it is valid. This is relatively inexpensive for the provided examples. There are only 120 permutations of 5 words. However if there were 17 words, that blows out to 355 trillion permutations. My solution still computes a large list quickly.

$ time ./ch-2.py ABC CDE EFG GHI IJK KLM MNO OPQ QRS STU UVW WZY SUN USE NET SEE TEN
['SUN', 'USE', 'NET']

real    0m0.021s
user    0m0.014s
sys 0m0.006s

Examples

$ ./ch-2.py MA AM MY ME
['MA', 'AM']

$ ./ch-2.py SUN USE NET SEE TEN
['SUN', 'USE', 'NET']

$ ./ch-2.py BOAT TEAL AREA TSAR OGRE
['BOAT', 'OGRE', 'AREA', 'TEAL']

$ ./ch-2.py CARD AREA REAR DART
['CARD', 'AREA', 'REAR', 'DART']

$ ./ch-2.py HEART TREND EMBER RESIN ABUSE
['HEART', 'EMBER', 'ABUSE', 'RESIN', 'TREND']

Weekly Challenge: The one about alternating

Simon Green — Sun, 11 Oct 2026 13:06:18 +0000

Weekly Challenge 394

Challenge, My solutions

Task 1: Alternate Case

You are given a string containing an equal number of uppercase and lowercase English letters.

Write a script to the minimum number of adjacent character swaps needed to turn the given string into an alternate case string.

My solution

I'm pretty sure I've overengineered this solution, given that it is task one. For this I start with two constants called UCL and LCL which is a set of upper case letters and lower case letters respectively.

import string

UCL = set(string.ascii_uppercase)
LCL = set(string.ascii_lowercase)

I then have a function is_alt_case. It determines if the string is alternating between upper and lower case letters. If it is, it will return None (-1 for the Perl solution). If it finds a letter with incorrect case, it will find the position of the next letter in the correct case and returns one less than that position. This represents the letters that will be swapped.

def is_alt_case(s: str, upper_first: bool) -> int|None:
    for pos, letter in enumerate(s):
        next_letters = UCL if (upper_first + pos) % 2 else LCL
        if letter in next_letters:
            continue

        for i in range(pos+ 1, len(s)):
            if s[i] in next_letters:
                return i-1

    return None

As strings are immutable in Python, I have function called swap_letters. Given a string s and an integer pos, it will swap the letters in position pos and pos+1.

def swap_letters(s: str, pos: int) -> str:
    return s[:pos] + s[pos+1] + s[pos] + s[pos+2:]

The main function starts by checking that the strings is valid, specifically it contains only letters, has an even number of letters and half of them are upper case.

def alt_case(input_string: str) -> int:
    half_length = len(input_string) // 2
    if len(input_string) % 2:
        raise ValueError("String must have an even number of characters")
    if not re.search("^[a-z]+$", input_string, flags=re.I):
        raise ValueError("The word contain non-letter characters")
    if sum(1 for letter in input_string if letter in UCL) != half_length:
        raise ValueError(
            "Letter must contain the same number of upper and lower case letters"
        )

As I don't know if the string should start with an upper case or lower case letter, I try both and return the one with the minimum number of moves.

I have a loop that calls is_alt_case until it returns None (meaning the string is correct) counting moves for each move made.

    move_list = []

    for upper_first in {True, False}:
        s = input_string
        moves = 0
        while (next_swap_pos := is_alt_case(s, upper_first)) is not None:
            s = swap_letters(s, next_swap_pos)
            moves += 1

        move_list.append(moves)

    return min(move_list)

Examples

$ ./ch-1.py aAbB
0

$ ./ch-1.py AAbb
1

$ ./ch-1.py AAAbbb
3

$ ./ch-1.py aABb
1

$ ./ch-1.py bBBAaa
2

Task 2: Alternating Vowels Consonants

You are given three strings containing English alphabetic characters.

Find all the longest contiguous substrings common to all three strings that strictly alternate between vowels and consonants.

My solution

For this challenge, I define a function called is_alt_vc. It checks if the substring alternates between vowels and consonants. For the first letter, it sets vowel_next to True or False depending on the type of it. It then alternates this variable for each subsequent letter.

def is_alt_vc(substr: str) -> bool:
    # Start with the type of the fist letter
    vowel_next = substr.lower()[0] in VOWELS

    for letter in substr.lower():
        if vowel_next ^ (letter in VOWELS):
            # The letter is the wrong type
            return False
        # The next letter needs to be the opposite
        vowel_next = not(vowel_next)

    # The word alternates between vowels and consonants
    return True

The main function starts by checking that all the supplied words only contain letters of the English alphabet.

def alt_vc(words: list[str]) -> list[str]:
    if not all(re.search('^[a-z]+$', word, flags=re.I) for word in words):
        raise ValueError("Some words contain non-letters")

I then find the shortest_word (the first if there is more than one of the same length) and the length of that word. The maximum possible solution is this length.

    shortest_word = sorted(words, key=len)[0]
    min_length = len(shortest_word)

I then have a double loop. The outer loop is called length and starts with min_length and decreases to 1. The inner loop is called start representing the starting position of the substr, the value is 0 up to the min_length - length. I then generate the substring, and check if it appears in all words and alternates between vowels and consonants.

If one or more substrings of a specific length is found, I return all the substrings found. If the loops are exhausted, I return an empty list (array in Perl).

    result = []
    for length in range(min_length, 0, -1):
        for start in range(min_length-length+1):
            substr = shortest_word[start:start+length]
            if all(substr in word for word in words) and is_alt_vc(substr):
                result.append(substr)

        if result:
            return sorted(result)

    return []

Examples

$ ./ch-2.py relocate delocate allocate
("locate")

$ ./ch-2.py apple banana cherry
()

$ ./ch-2.py navigate cavity gravity
("avi")

$ ./ch-2.py pedalgia pedalboard pedantic
("peda")

$ ./ch-2.py schoolmaster schoolhouse schooling
("ho", "ol")

Weekly Challenge: Pythagoras Prime

Simon Green — Sun, 04 Oct 2026 14:40:55 +0000

Weekly Challenge 393

Challenge, My solutions

Task 1: Pythagoras Multiplied

You are given a positive integer n.

Find the number of all positive integer triplets (a, b, c) so that a² + b² = c² and a, b and c are integers <= n.

My solution

Since $a and $b are special variables in Perl, I call the values i, j and k. I start my solution by creating a function called is_valid_pythagoras which checks that k is an integer and it is less than or equal to n.

def is_valid_pythagoras(k: int | float, n: int) -> bool:
    return k == int(k) and k <= n

The main function finds all combinations of i and j (between 1 and n), and checks that k (being the square root of i² + j²) matches the criteria. As i and j can be swapped, I count two at a time.

def pythagoras_multiplied(n: int) -> int:
    return sum(
        2
        for i, j in combinations(range(1, 1 + n), 2)
        if is_valid_pythagoras(math.sqrt(i**2 + j**2), n)
    )

The Perl solution follows similar logic. As Algorithm::Combinatorics raises a warning if the length of the array is less than two, I handle the case if n is 1 manually.

use Algorithm::Combinatorics 'combinations';

sub main ($n) {
    my $count = 0;

    if ($n == 1) {
        # Prevent Parameter k is greater than the size of data warning
        say 0;
        return;
    }
    # Generate all combinations
    my $iter = combinations( [ 1 .. $n ], 2 );

    # Loop through all combinations of 1 <= i < j <= n
    while ( my $combination = $iter->next ) {
        my ( $i, $j ) = @$combination;
        # Check that 'k' is an integer and less than or equal to 'n'
        my $k = sqrt( $i**2 + $j**2 );
        if ( $k == int($k) and $k <= $n ) {
            # We add two to count the opposite a and b values
            $count += 2;
        }
    }

    # Return the result
    say $count;
}

Examples

$ ./ch-1.py 20
12

$ ./ch-1.py 7
2

$ ./ch-1.py 1
0

$ ./ch-1.py 15
8

$ ./ch-1.py 30
22

Task 2: Prime Step

You are given a string with English alphabetic characters only.

What is the absolute difference of the sum of the ASCII values of the characters in the string to the nearest prime number?

My solution

I start this challenge, by creating a function called is_prime. Given an integer it will return a boolean if the number is a prime.

def is_prime(n: int) -> bool:
    for i in range(2, int(math.sqrt(n)) + 1):
        if n % i == 0:
            return False

    return n >= 2

In the main function, I start by checking that the input is valid.

def prime_step(word: str) -> int:
    if not re.search(r"^[A-Za-z]+$", word):
        raise ValueError("Input can only contain English letters")

I then calculate the sum of ASCII representation of the supplied string.

    target = sum(ord(char) for char in word)

If target is a prime, I return 0. Otherwise, I have a loop called diff that increments by one and checks if the target-diff to target+diff is a prime. If it is, the code will return that function. If it isn't, the loop runs again after incrementing the diff value.

    if is_prime(target):
        return 0

    diff = 1
    while True:
        if is_prime(target - diff) or is_prime(target + diff):
            return diff
        diff += 1

Examples

$ ./ch-2.py hello
9

$ ./ch-2.py football
2

$ ./ch-2.py a
0

$ ./ch-2.py challenge
2

$ ./ch-2.py perl
2

Weekly Challenge: The palindromic length

Simon Green — Sun, 27 Sep 2026 13:19:28 +0000

Weekly Challenge 392

Challenge, My solutions

Task 1: Convert Palindrome

You are given a string.

Write a script to convert the given string to palindrome by adding characters in front of it.

My solution

Being the first challenge, this is pretty straight forward. I need to find the longest palindrom substring pinned to the first letter. Only the characters after this need to prepended to input_string.

I have a loop called pos that goes from the length of string to 2. For each iteration, it checks if the substr from the 1st position to the pos position is a palindrome. If it is, I return the characters after pos reversed, and the original string.

If the loop is exhausted, it will return all but the first letter reversed before the original string.

The Perl solution follows the same logic.

def convert_palindrome(input_string: str) -> str:
    for pos in range(last_pos, 1, -1):
        substr = input_string[:pos]
        if substr == substr[::-1]:
            return input_string[last_pos : pos - 1 : -1] + input_string

    return input_string[last_pos:0:-1] + input_string

Examples

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

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

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

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

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

Task 2: Words Length Product

You are given an array of strings.

Write a script to return the maximum value of len($words[i]) × len($words[j]) where the two words do not share common letters. If no such two words exist, return 0.

My solution

For the Python solution, this is a one liner. It uses the combinations function from itertools to generate all combinations of pairs of words. It checks that the letters are unique, and returns the maximum of the product of the pair of words that match the criteria. The default=0 part ensures an error is not raised if there are no unique words.

from itertools import combinations

def word_length_product(words: list[str]) -> int:
    return max(
        (
            len(word1) * len(word2)
            for word1, word2 in combinations(words, 2)
            if not any(letter in word2 for letter in word1)
        ),
        default=0,
    )

As Perl does not have list comprehension, this solution is a little more verbose. I start by defining a function called unique_letters that check for any characters in one word doesn't appear in the other.

sub unique_letters ( $word1, $word2 ) {
    # Check no letters appear in both words
    for my $letter ( split //, $word1 ) {
        return 0 if index( $word2, $letter ) != -1;
    }
    return 1;
}

The main function follows the same logic as the Python solution.

use Algorithm::Combinatorics 'combinations';

sub main (@words) {
    my $max_length = 0;

    # Loop through each pair combination
    my $iter = combinations( \@words, 2 );
    while ( my $word_pairs = $iter->next() ) {
        my ( $word1, $word2 ) = @$word_pairs;
        if ( unique_letters( $word1, $word2 ) ) {
            my $length = length($word1) * length($word2);
            if ( $length > $max_length ) {
                $max_length = $length;
            }
        }
    }

    say $max_length;
}

Examples

$ ./ch-2.py a ab abc d de def
9

$ ./ch-2.py a aa aaa aaaa
0

$ ./ch-2.py meet app code sky bold
16

$ ./ch-2.py a ab abc abcd efghi
20

$ ./ch-2.py xyz w abcdefg hij
21

The Weekly Challenge: Arranging things

Simon Green — Sun, 20 Sep 2026 12:35:05 +0000

Weekly Challenge 391

Challenge, My solutions

Task 1: Array Median

You are given two sorted arrays.

Write a script to merge the two given sorted arrays and return the median of the merged array.

My solution

For input from the command line, I take two strings and find all integer values to create each list.

import re

def main():
    arr1 = [int(i) for i in re.findall(r"\d+", sys.argv[1])]
    arr2 = [int(i) for i in re.findall(r"\d+", sys.argv[2])]
    result = array_median(arr1, arr2)
    print(float(result))

Python has a median function from the statistics module. Therefore the solution is to join the two lists, and return the median.

from statistics import median

def array_median(arr1: list[int], arr2: list[int]) -> float:
    return median(arr1 + arr2)

For the Perl solution, I went old school and wrote a function that sorts the joined array. If there are an odd number of items, it returns the middle number. If there is an even number, it takes the average of the two middle values.

sub main ( $str1, $str2 ) {
    my @arr1 = ( $str1 =~ /(\d+)/g );
    my @arr2 = ( $str2 =~ /(\d+)/g );

    my @sorted_array = sort { $a <=> $b } ( @arr1, @arr2 );
    my $half         = int( $#sorted_array / 2 );
    my $median =
      $#sorted_array % 2
      ? ( $sorted_array[$half] + $sorted_array[ $half + 1 ] ) / 2
      : $sorted_array[$half];

    say sprintf( "%0.1f", $median );
}

Examples

$ ./ch-1.py 2 4
3.0

$ ./ch-1.py "1 2 3" "7 8 9 10"
7.0

$ ./ch-1.py "" "10 20 30 40"
25.0

$ ./ch-1.py 100 "1 2 3 4 5 6 7"
4.5

$ ./ch-1.py "1 2 2" "2 2 3"
2.0

Task 2: Arrange Box

You are given an array of box dimensions.

Write a script to determine the maximum number of these boxes that can fit inside each other in a single stack. For a box to fit inside another, it must be smaller in both dimensions.

My solution

For the Python solution, I define a dataclass called Box, which stores the width and height of each box. This makes the code easier to understand, as I can use the width and height attributes.

from dataclasses import dataclass

@dataclass
class Box:
    width: int
    height: int

I then create a function called stackable_boxes. Given a tuple of Boxes it determines if they can be arranged correctly. It first checks that the widths and heights of the boxes are unique. It then sorts them by width and ensures the corresponding height is also in ascending order.

def stackable_box(boxes) -> int:
    box_count = len(boxes)
    if len(set(box.width for box in boxes)) != box_count:
        return False
    if len(set(box.height for box in boxes)) != box_count:
        return False

    sorted_boxes = sorted(boxes, key=lambda box: box.width)
    heights = [box.height for box in sorted_boxes]
    return heights == sorted(heights)

The main function starts by converting the boxes into a Box object, if it isn't already. For input from the command line, I take pairs of integers as the dimension of each box.

I then have a loop called length. It starts with the number of boxes, and ends at 2. For each length, I use the combinations function from the itertools module to generate all combinations of the specified number of boxes. I call the stackable_boxes function for each combination, and return the length if the boxes can be arranged. If the loop is exhausted, I return 1.

def arrange_box(*boxes) -> int:
    boxes = [box if isinstance(box, Box) else Box(*box) for box in boxes]
    for length in range(len(boxes), 1, -1):
        for box_set in combinations(boxes, length):
            if stackable_box(box_set):
                return length

    return 1

The Perl solution uses similar logic.

Examples

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

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

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

$ ./ch-2.py 2 100 3 200 4 300 5 50 5 400
4

$ ./ch-2.py 10 20 15 10 20 30 12 18 16 25
3

Weekly Challenge: The First Expansion

Simon Green — Sun, 13 Sep 2026 12:14:09 +0000

Weekly Challenge 390

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. 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: Decode String

You are given an encoded string.

Write a script to return the decoded string of the given encoded string.

The encoding rule is: K[encoded_string], where the encoded_string inside the square brackets is repeated exactly K > 0 times.

My solution

This task is very similar to the second challenge three weeks ago. My commentary there applies equally here.

I start with a function called expand_brackets which will expand the inner most brackets preceeded by a number using that number match_obj[1] to multiple the characters inside the bracket match_obj[2].

def expand_brackets(match_obj: re.Match) -> str:
    multiplier = int(match_obj[1])
    s = match_obj[2]
    return s * multiplier

The main decode_string function starts by expanding all brackets using a regular expression and the expand_brackets callback function. It then checks that all brackets have been removed, and returns the string.

import re

def decode_string(input_string: str) -> str:
    while re.search(r"\d+\[[A-Z0-9]+\]", input_string, flags=re.I):
        input_string = re.sub(
            r"(\d+)\[([^\[\]]+)\]", expand_brackets, input_string, flags=re.I
        )

    if "[" in input_string or "]" in input_string:
        raise ValueError("Invalid input")

    return input_string

Examples

$ ./ch-1.py "2[3[a]]"
"aaaaaa"

$ ./ch-1.py "10[a]"
"aaaaaaaaaa"

$ ./ch-1.py "a2[b]c3[d]e"
"abbcddde"

$ ./ch-1.py "2[a2[b]c]"
"abbcabbc"

$ ./ch-1.py "1[a]2[b3[c]]"
"abcccbccc"

Task 2: Order Characters

You are given a string $s (containing only alphabetic characters) and an integer $k > 0.

Write a script to choose one of the first $k letters of given string and append it at the end of the string. You keep doing this until you have lexicographically smallest string and return the string.

My solution

Picking from 1 to k, and repeating sounds like a task that requires a recursive function. The order_characters function takes the input values, and calls the find_string function to find all strings that can be computed. It then sorts the set, and returns the first one alphabetically.

def order_characters(input_string: str, k: int) -> str:
    strings_found = set()
    find_string(input_string, k)
    return sorted(strings_found)[0]

The find_string function (which is called from above) starts by adding the current word to the strings_found set. It then has a loop from 1 to k. For each iteration it generates new_word by moving one character to the end of the string. If that string is not in the strings_found set, the recursive function is called again.

def find_string(word, k):
    nonlocal strings_found

    strings_found.add(word)
    for i in range(k):
        new_word = word[:i] + word[i + 1 :] + word[i]
        if new_word not in strings_found:
            find_string(new_word, k)

Examples

$ ./ch-2.py dbca 1
"adbc"

$ ./ch-2.py geeks 2
"eegks"

$ ./ch-2.py cbaed 3
"abcde"

$ ./ch-2.py fedcba 4
"abcdef"

$ ./ch-2.py perl 1
"erlp"

$ ./ch-2.py oloolooo 1
"looloooo"

$ ./ch-2.py oloooolo 1
"looloooo"

Weekly Challenge: Zigzag notes

Simon Green — Sun, 06 Sep 2026 11:48:09 +0000

Weekly Challenge 389

Challenge, My solutions

Task 1: Reorder Notes

You are given an array [composer, notes, permutation], reconstruct the melody by using each permutation value as the destination position of the corresponding note. Use no explicit for, foreach, or while loops. Output each result as COMPOSER => reordered notes.

ASSUMPTION: Input is valid; the notes array and permutation array have identical lengths, and the permutation contains each position from 1 to N exactly once.

My solution

For input from the command line, I take the first value as the composer. The first half of the remaining values are the notes list (array in Perl), with the remainder making up the positions list. As it's 2016, I use ♭ and ♯ for flat and sharp, but it will accept b and # as well.

This becomes fun when you can't use for and while loops. For this I start by checking the assumptions that the input is valid. I check that the lengths of notes and positions are the same, the notes are valid, and the positions list has each value from 1 to the length of the list.

As I can't use a for loops, I use the filter function. This returns a generator, so I wrap it in the list() function to see if there are any issues

def reorder_notes(composer: str, notes: list[str], positions: list[int]) -> str:
    if len(notes) != len(positions):
        raise ValueError("The two lists must be the same length")
    if list(filter(lambda note: not re.search("^[A-G][♯♭#b]?$", note), notes)):
        raise ValueError("Invalid note")
    if list(filter(lambda i: i not in positions, range(1, len(positions) + 1))):
        raise ValueError("Missing position")

With that done, I convert the two lists into a dictionary (hash in Perl). The key is the position and the value is the note.

    music = dict(zip(positions, notes))

The last step is to sort the keys of the music dictionary (by their position) and using the map function to return the note at that position.

    ordered_music = list(map(lambda note: music[note], sorted(music)))
    return composer.upper() + " => " + " ".join(ordered_music)

The Perl solution follows the same logic, and makes use of the any, mesh and zip functions from List::Util. The most tricky part was checking the @positions array is valid. In the end, I use the zip function with two arrays, the first is the expected values and the second is the values provided sorted numerically.

use List::Util qw(any mesh zip);

sub main (@args) {
    my $composer  = shift(@args);
    my $split_pos = ( $#args + 1 ) / 2;
    my @notes     = @args[ 0 .. $split_pos - 1 ];
    my @positions  = @args[ $split_pos .. $#args ];

    if ( $#notes != $#positions ) {
        die "The two lists must be the same length\n";
    }
    if ( any { $_ !~ /^[A-G][♯♭#b]?$/ } @notes ) {
        die "Invalid note\n";
    }
    if ( any { $_->[0] != $_->[1] }
        zip( [ 1 .. $#notes + 1 ], [ sort { $a <=> $b } @positions ] ) )
    {
        die "Missing position\n";
    }

    my %music = mesh \@positions, \@notes;

    my @ordered_music = map { $music{$_} } sort { $a <=> $b } keys %music;
    say uc($composer) . " => " . join( " ", @ordered_music );
}

Examples

$ ./ch-1.py Bach C D E F♯ G A B 7 1 6 2 5 3 4
BACH => D F♯ A B G E C

$ ./ch-1.py Beethoven C D F♯ G A♭ 1 3 5 2 4
BEETHOVEN => C G D A♭ F♯

$ ./ch-1.py Brahms C D♭ E♭ F G A♭ B♭ C D 9 3 7 1 8 5 2 6 4
BRAHMS => F B♭ D♭ D A♭ C E♭ G C

$ ./ch-1.py Bruckner G F♯ B♭ C D E♭ F 4 7 2 6 1 5 3
BRUCKNER => D B♭ F G E♭ C F♯

$ ./ch-1.py Berg C♯ 1
BERG => C♯

Task 2: ZigZag Subarray

You are given an array of integers.

Write a script to find the length of the longest contiguous subarray where the numbers alternate between strictly increasing and strictly decreasing (a ZigZag pattern).

A sequence of numbers $A = [a0, a1, …, ak] with length $k >= 1 is considered a ZigZag sequence if every adjacent pair alternates direction: a_0 < a_1 > a_2 < a_3 > ... OR a_0 > a_1 < a_2 > a_3 < ...

NOTE: A single element (length 1) or any two distinct elements (length 2) are automatically valid ZigZag sequences. Equal adjacent numbers (e.g., 5, 5) break the pattern.

My solution

I start this challenge by defining a function called get_change. It takes the list (array in Perl) ints, and a position p. It returns the difference between ints[p] and ints[p+1]. If the second value is higher it returns h, s if the values are the same or l if it is lower.

def get_change(ints, p):
    i = ints[p]
    j = ints[p + 1]
    if i == j:
        return "s"
    return "h" if j > i else "l"

The main function converts all the differences in values to a string of h, s and l. It then uses a regular expression to find all sub-strings matching h?(lh)+ or l?(hl)+ or a single h or l. It returns the longest sub-string length plus 1, or 1 if all the values are the same.

def zigzag_subway(ints: list[int]) -> int:
    pattern = "".join(get_change(ints, i) for i in range(len(ints) - 1))

    return max(
        (
            len(match.group(0)) + 1
            for match in re.finditer("(h?(?:lh)+|l?(?:hl)+|[hl])", pattern)
        ),
        default=1,
    )

The Perl solution follows the same logic.

use List::Util 'max';

sub get_change( $ints, $p ) {
    my $i = $ints->[$p];
    my $j = $ints->[ $p + 1 ];
    if ( $i == $j ) {
        return "s";
    }
    return $j > $i ? "h" : "l";
}

sub main (@ints) {
    my $pattern = join "", map { get_change( \@ints, $_ ) } ( 0 .. $#ints - 1 );

    say max(
        map ( { length($_) + 1 } $pattern =~ /(h?(?:lh)+|l?(?:hl)+|[hl])/g ),
        1 );
}

Examples

$ ./ch-2.py 9 4 2 10 7 8 8 1 9
5

$ ./ch-2.py 1 7 4 9 2 5
6

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

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

$ ./ch-2.py 10 20 15 12 18
3

Weekly Challenge: Secret Words

Simon Green — Sun, 30 Aug 2026 13:28:14 +0000

Weekly Challenge 388

Challenge, My solutions

Task 1: Dyck Words

A Dyck Word of order $n is a string of length 2 × $n consisting of $n U (Up) characters and $n D (Down) characters such that no initial prefix of the string contains more Ds than Us.

Write a script to return a list of all valid Dyck words of length 2 × $n, sorted in lexicographical (alphabetical) order.

My solution

For this task, I have a recursive function called dyck_words. It takes n as an input, as well as dyck which is the word found so far. On the first call dyck is set to None (undef in Perl).

The first thing I do is set dyck to "U" if it is None (i.e. the first call of the recursive function). The first move must be up. If the length of dyck is 2 × n, I return that back as a list as it is a valid solution.

def dyck_words(n: int, dyck: str | None = None) -> list[str]:
    if dyck is None:
        dyck = "U"

    if len(dyck) == 2 * n:
        return [dyck]

The recursive part of the function starts by counting how many steps up we are. This is stored in the variable steps, by counting the number of ups and subtracting the number of downs.

    steps = dyck.count("U") - dyck.count("D")
    solutions = []

If the steps is greater than zero, the next move can be down. I call the function again adding D to the dyck variable. If steps is less than the remaining characters left to fill 2 × n - len(dyck), it is possible to move up as there are enough down positions remaining to get back to zero. In the case, I call the function again adding U to the dyck variable.

Finally I return all valid solutions up the recursive chain. As the down is called before the up, the list will already be sorted alphabetically.

    if steps > 0:
        down = dyck_words(n, f"{dyck}D")
        if down:
            solutions.extend(down)
    if steps < 2 * n - len(dyck):
        up = dyck_words(n, f"{dyck}U")
        if up:
            solutions.extend(up)

    return solutions

Examples

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

$ ./ch-1.py 2
("UDUD", "UUDD")

$ ./ch-1.py 3
("UDUDUD", "UDUUDD", "UUDDUD", "UUDUDD", "UUUDDD")

$ ./ch-1.py 4
("UDUDUDUD", "UDUDUUDD", "UDUUDDUD", "UDUUDUDD", "UDUUUDDD", "UUDDUDUD", "UUDDUUDD", "UUDUDDUD", "UUDUDUDD", "UUDUUDDD", "UUUDDDUD", "UUUDDUDD", "UUUDUDDD", "UUUUDDDD")

$ ./ch-1.py 0
()

Task 2: Secret Santa

A company with $n employees is running a Secret Santa exchange. Each employee buys one gift and receives one gift.

Write a script to return the total number of valid gift assignments where no employee receives the gift they originally bought (i.e., employee $i must not be assigned gift $i).

My solution

Completing this challenge, is an example of trial and error. The first thing I looked for was a pattern. If n is 5, the answer is 44 (prime factors 2 × 2 × 11), so that wasn't the answer.

The next iteration was to write a recursive function that found all circular references. That worked, but didn't produce the desired results.

I then realized that for this task, the links didn't need to be circular. In other words, if you have four people, the first two could swap gifts and the other two can swap gifts.

In the end I went for a solution that brute forces the answer. I calculate all permutations for 0 to n-1 and count the rows where a person is not gifting it to themselves.

from itertools import permutations

def secret_santa(people: int) -> int:
    count = 0

    for p in permutations(range(people)):
        if not any(i == j for i, j in enumerate(p)):
            count += 1

    return count

The Perl solution follows the same logic.

use Algorithm::Combinatorics 'permutations';
use List::Util 'none';

sub main ($people) {
    my $count  = 0;
    my @people = ( 0 .. $people - 1 );

    my $permutations = permutations( \@people );
    while ( my $p = $permutations->next() ) {
        if ( none { $p->[$_] eq $_ } ( 0 .. $people - 1 ) ) {
            $count++;
        }
    }

    say $count;
}

The drawback with this method is that if n is larger than 10, it can take a little while to produce a result. On my home PC, it took 24 seconds to find with 11 people, there are 14,684,570 possible combinations.

Examples

$ ./ch-2.py 1
0

$ ./ch-2.py 2
1

$ ./ch-2.py 3
2

$ ./ch-2.py 4
9

$ ./ch-2.py 5
44

Weekly Challenge: Rearranging Atoms

Simon Green — Sun, 23 Aug 2026 11:32:50 +0000

Weekly Challenge 387

Challenge, My solutions

Task 1: Rearrange Binary String

You are given a binary string string.

Write a script to re-arrange the given binary string that all occurrences of “01” are simultaneously replaced with “10” until no occurrences of “01” exist. Finally return the total steps needed.

My solution

For this task, I have coded the instructions as stated. I have a variable count that counts the number of times the loop is run before the solution is found.

def rearrange_binstr(input_string: str) -> int:
    if not re.search("^[01]+$", input_string):
        raise ValueError("Invalid input")

    count = 0
    while "01" in input_string:
        count += 1
        input_string = re.sub("01", "10", input_string)

    return count

The Perl solution follows the same logic.

sub main ($input_string) {
    if ( $input_string !~ /^[01]+$/ ) {
        die "Invalid input\n";
    }

    my $count = 0;
    while ( index( $input_string, "01" ) != -1 ) {
        $count++;
        $input_string =~ s/01/10/g;
    }

    say $count;
}

Examples

$ ./ch-1.py 111000
0

$ ./ch-1.py 00011
4

$ ./ch-1.py 01011
3

$ ./ch-1.py 010101
3

$ ./ch-1.py 00001
4

Task 2: Rational Numbers

You are given a chemical formula with elements, numbers, and parentheses.

Write a script to count the total number of each type of atom by expanding all grouped multipliers. Then, format and return the final inventory as a single string sorted alphabetically by element name, including the total count only if it is greater than 1.

My solution

For this task I start with a function called expand_parens which will expand the inner most parentheses followed by a number using that number match_obj[2] to multiple the number of atoms for each individual element match_obj[1].

def expand_parens(match_obj: re.Match) -> str:
    multiplier = int(match_obj[2])

    new_elements = defaultdict(int)
    for elements in re.findall(r"([A-Z][a-z]?)(\d+)?", match_obj[1]):
        new_elements[elements[0]] += (
            int(1 if elements[1] == "" else elements[1]) * multiplier
        )
    return "".join(f"{key}{value}" for key, value in new_elements.items())

The main atom_count function starts by expanding all parentheses.

def atom_count(input_string: str) -> str:
    while re.search(r"\([A-Z0-9]+\)\d+", input_string, flags=re.I):
        input_string = re.sub(
            r"\(([A-Z0-9]+)\)(\d+)", expand_parens, input_string, flags=re.I
        )

It then checks that the final string is as expected, in case the input has mismatched parentheses or symbols for example.

    if not re.search("^[A-Z0-9]+$", input_string, flags=re.I):
        raise ValueError("Invalid input")

The next step is to count the number of atoms each element has.

    count_elements = defaultdict(int)
    for elements in re.findall(r"([A-Z][a-z]?)(\d+)?", input_string):
        count_elements[elements[0]] += int(1 if elements[1] == "" else elements[1])

The final step is to convert this dict into a string sorted alphabetically by the element. If there is more than one atom, the number is appended as required.

    output = ""
    for element in sorted(count_elements):
        count = count_elements[element]
        output += element
        if count > 1:
            output += str(count)

    return output

Like with the first task, the Perl solution follows the same logic. It uses the s///e pattern to call the expand_parens() function.

Examples

$ ./ch-2.py "((N2O)3(H2O)2)2"
H8N12O10

$ ./ch-2.py "Mg3(PO4)2"
Mg3O8P2

$ ./ch-2.py "(((H)2)3)4"
H24

$ ./ch-2.py "NaCl3(O2(S10)2)2Mg"
Cl3MgNaO4S40

$ ./ch-2.py "Z2Y3(X2W)2"
W2X4Y3Z2

Weekly Challenge: The Rational Base

Simon Green — Sun, 16 Aug 2026 12:56:27 +0000

Weekly Challenge 386

Challenge, My solutions

Task 1: Reverse Base

Task

You are given a string representing a number, and an integer specifying the base of that representation.

Write a function to convert this string to an integer. (For bases greater than 10, use characters A-Z, a-z, + and / in that order.)

My solution

This is the reserve of a previous challenge where we converted numbers to a specified base. In this challenge, I start by defining the variable alphabet which has the first base characters from 0-9A-Za-z+/

import string

def reverse_base(input_string: str, base: int) -> int:
    alphabet = "0123456789" + string.ascii_uppercase + string.ascii_lowercase + "+/"

    alphabet = alphabet[:base]

I then convert each charter to its decimal representation. This uses list comprehension to find the index (position) of the character in the alphabet variable. If a value is invalid, a ValueError is raised, and I raise an Exception to state this.

    try:
        digits = [alphabet.index(digit) for digit in input_string]
    except ValueError:
        raise ValueError("Invalid input for the specified base")

The last part is to calculate the integer value, and return the output variable.

    output = 0
    for digit in digits:
        output *= base
        output += digit

    return output

The Perl solution follows the same logic.

Examples

$ ./ch-1.py 101010 2
42

$ ./ch-1.py EEADEE 16
15642094

$ ./ch-1.py 755 8
493

$ ./ch-1.py 1BRJB 36
2228519

$ ./ch-1.py 7MyqL 64
123456789

Task 2: Rational Numbers

Task

You are given two strings representing non-negative rational numbers.

Write a script to return true if the two given rational numbers are same otherwise false.

My solution

For this challenge, I take two or more numbers. I start by split each rats (rational number) value into three parts: 1) The whole number (or 0 if not present), 2) The non-recurring fraction (or "" if not present), and 3) The recurring part of the fraction (or 0 if not present). This is stored in a list (array in Perl) called rat_parts.

def same_rational_numbers(*rats) -> bool:
    rat_parts = []
    for rat in rats:
        m = re.search(r"(\d+)(?:\.(\d*)(?:\((\d+)\))?)?$", rat)
        if not m:
            raise ValueError("The value {rat} is invalid!")
        rat_parts.append([m.group(1) or "0", m.group(2) or "", m.group(3) or "0"])

The next thing I do is check if the whole part of the numbers are the same. By using a set, duplicate values are removed. If there is more than one unique whole number, it means the values in rat aren't the same. For the Perl solution, I use uniq from the List::Util module to check for uniqueness.

    if len(set(r[0] for r in rat_parts)) != 1:
        return False

The last part to is check if the fraction part is the same. For this I set the part length to the maximum of length the non-recurring fraction and two times the recurring amount. This should cover all cases. The extend_part function takes the split parts, and extends the fractional part of part_length length.

def extend_part(rat_part, part_length) -> str:
    s = rat_part[1]
    while len(s) < part_length:
        s += rat_part[2]

    return s[:part_length]

Like with the whole check, the fraction part also uses a set (or uniq in Perl) to check that all parts are the same.

    part_length = max(len(r[1]) + 2 * len(r[2]) for r in rat_parts)
    if len(set(extend_part(r, part_length) for r in rat_parts)) != 1:
        return False

    return True

Like with the first task, the Perl solution follows the same logic.

Examples

In the challenge, the solution to the fourth example gives a different result. I believe this is an error in the example, not in my code.

$ ./ch-2.py "0.(12)" "0.(121)"
false

$ ./ch-2.py "0.1(23)" "0.12(32)"
true

$ ./ch-2.py "0.1(234)" "0.12(342)"
true

$ ./ch-2.py "12.99(99)" "13."
false

$ ./ch-2.py "0.(123)" "0.1(231)"
true

Weekly Challenge: Uncommon parentheses

Simon Green — Sun, 09 Aug 2026 03:56:09 +0000

Weekly Challenge 385

Challenge, My solutions

Task 1: Uncommon Words

Task

You are given two sentences.

Write a script to return list of all uncommon words, order is not important.

My solution

This is relatively straight forward. I start with a Counter called word_freq which is a special type of dictionary which is ideal for counting frequencies.

I take one or more sentences as input. I loop through each sentence, separate them by spaces and increment the word_freq counter. I then return all words that have a frequency of 1.

Since Python 3.6, dictionaries maintain their order. Therefore the words in the output will maintain their order from the supplied sentences.

from collections import Counter

def uncommon_word(*sentences: str) -> list:
    word_freq = Counter()
    for sentence in sentences:
        word_freq.update(sentence.split())

    return [word for word in word_freq if word_freq[word] == 1]

Perl does not maintain order of hashes. For the Perl solution, I sort the unique words alphabetically. This is an example of stacking sort, map (to quote strings) and grep (to filter duplicated words) in a single function.

sub main (@sentences) {
    my %word_freq = ();
    foreach my $sentence (@sentences) {
        foreach my $word ( split /\s+/, $sentence ) {
            $word_freq{$word}++;
        }
    }

    say "("
      . join( ", ",
        sort map { qq{"$_"} } grep { $word_freq{$_} == 1 } keys %word_freq )
      . ")";
}

Examples

$ ./ch-1.py "apple banana apple" "banana orange"
("orange")

$ ./ch-1.py "cat dog" "bird fish"
("cat", "dog", "bird", "fish")

$ ./ch-1.py "the quick brown fox" "the quick"
("brown", "fox")

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

$ ./ch-1.py "blue blue red" "red green green yellow"
("yellow")

Task 2: Outermost Parentheses

Task

You are given a valid parentheses string.

Write a script to return the string after removing the outermost parentheses of every primitive string in the primitive decomposition of the given string.

My solution

For this task, I start by checking that the supplied string only contains open and closing parentheses.

def outermost_parentheses(input_string: str) -> str:
    if not re.search(r"^[()]+$", input_string):
        raise ValueError("Invalid input")

I then create two variables. output will store the string that is returned to the user, while open_count variable stores how many unclosed open parentheses there are.

    output = ""
    open_count = 0

The rest of the function loops through each character of input_string incrementing and decreasing the open_count value as needed. If open_count is 1 (after the increment, or before the decrement), then it is the opening or closing the outermost parentheses, and is not added to the output string.

I also have checks to ensure that a closing parentheses does not appear before the opening one, and all open parentheses are closed at the end of the string.

    for char in input_string:
        if char == "(":
            open_count += 1

        if open_count != 1:
            output += char

        if char == ")":
            open_count -= 1

        if open_count < 0:
            raise ValueError("Too many closing parentheses")

    if open_count != 0:
        raise ValueError("Not enough closing parentheses")

    return output

The Perl solution follows the same logic.

Examples

$ ./ch-2.py "()()()"
""

$ ./ch-2.py "(((())))"
"((()))"

$ ./ch-2.py "(()())(())"
"()()()"

$ ./ch-2.py "()((()))()"
"(())"

$ ./ch-2.py "(()(()))(()())"
"()(())()()"