DEV Community: Simon Green

Weekly Challenge: Uncommon parentheses

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

Weekly Challenge 385

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

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

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

Weekly Challenge: Work it

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

Weekly Challenge 379

Challenge, My solutions

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

Task 1: Reverse String

Task

You are given a string.

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

My solution

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

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

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

    return result_string

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

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

Examples

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

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

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

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

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

Task 2: Armstrong Number

Task

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

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

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

My solution

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

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

    return result_list

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

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

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

        if i == 0:
            break

        num = i

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

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

The Perl solution follows the same logic.

Examples

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

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

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

Weekly Challenge: The Second Sum

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

Weekly Challenge 378

Challenge, My solutions

Task 1: Second Largest Digit

Task

You are given an alphanumeric string.

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

My solution

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

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

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

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

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

Examples

$ ./ch-1.py aaaaa77777
-1

$ ./ch-1.py abcde
-1

$ ./ch-1.py 9zero8eight7seven9
8

$ ./ch-1.py xyz9876543210
8

$ ./ch-1.py 4abc4def2ghi8jkl2
4

Task 2: Sum of Words

Task

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

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

My solution

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

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

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

The sum_of_words function simply checks if the math is valid.

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

The Perl code follows the same logic.

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

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

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

Examples

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

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

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

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

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

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

Weekly Challenge: Existence

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

Weekly Challenge 377

Challenge, My solutions

Task 1: Reverse Existence

Task

You are given a string.

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

My solution

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

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

    return False

The Perl solution follows the same logic.

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

    say "false";
}

Examples

$ ./ch-1.py abcba
true

$ ./ch-1.py racecar
true

$ ./ch-1.py abcd
false

$ ./ch-1.py banana
true

$ ./ch-1.py hello
true

Task 2: Prefix Suffix

Task

You are given an array of strings.

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

My solution

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

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

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

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

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

}

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

use Algorithm::Combinatorics 'combinations';

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

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

    say $count;
}

Examples

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

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

$ ./ch-2.py abao ab
0

$ ./ch-2.py abab abab
1

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

Weekly Challenge: Double chessboard

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

Weekly Challenge 376

Challenge, My solutions

Task 1: Chessboard Squares

Task

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

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

My solution

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

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

import re

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

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

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

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

The Perl solution follows the same logic.

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

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

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

Examples

$ ./ch-1.py a7 f4
true

$ ./ch-1.py c1 e8
false

$ ./ch-1.py b5 h2
false

$ ./ch-1.py f3 h1
true

$ ./ch-1.py a1 g7
true

Task 2: Doubled Words

Task

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

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

The script should:

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

My solution

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

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

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

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

import re

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

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

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

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

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

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

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

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

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

    return "\n".join(different_lines)

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

Examples

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

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

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

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

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

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

The Weekly Challenge: The Common Beauty

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

Weekly Challenge 375

Challenge, My solutions

Task 1: Single Common Word

Task

You are given two array of strings.

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

My solution

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

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

from collections import Counter

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

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

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

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

    return len(unique1 & unique2)

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

use Array::Utils 'intersect';

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

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

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

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

Examples

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

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

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

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

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

Task 2: Find K-Beauty

Task

You are given a number and a digit k.

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

My solution

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

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

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

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

    return count

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

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

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

    say $count;
}

Examples

$ ./ch-2.py 240 2
2

$ ./ch-2.py 1020 2
3

$ ./ch-2.py 444 2
0

$ ./ch-2.py 17 2
1

$ ./ch-2.py 123 1
2

Weekly Challenge: Vowels and numbers

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

Weekly Challenge 374

Challenge, My solutions

Task 1: Count Vowel

Task

You are given a string.

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

My solution

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

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

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

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

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

    return solution

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

use List::Util 'any';

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

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

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

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

            push @solution, $substr;
        }
    }

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

Examples

The order in the output differs from the examples.

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

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

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

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

$ ./ch-1.py aeioaeioa
()

Task 2: Largest Same-digits Number

Task

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

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

My solution

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

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

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

from collections import Counter
import re

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

    largest_number = 0
    freq = Counter(input_string)

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

    return largest_number

The Perl solution follows the same logic.

Examples

$ ./ch-2.py 6777133339
3333

$ ./ch-2.py 1200034
4

$ ./ch-2.py 44221155
55

$ ./ch-2.py 88888
88888

$ ./ch-2.py 11122233
222