PWC 349 Task 2: Meeting Point

Musical Interlude

We're going deep cut from the classic Blood on the Tracks album by Bob Dylan, Meet Me in the Morning

The Task

You are given an instruction string made up of U (up), D (down), L (left) and R (right). Write a script to return true if following the instructions, you meet (0,0) at any point along the sequence.

• Example 1:
  • Input: $path = "ULD"
  • Output: false
  • U -> (0,1), L -> (-1,1), D -> (-1, 0)
• Example 2:
  • Input: $path = "ULDR"
  • Output: true
  • U -> (0,1), L -> (-1,1), D -> (-1, 0), R -> (0,0)
• Example 5:
  • Input: $path = "RRUULLDDRRUU"
  • Output: true
  • RRUULLDD -> (0,0), RRUU -> (2,2)

The Deliberation

The first thought is emulate the movement on the grid and see if we end up at (0,0).

A clever thought arises: to end up back where we began, every Up must be matched with a Down, and every Right must be matched with a Left. So all we really have to do is count moves, right?

But Example 5 throws a wrench. The path makes a big square and passes through (0,0), but doesn't end there. I guess I really do need to check every move in the path.

Second clever thought (this one might be worth keeping): moving around a grid can be like moving in the complex plane. A horizontal move is along the real axis, and a vertical move is along the imaginary axis. If we think of the location as a complex number, then a move is an increment of either the real or the imaginary part.

The Code

Nice try, no cigar

Let's dispense with what didn't work, because it looked good until we hit Example 5.

sub meet($path)
{
    my @m = map { scalar(()= $path =~ m/$_/g) } qw(U D L R);
    return $m[0] == $m[1]  && $m[2] == $m[3];
}

Notes:

• We'll try to count the number of each direction and see if Ups cancel Downs and Rights cancel Lefts.
• my @m = map {...} qw(U D L R) -- for each move, map to the number of occurrences of that move in $path
• $path =~ m/$_/g -- $_ is one of (U,D,L,R). The regular expression match with a g flag can return a list of all the occurrences of that letter in $path.
• scalar(()= ...) -- assigning the match to an empty list will create an array context, so that m// will yield a list. Then taking the scalar of that will give a count. This is a variant of the =()= Saturn secret operator
• Now it only remains to check if the numbers align.

Moving on to something that works

sub meetComplex($path)
{
    use Math::Complex;

    state $origin = (0 + 0*i);
    state %move = ( R => (1 + 0*i), L => (-1 +  0*i),
                    U => (0 + 1*i), D => ( 0 + -1*i), );

    my $place = $origin;
    for ( split(//, uc $path) )
    {
        $place += $move{$_};
        return true if $place == $origin;
    }
    return false;
}

Notes:

• use Math::Complex -- Yes, Perl does complex arithmetic.
• state $origin = (0 + 0*i) -- Set up a "constant" for the origin. state makes a variable that is initialized only the first time the function is entered, and limits the scope to the function. Math::Complex makes it possible to write complex constants in a natural way.
• state %move -- Set up "constants" for movements. Moving Right and Left affects the real part of the complex number; moving Up and Down affects the imaginary part.
• for ( split(...) ) -- Take the path apart to process each move. I threw in an uc to make sure we would only have uppercase input.
• $place += $move{$_} -- For each move, change $place in the complex plane. Math::Complex overloads operators as expected.
• return true if $place == $origin -- Complex numbers can be compared, of course.
• If we didn't find (0,0), then the answer is false.

Originally published at Perl Weekly 748

Hi there,

Just couple of days ago, we had another development release: Perl v5.43.5. Among the many changes in this release, my favourite is Named Parameters in Signatures. For further details, please check out the perldelta page.

The LPW 2025 is finally happening on 29th Nov 2025. So if you are available then please do join us for the tech meet. I would request you to register if you are planning to attend as this will help the organisers schedule the day accordingly. It's a great opportunity to meet friends and attend talks from speakers like Sawyer, Paul Evans and Stevan Little.

I have submitted a talk, Design Patterns in Modern Perl, and it has been accepted. I am excited to share my ideas with fellow tech friends. Here is the list of talks for you. One last thing, please register your favourite talks, this will help the organisers with scheduling. Someone also shared a very interesting post about Lunch options - LPW 2025.

The Advent Calendar is back and we need more articles for Perl Advent Calendar 2025. Please submit your proposal. I have proposed one about OpenAPI::Linter and it has already been accepted already. Soon, I'll submit the first draft. I know, time is running out - too many things to do in too little time.

Holiday season is kicking in, so take it easy and enjoy rest of the newsletter.

--
Your editor: Mohammad Sajid Anwar.

Announcements

You're invited: LPW 2025

You're welcome to attend this week's free London Perl and Raku Workshop 2025 on Saturday the 29th of November.

Articles

This week in PSC (207) | 2025-11-17

Talking about changes in the latest development release.

When does February 29th next land on a Monday?

Just released Cron::Toolkit 0.09 to CPAN to help answer this and other puzzlers. Over 400 tests.

Elderly Camels in the Cloud

Dave continues to share his recent work with Google Cloud and Google Run.

Grants

Maintaining Perl 5 Core (Dave Mitchell): October 2025

The Weekly Challenge

The Weekly Challenge by Mohammad Sajid Anwar will help you step out of your comfort-zone. You can even win prize money of $50 by participating in the weekly challenge. We pick one champion at the end of the month from among all of the contributors during the month, thanks to the sponsor Lance Wicks.

The Weekly Challenge - 349

Welcome to a new week with a couple of fun tasks "Power String" and "Meeting Point". If you are new to the weekly challenge then why not join us and have fun every week. For more information, please read the FAQ.

RECAP - The Weekly Challenge - 348

Enjoy a quick recap of last week's contributions by Team PWC dealing with the "String Alike" and "Convert Time" tasks in Perl and Raku. You will find plenty of solutions to keep you busy.

TWC348

This is professional-grade Perl code that demonstrates deep understanding of the language. The solutions are both correct and elegantly implemented.

Time Alike

This is an excellent technical write-up and solid Raku code. Both scripts are idiomatic, correct, and easy to follow.

String Alike, Convert Time

The post is a clear, concise, and practical walkthrough of solving two weekly challenge problems. The code is functional, readable, and demonstrates a good understanding of Perl. The explanations are direct and easy to follow.

Perl Weekly Challenge: Week 348

Jaldhar demonstrates good programming fundamentals and the ability to think critically about language design. The Perl context discussion alone makes this submission valuable, as it highlights a real learning barrier that affects many developers. The experienced-based commentary is exactly what helps improve programming languages and educational resources.

The Times They Are a-Like

Jorg demonstrates exceptional mathematical talent - the mixed radix solution to Task 2 is one of the most elegant I've seen for this problem. The J implementation is actually idiomatic and shows good understanding of array programming.

splitting, counting and multiplying

Excellent work! This showcases exceptional versatility in programming languages and database integration. The solutions are consistently correct across all implementations.

Perl Weekly Challenge 348

The combination of optimal algorithms, comprehensive error handling, and critical problem analysis places this submission in the top tier of challenge solutions. This is the quality of work one would expect from a senior software engineer.

Get Those Strings and Times Covered

This is professional-grade Perl programming that demonstrates both technical competence and thoughtful problem-solving. The solutions are not just correct but elegantly efficient.

Ticking away the moments that make up a challenge…

This is an excellent and highly polished multi-language implementation. Packy demonstrates exceptional attention to detail, pedagogical clarity, and cross-language consistency.

String time

This represents solid, practical Perl programming from someone with considerable experience. It demonstrates a focus on correctness, testing, and maintainability that is valuable in real-world programming.

The Weekly Challenge #348

This represents the work of an experienced software engineer who understands both the technical challenges and the importance of documentation. Excellent work that balances correctness, clarity, and practical considerations.

Time for Strings

This represents solid practical programming with good problem-solving skills. The mathematical approach to Task 2 is particularly commendable and shows Roger can think abstractly about problems.

Alike Time

This is an excellent, well-explained, and pedagogically focused post. Simon demonstrates a strong grasp of Python fundamentals and a clear, methodical approach to problem-solving. The code is clean, correct, and accompanied by reasoning that is easy to follow.

Rakudo

2025.46 Advent Alert & Release #187

Weekly collections

NICEPERL's lists

Great CPAN modules released last week.

Events

London Perl and Raku Workshop

November 29, 2025

Perl Maven online: Code-reading and testing

December 1, 2025

Toronto.pm - online - How SUSE is using Perl

December 6, 2025

Paris.pm monthly meeting

December 10, 2025

German Perl/Raku Workshop 2026 in Berlin

March 16-18, 2025

You joined the Perl Weekly to get weekly e-mails about the Perl programming language and related topics.

Want to see more? See the archives of all the issues.

Not yet subscribed to the newsletter? Join us free of charge!

(C) Copyright Gabor Szabo
The articles are copyright the respective authors.

Weekly Challenge 348

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. It's a great way for us all to practice some coding.

Challenge, My solutions

Task 1: String Alike

Tasks

You are given a string of even length.

Write a script to find if the given string split into two halves of equal lengths and they both have same number of vowels.

My solution

The main logic for this challenge is a function called count_vowels. The takes a string and returns the number of vowels. The Python code for this function is

def count_vowels(s: str) -> int:
    vowels = 'aeiouAEIOU'
    return sum(1 for char in s if char in vowels)

Not to be outdone, it's a single line in Perl.

sub count_vowels ($s) {
    return $s =~ tr/aeiouAEIOU/aeiouAEIOU/;
}

With that out of the way, the main function

1. Throws an error if there there there is not an even number of characters in the input_string.
2. Return False if there is are no vowels in the input_string.
3. Set the variables first_half and second_half.
4. Compare the number of vowels in each half.
5. Return True if the two string have the same number of vowels, else False.

def string_alike(input_string: str) -> bool:
    if len(input_string) % 2 == 1:
        raise ValueError("Input string must have an even length.")

    if count_vowels(input_string) == 0:
        return False

    first_half = input_string[:len(input_string)//2]
    second_half = input_string[len(input_string)//2:]
    return count_vowels(first_half) == count_vowels(second_half)

The Perl solution follows the same logic.

sub string_alike ($input_string) {
    die "Input string must have an even length."
      if length($input_string) % 2 == 1;

    if ( count_vowels($input_string) == 0 ) {
        say "False";
        return;
    }

    my $mid         = length($input_string) / 2;
    my $first_half  = substr( $input_string, 0, $mid );
    my $second_half = substr( $input_string, $mid );
    say count_vowels($first_half) == count_vowels($second_half)
      ? "True"
      : "False";
}

Examples

$ ./ch-1.py textbook
False

$ ./ch-1.py book
True

$ ./ch-1.py AbCdEfGh
True

$ ./ch-1.py rhythmmyth
False

$ ./ch-1.py UmpireeAudio
False

Task 2: Covert Time

Task

You are given two strings, $source and $target, containing time in 24-hour time form.

Write a script to convert the source into target by performing one of the following operations:

1. Add 1 minute
2. Add 5 minutes
3. Add 15 minutes
4. Add 60 minutes

Find the total operations needed to get to the target.

My solution

For this task I have created a function called time_to_minutes that takes the time in HH:MM format, and returns the minutes since midnight. It also checks that the time is in a valid format, and the hours (0-23) and minutes (0-59) minutes are in range.

def time_to_minute(s: str) -> int:
    if not re.match(r'^\d{1,2}:\d{2}$', s):
        raise ValueError("Invalid time format, should be HH:MM")

    hour, minute = map(int, s.split(':'))

    if hour < 0 or hour > 23 or minute < 0 or minute > 59:
        raise ValueError("Invalid time format")

    return hour * 60 + minute

In the main function, I set a variable duration that is the minutes difference between the source and target. If this value is negative, the time crosses midnight, so I add 1440 (60 × 24) minutes to compute the correct duration.

def convert_time(source: str, target: str) -> int:
    duration = time_to_minute(target) - time_to_minute(source)
    if duration < 0:
        duration += 24 * 60

I set the moves list (array in Perl) to the possible moves, with the largest first. For each move, I make as many moves as possible, adding the number of moves to the count variable, and reducing duration to what remains.

    moves = [60, 15, 5, 1]
    count = 0

    for move in moves:
        count += duration // move

        duration %= move

    return count

The Perl solution follows the same logic.

Examples

$ ./ch-2.py 02:30 02:45
1

$ ./ch-2.py 11:55 12:15
2

$ ./ch-2.py 09:00 13:00
4

$ ./ch-2.py 23:45 00:30
3

$ ./ch-2.py 14:20 15:25
2

This release follows up on release 2.08 and hopefully stabilizes the test suite even further.

At the same time we are taking a first step towards the next major release by deprecating the use of XML configuration files. The preferred format for configuration files is now YAML. The XML support will be removed in a future major release, for now this is just a deprecation notice and several warnings from the test suite.

When we did the last major release to version 2, see the blog post:

• "Major Release 2 of the Perl Distribution Workflow"

We caused some grievances for one of our users, afterwards we discussed that perhaps the distribution should have been renamed to Workflow2 to better reflect the breaking changes and to make a more clear distinction and separation. However, at the time we did not expect this to be a problem since we wanted to keep the distribution name simple and easy to remember. Instead we will try to communicate breaking changes more clearly in future major releases.

But let's see how this pans out as we are slowly approaching the next major release and what we decide on moving forward.

The challenge with Perl and version numbers is complex and now that the mentioned problems got sorted out, I do not believe we would experience them again and I for one want to avoid renaming the distribution in future major releases.

The release is available on CPAN and GitHub:

• GitHub perl-workflow release 2.09

Change log for Perl Workflow release 2.09.

2.09 2025-11-23 maintenance release, update not required

• Deprecation notice of use of XML configuration files, issue #125 and deprecation notices implementation by @ehuelsmann via PR #256.

  • YAML configuration files are now the preferred format for configuration of Workflow instances. The XML implementation was based on XML::Simple, which itself has been discouraged for use for several years. The distribution still supports XML configuration files, but this support will be removed in a future unscheduled major release.

• Improvements to test suite, PR #275 by @ehuelsmann. This is a follow up on release 2.08, since we spotted the issue in the tests running as part of the CI pipeline on GitHub

PWC 348 Task 1: String Alike

The Task

You are given a string of even length. Write a script to find out whether the given string can be split into two halves of equal lengths, each with the same non-zero number of vowels.

• Example 1:

  • Input: $str = "textbook" text | book (1, 2)
  • Output: false

• Example 2:

  • Input: $str = "book" bo | ok (1, 1)
  • Output: true

• Example 3:

  • Input: $str = "AbCdEfGh" AbCd | EfGh (1, 1)
  • Output: true

• Example 4:

  • Input: $str = "rhythmmyth" rhyth | mmyth (0, 0)
  • Output: false

• Example 5:

  • Input: $str = "UmpireeAudio" Umpire | eAudio (3, 5)
  • Output: false

Thoughts

Two steps are required: dividing the string in half, and counting vowels in each half. Let's do the obvious thing with substr to get the halves, and we can exploit the quirks of tr to count.

The examples give us a couple of important test cases: the string can contain uppercase and lowercase; and the string might not have any vowels at all. Also notice that vowels are strictly "aeiou" -- "y" is not counted as a vowel.

Code

sub strAlike($str)
{
    $str = lc($str);
    my $mid = length($str) / 2;
    my @count = map { $_ =~ tr/aeiou// }
                        substr($str, 0, $mid), substr($str, $mid);
    return $count[0] == $count[1] && $count[0] > 0;
}

Notes:

• lc($str) -- eliminate uppercase letters
• $mid = ... -- assuming even length given, as specified
• substr($str, 0, mid) -- the left half
• substr($str, $mid) -- the right half (third argument not needed). The two substr calls result in a list of two strings, which we will pass to ...
• @count = map { } -- count vowels in each substring and assign into an array of vowel counts
• $_ =~ tr/aeiou// -- Ah, tr. A quirk of tr is that it returns a count of replacements made. Replace all the vowels of interest, and there's our count. Another quirk of tr is that the first argument is not a regular expression, so there are no brackets for character class here. Note the literal use of aeiou. Yet another quirk of tr is that there is no variable interpolation, so it would be awkward to try to parameterize this.
• return ... -- The description specifies non-zero counts, so the extra condition is needed to make Example 4 work.

PWC 348 Task 2: Convert Time

The Task

You are given two strings, $source and $target, containing time in 24-hour time form. Write a script to convert the source into target by performing one of the following operations:

1. Add 1 minute
2. Add 5 minutes
3. Add 15 minutes
4. Add 60 minutes

Find the total operations needed to get to the target.

• Example 1:
  • Input: $source = "02:30" $target = "02:45"
  • Output: 1 (Add 15 minutes)
• Example 2:
  • Input: $source = "11:55" $target = "12:15"
  • Output: 2 (Add 15 minutes, Add 5 minutes)
• Example 3:
  • Input: $source = "09:00" $target = "13:00"
  • Output: 4 (Add 60 minutes four times)
• Example 4:
  • Input: $source = "23:45" $target = "00:30"
  • Output: 3 (Add 15 minutes three times)
• Example 5:
  • Input: $source = "14:20" $target = "15:25"
  • Output: 2 (Add 60 minutes, Add 5 minutes)

Thoughts

This is a variation on the problem of making change from a set of coins, or finding the combination of stamps to pay postage.

We need to find the difference in minutes from $source to $target. Example 4 shows that we might have to cross midnight.

I could take the hours and minutes apart and do the math. But I think I'd rather use well-tested modules, so I'll use Time::Piece to parse the times and find the difference.

The operation count will be taking the biggest number of chunks possible, so in reverse order: 60, 15, 5, 1.

Code

sub convert($source, $target)
{
    use Time::Piece;

    my $s = Time::Piece->strptime($source, "%H:%M");
    my $t = Time::Piece->strptime($target, "%H:%M");
    my $min = ($t - $s)->minutes;
    if ( $min <  0 ) { $min += 24*60; }

    my $count = 0;
    for my $period ( 60, 15, 5, 1 )
    {
        $count += int($min / $period);
        $min %= $period;
    }
    return $count;
}

Notes:

• strptime() -- parse the time strings and create a Time::Piece object. Without any day information, this will be a time on January 1, 1970, but we don't care.
• ($t-$s)->minutes -- Time::Piece objects can be subtracted to get a duration. That duration is actually a Time::Seconds object, which has a method that returns the duration in minutes.
• if ( $min < 0 ) -- This covers the case where $target is after midnight. We'll add 24 hours of minutes to wrap it around back to positive.
• The rest is math. Reduce by hours, then quarter-hours, then 5-minute blocks. Since the last block is 1 minute, this will always eventually terminate.