DEV Community: Simon Green

The Weekly Challenge: Arranging things

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

Weekly Challenge 391

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: 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 "(()(()))(()())"
"()(())()()"

Weekly Challenge: Base substrings

Simon Green — Sun, 02 Aug 2026 08:39:52 +0000

Weekly Challenge 384

Challenge, My solutions

Task 1: Base N

Task

You are given a number and a base integer.

Write a script to convert the given number in the given base integer.

My solution

For this challenge, I start by checking n is not a negative integer and base is between 2 and 64.

def base_n(num: int, base: int) -> str:
    if not 1 <= base <= 64:
        raise ValueError(f"Invalid base value: {base}")
    if num < 0:
        raise ValueError(f"Number {num} must be non-negative")

I then separate n into the digits in the specified base. This is the same code that was used in Challenge 379.

    digits = []
    while True:
        i, j = divmod(num, base)
        digits.insert(0, j)

        if i == 0:
            break

        num = i

The last step is to define the strings that represent each character, and return that.

    alphabet = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz+/"
    return "".join(alphabet[i] for i in digits)

One thing to note is that Base 64 (as defined in RFC 4648) uses upper case letters (0-25), lower case letters (26-51), numbers (52-61) and two extra characters (62 and 63). It's clear from the fifth example that in this case, the numbers come before the letters.

Examples

$ ./ch-1.py 42 2
101010

$ ./ch-1.py 15642094 16
EEADEE

$ ./ch-1.py 493 8
755

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

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

Task 2: Special Binary Substrings

Task

You are given a binary string.

Write a script to return all non-empty substrings (distinct) that have the same number of 0’s and 1’s, and all the 0’s and all the 1’s in these substrings are grouped consecutively.

My solution

For this task, I start by checking that input_string contains only ones and zeros.

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

I then generate a set (hash in Perl) of all valid substrings.

    half_length = int(len(input_string) / 2)
    valid_substring = {
        substring
        for l in range(1, half_length + 1)
        for substring in generate_substring(l)
    }

The generate_substring function will generate the substrings of l zeros and l ones and visa versa.

def generate_substring(l: int) -> tuple:
    return ("0" * l + "1" * l, "1" * l + "0" * l)

The last step is to find all the substrings that are in the valid_substring set. For this, I use a double loop. The outer loop is called start from 0 to two less than the length of the string. The inner loop is end from one more than start to the length of the string, two at a time (since all solutions must have an even number of digits).

    results = []
    for start in range(len(input_string) - 1):
        for end in range(start + 1, len(input_string), 2):
            substring = input_string[start : end + 1]
            if substring in valid_substring:
                results.append(substring)

    return results

For the Perl solution, I use $length instead of end, as this is the parameter that the substring function uses.

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

    my %valid_substring = ();
    my $half_length     = int( length($input_string) / 2 );
    foreach my $l ( 1 .. $half_length ) {
        $valid_substring{ "0" x $l . "1" x $l } = 1;
        $valid_substring{ "1" x $l . "0" x $l } = 1;
    }

    my @results = ();
    my $l       = length($input_string);
    foreach my $start ( 0 .. $l - 2 ) {
        for ( my $length = 2 ; $length <= $l - $start ; $length += 2 ) {
            my $substring = substr( $input_string, $start, $length );
            if ( exists $valid_substring{$substring} ) {
                push @results, $substring;
            }
        }
    }

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

Examples

$ ./ch-2.py 0101
("01", "10", "01")

$ ./ch-2.py 000111
("000111", "0011", "01")

$ ./ch-2.py 000011
("0011", "01")

$ ./ch-2.py 10011100
("10", "0011", "01", "1100", "10")

$ ./ch-2.py 00000
()

Weekly Challenge: Similar colors

Simon Green — Sun, 26 Jul 2026 11:56:09 +0000

Weekly Challenge 383

Challenge, My solutions

Task 1: Similar List

Task

You are given three list of strings.

Write a script to find out if the first two list are similar with the help the third list. The third list contains the similar words map.

My solution

Lie with a lot of challenges, I can use the examples to extract information that isn't in the task itself. In this case, it's clear from example two that list3 isn't bi-directional. If it was, both lists could match to peach pie and return True.

What isn't clear is the third example where three words appear in the first list in list3. In this case, I've treated word1 word2 word3 as the same as word1 word3 and word2 word3.

For input from the command line, I take comma separated values to make the different lists. The first argument is list1, the second is list2 and the remainder is a list (array in Perl) for list3.

If list1 and list2 are different lengths, I return False. If the two lists are the same, I return True.

def similar_list(list1: list[str], list2: list[str], list3: list[list[str]]) -> bool:
    # Return false if the list1 and list2 are different length
    if len(list1) != len(list2):
        return False

    # ... or they are the same
    if list1 == list2:
        return True

The next step I do is create a mapping dict called mapping (original name, I know :)). This takes the list3 list and creates a mapping from the original word to the target word.

    mapping = {}
    for mapping_list in list3:
        target_word = mapping_list.pop()
        for word in mapping_list:
            mapping[word] = target_word

The final step is to use the dict to convert the two lists, and check for equality.

    target_list1 = [ mapping.get(word, word) for word in list1]
    target_list2 = [ mapping.get(word, word) for word in list2]
    return target_list1 == target_list2

The Perl solution uses the same logic

sub similar_list($list1, $list2, @list3) {
    if ($#$list1 != $#$list2) {
        return 0;
    }

    my %mapping = ();
    foreach my $mapping_list (@list3) {
        my $target_word = pop(@$mapping_list);
        foreach my $word (@$mapping_list) {
            $mapping{$word} = $target_word;
        }}

    my @target_list1 = map { exists $mapping{$_} ? $mapping{$_} : $_} @$list1;
    my @target_list2 = map { exists $mapping{$_} ? $mapping{$_} : $_} @$list2;

    for my $i (0 .. $#$list1) {
        if ($target_list1[$i] ne $target_list2[$i]) {
            return 0;
        }}

    return 1;
}

Examples

$ ./ch-1.py great,acting fine,drama great,fine acting,drama
false

$ ./ch-1.py great,acting fine,drama great,fine acting,drama
true

$ ./ch-1.py apple,pie banana,pie apple,peach peach,banana
false

$ ./ch-1.py perl4,python raku,python perl4,perl5,raku
true

$ ./ch-1.py enjoy,challenge love,weekly,challenge enjoy,love
false

$ ./ch-1.py fast,car quick,vehicle quick,fast vehicle,car
true

Task 2: Nearest RGB

Task

You are given a 6-digit hex color.

Write a script to round the RGB channels to the nearest web-safe value and return the nearest RGB color. Values are 00 (0), 33 (51), 66 (102), 99 (153), CC (204) and FF (255).

My solution

For this task, I have a function called nearest_color that takes a two character hex value and converts to the nearest web safe color. For this I take the average of two values to see the cut off point. For example (255 + 204) ÷ 2 is 229½ so values greater than or equal to 230 will return FF. In Python (from 3.6) dicts retain their insertion order.

def nearest_color(hex_string: str) -> str:
    """Convert a hex value to the nearest web safe value"""
    mapping = {230: "FF", 179: "CC", 128: "99", 77: "66", 26: "33"}
    value = int(hex_string, base=16)
    for key, result in mapping.items():
        if value >= key:
            return result

    return "00"

Perl hashes on the other hand do not maintain their insertion order. Therefore I need to use the sort function to achieve the same functionality.

sub nearest_color($hex_string) {
    my %mapping =
      ( 230 => "FF", 179 => "CC", 128 => "99", 77 => "66", 26 => "33", );
    my $value = hex($hex_string);
    foreach my $key ( sort { $b <=> $a } keys %mapping ) {
        if ( $value >= $key ) {
            return $mapping{$key};
        }
    }

    return "00";
}

The nearest_rgb function simply checks that input_string is valid (a hash followed by six characters in 0-9 A-F) and calls the nearest_color function for each pair of digits. The Perl code also does the same.

def nearest_rgb(input_string: str) -> str:
    if not re.search(r'^#[0-9A-F]{6}$', input_string):
        raise ValueError(f"Invalid input")

    return ("#"
        + nearest_color(input_string[1:3])
        + nearest_color(input_string[3:5])
        + nearest_color(input_string[5:7])
    )

Examples

$ ./ch-2.py "#F4B2D1"
#FF99CC

$ ./ch-2.py "#15E6E5"
#00FFCC

$ ./ch-2.py "#191A65"
#003366

$ ./ch-2.py "#2D5A1B"
#336633

$ ./ch-2.py "#00FF66"
#00FF66

Weekly Challenge: The Hamiltonian Question

Simon Green — Sun, 19 Jul 2026 13:50:14 +0000

Weekly Challenge 382

Challenge, My solutions

Sorry, no Perl solutions this week.

Task 1: Hamiltonian Cycle

Task

You are given a target number.

Write a script to arrange all the whole numbers from 1 up to the given target number into a circle so that every pair of side-by-side numbers adds up to a perfect square. Please make sure, the last number and the first must also add up to a square.

My solution

This was a fun challenge. After a few days of thought, I went to my trusty friend, a recursive function.

When the function is called for the first time, it populates the SQUARE set with the squares from 1 to n². In reality, I only need the squares up to n * 2 - 1, but that would be harder to write.

I also set the results list to a single 1 to seed the list in the first iteration. I then create a list called remaining_numbers which are the numbers from 2 to n (inclusive) that are not in the results list.

SQUARES = None

def hamiltonian_cycle(n: int, results=None) -> list[int]:
    global SQUARES

    if SQUARES is None:
        SQUARES = {n * n for n in range(1, n + 1)}

    if results is None:
        results = [1]

    remaining_numbers = [n for n in range(2, n + 1) if n not in results]

If the remaining_numbers list is empty, I have used all the numbers and need to check if the sum of the first and last number is also a square. If it is, I return the list to the calling function. If it isn't, I return an empty list to find another solution.

    if not remaining_numbers:
        if results[0] + results[-1] in SQUARES:
            return results
        return []

The rest of the function is an loop called i using each value from the remaining_numbers list. For each iteration, if the sum of the last number in the results list and i is a square, I call the recursive function again. If the loop is exhausted, I return an empty string.

    for i in remaining_numbers:
        if i + results[-1] in SQUARES:
            new_results = hamiltonian_cycle(n, results + [i])
            if new_results:
                return new_results

    return []

Examples

For the third example, the list differs from the one on the website. Unless I missed something, it is still valid.

$ ./ch-1.py 32
[1, 8, 28, 21, 4, 32, 17, 19, 30, 6, 3, 13, 12, 24, 25, 11, 5, 31, 18, 7, 29, 20, 16, 9, 27, 22, 14, 2, 23, 26, 10, 15]

$ ./ch-1.py 15
[]

$ ./ch-1.py 34
[1, 3, 13, 12, 4, 32, 17, 8, 28, 21, 15, 34, 30, 19, 6, 10, 26, 23, 2, 14, 22, 27, 9, 16, 33, 31, 18, 7, 29, 20, 5, 11, 25, 24]

Task 2: Replace Question Mark

Task

You are given a string that contains only 0, 1 and ? characters.

Write a script to generate all possible combinations when replacing the question marks with a zero or one.

My first solution

This was a question I was asked in a closed-book hand-written interview I had a few months ago. I didn't get the job, but I thought it would be suitable for a task for Team PWC members.

When I wrote this solution on paper, I mentioned that while I'm sure the code would work (spoiler: it does) it was probably not the most efficient one, and in the real world I'd just ask Copilot to do the job.

This solution is the script ch-2-alternate.py. I start by checking the input is made up of 0, 1 and ? characters. If there are no question marks, I return the original input as a single-item list. I also seed the result list with a single empty string.

import re

def replace_question_mark(input_string: str) -> list[str]:
    if not re.match(r"^[01?]+$", input_string):
        raise ValueError("input_string must contain only '0', '1', and '?' characters")

    if "?" not in input_string:
        return [input_string]

    result = [""]

I then iterate over each character. If the character is a question mark, I duplicate the array, appending 0 to the first half and 1 to the second half. If the character is 0 or 1, I append that character to each item in the list.

    for c in input_string:
        if c == "?":
            new_result = [row + "0" for row in result]
            new_result += [row + "1" for row in result]
            result = new_result
        else:
            result = [row + c for row in result]

    return result

The AI (and better) solution

So when I got home, I asked Copilot to write a solution for me. It took no time to produce the output in the script ch-2.py. This is slightly modified, but the logic came from Copilot.

After performing the same checks as the previous example, it finds the position of all the question marks and stores this in a list called question_positions.

from itertools import product
import re

def replace_question_mark(input_string: str) -> list[str]:
    if not re.match(r"^[01?]+$", input_string):
        raise ValueError("input_string must contain only '0', '1', and '?' characters")

    if "?" not in input_string:
        return [input_string]

    question_positions = [i for i, char in enumerate(input_string) if char == "?"]

It then uses the product function from the itertools package to generate all combinations of zeros and ones and substitutes them in the correct position.

    results = []
    for combination in product("01", repeat=len(question_positions)):
        chars = list(input_string)
        for pos, value in zip(question_positions, combination):
            chars[pos] = value
        results.append("".join(chars))

    return results

Examples

The order in the alternate script differs from the below. The solutions are still valid.

$ ./ch-2.py 01??0
['01000', '01010', '01100', '01110']

$ ./ch-2.py 101
['101']

$ ./ch-2.py ???
['000', '001', '010', '011', '100', '101', '110', '111']

$ ./ch-2.py 1?10
['1010', '1110']

$ ./ch-2.py 1?1?0
['10100', '10110', '11100', '11110']

The Weekly Challenge: Grep, set and match

Simon Green — Sun, 12 Jul 2026 11:31:01 +0000

Weekly Challenge 381

Challenge, My solutions

The etymology of this weeks title is the use of set in the Python solution, grep in the Perl solution, matching items in a list/array and a nod to the Wimbledon Grand Slam.

Task 1: Same Row Column

Task

You are given a n × n matrix containing integers from 1 to n.

Write a script to find if every row and every column contains all the integers from 1 to n.

My solution

For input from the command line, I take a JSON-fomatted string which is converted to a list (array in Perl) called matrix.

For the Python solution, I start by checking that the matrix is square.

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

I then create a set of the expected values of each row and column.

    expected_set = set(range(1, length+1))

Finally I check each row and each column meets the criteria. If it doesn't, I return False. If all checks pass, I return True. Sets are unordered so {1, 2, 3} is equal to {3, 2, 1}.

    for i in range(length):
        if set(matrix[i]) != expected_set:
            return False

        if set(matrix[r][i] for r in range(length)) != expected_set:
            return False

    return True

Perl does not have sets, so the solution is slightly different. I start by creating a function called check_values. This checks that every value from 1 to n (the length of the matrix) is present. It will return 1 if it is, or 0 if it isn't.

use List::Util 'none';

sub check_values (@ints) {
    # Check that each number from 1 to the length of ints is present
    for my $i ( 1 .. $#ints + 1 ) {
        if ( none { $_ == $i } @ints ) {
            return 0;
        }
    }

    return 1;
}

The rest of the code follows the same logic as the Python solution. It uses the map function to retrieve the columns as required.

sub main ($matrix_json) {
    my $matrix = decode_json($matrix_json);

    my $length = scalar(@$matrix);

    foreach my $row (@$matrix) {
        if ( scalar(@$row) != $length ) {
            die "All rows must have the same length\n";
        }
    }

    foreach my $i ( 0 .. $#$matrix ) {
        if ( not check_values( @{ $matrix->[$i] } ) ) {
            say 'false';
            return;
        }

        if ( not check_values( map { $_->[$i] } @$matrix ) ) {
            say 'false';
            return;
        }
    }

    say 'true';
}

Examples

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

$ ./ch-1.py "[[1]]"
True

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

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

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

Task 2: Smaller Greater Element

Task

You are given an array of integers.

Write a script to find the number of elements that have both a strictly smaller and greater element in the given array.

My solution

Unless I'm missing something obvious, this task is to count the number of items that aren't the lowest or higher number. For this task, I create a set of the lowest and highest number called excluded_values and then count the number items that aren't in the set.

def smaller_greater_element(ints: list[int]) -> int:
    excluded_values = {min(ints), max(ints)}
    return sum(1 for i in ints if i not in excluded_values)

For the Perl solution, I create two variables min_value and max_value. I then use the grep function to count the number of items isn't one of the value. The function will return the number of items in the array if it is assigned to a scalar.

use List::Util qw(max min);

sub main (@ints) {
    my $min_value = min(@ints);
    my $max_value = max(@ints);

    my $count = grep { $_ != $min_value && $_ != $max_value } @ints;
    say $count;
}

Examples

$ ./ch-2.py 2 4
0

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

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

$ ./ch-2.py 3 6 6 9
2

$ ./ch-2.py 0 -5 10 -2 4
3

Weekly Challenge: The race car has rhythm

Simon Green — Fri, 03 Jul 2026 08:13:37 +0000

Weekly Challenge 380

Challenge, My solutions

Task 1: Sum of Frequencies

Task

You are given a string consisting of English letters.

Write a script to find the vowel and consonant with maximum frequency. Return the sum of two frequencies.

My solution

I start this task by creating a frequency dict (hash in Perl) called freq using the Counter function from the collections module. I create two variables max_vowels and max_consonants with both set to zero.

I loop through the freq dict, and update the one of the maximum variables if it is larger than the existing value. I finish by returning the sum of these two variables.

from collections import Counter

def sum_of_frequencies(input_string: str) -> int:
    freq = Counter(input_string.lower())

    max_vowels = 0
    max_consonants = 0
    for letter, count in freq.items():
        if letter in {"a", "e", "i", "o", "u"}:
            if count > max_vowels:
                max_vowels = count
        else:
            if count > max_consonants:
                max_consonants = count

    return max_vowels + max_consonants

As Perl does not have an equivalent of the Counter function, I create the freq hash manually. The rest of the code follows the same logic.

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

    my $max_vowels     = 0;
    my $max_consonants = 0;
    while ( my ( $letter, $count ) = each %freq ) {
        if ( index( "aeiou", $letter ) != -1 ) {
            if ( $count > $max_vowels ) {
                $max_vowels = $count;
            }
        }
        else {
            if ( $count > $max_consonants ) {
                $max_consonants = $count;
            }
        }
    }

    say $max_vowels + $max_consonants;

}

Examples

$ ./ch-1.py banana
5

$ ./ch-1.py teestett
7

$ ./ch-1.py aeiouuaa
3

$ ./ch-1.py rhythm
2

$ ./ch-1.py x
1

Task 2: Reverse Degree

Task

You are given a string.

Write a script to find the reverse degree of the given string.

For each character, multiply its position in the reversed alphabet (a = 26, b = 25, …, z = 1) with its position in the string. Sum these products for all characters in the string to get the reverse degree.

My solution

Both Python and Perl has the ord function which returns the integer Unicode code point value to for the supplied character. For the lower case English alphabet, 97 is a while 122 is the letter z.

For this task, I start by checking that the supplied string only contains English letters.

import re
def reverse_degree(input_string: str) -> int:
    if not re.search("^[a-zA-Z]*$", input_string):
        raise ValueError("String must only contain English letters")

I then generate a list (array in Perl) called number that has the revered alphabet number of each letter in input_string. Rather than relying on the character after z in the ASCII table being {, I use ord("z") + 1 to get the correct values.

    numbers = [ord("z") - ord(char) + 1 for char in input_string.lower()]

Finally I use the sum function and list comprehension to compute the correct number.

    return sum(number * pos for number, pos in enumerate(numbers, start=1))

The Perl solution is similar. To compute the correct number, I use the pre-increment operator ++$pos and the map function. The map function is also used to generate the numbers array.

use List::Util 'sum';

sub main ($input_string) {
    if ( $input_string !~ /^[a-zA-Z]*$/ ) {
        die "String must only contain English letters\n";
    }

    my @numbers = map { ord("z") - ord($_) + 1 } split //, lc $input_string;
    my $pos     = 0;
    say sum( map { $_ * ++$pos } @numbers );
}

Examples

$ ./ch-2.py z
1

$ ./ch-2.py a
26

$ ./ch-2.py bbc
147

$ ./ch-2.py racecar
560

$ ./ch-2.py zyx
14