Originally published at Perl Weekly 745

Hi there!

First of all, apologies. Apparently last edition included a link the source of the Perl IDE survey and not the actual Perl IDE Survey itself. This week we hope to provide you with the correct link.

The announcement about the London Perl Workshop might have also been a bit premature as it was still unclear if it will happen at all. I am still unclear about the exact situation, but this is an excellent opportunity for you to step up. Check out the web-site of LPW where you can find the names and the contact information of the organizers. Talk to them and offer your help. Any help. That will increase the chances for this to actually take place. We even received a special announcement exclusive to the readers of the Perl Weekly.

I figured I need to update my web site and emphasize that I help companies deal with legacy code, and that made me think: What does 'legacy code' mean? How is it different from 'existing code' or 'code in production'? Is it a term use in a derogative manner? Does it mean 'code that is in use, but where the authors have disappeared'? Does it mean 'code that I am scared to touch'? Maybe 'code that still makes money, but we are unsure how it works, we need to make changes but we are scared to do'?

I'd love to hear (well, read) what do you think about it. I know I could ask the AI overlord, but I am old-school and I prefer human intelligence.

While we are figuring out how to define legacy code I thought I'll organize an online event in which we'll take a CPAN module and add some tests to it. Register here

In any case, have a nice week!

--
Your editor: Gabor Szabo.

Announcements

Perl IDE survey

After a long hiatus the Perl IDE Survey is back to another round. It will take you about 20 seconds to fill it.

Articles

6 Perl One-Liners to Replace Common Linux Utilities

why for/foreach can't use existing vars?

A lesson in scoping?

OpenAPI Linter

OpenAPI has become the standard for designing, building and documenting RESTful APIs. However, ensuring your OpenAPI specifications are both syntactically correct and follow best practices can be challenging. OpenAPI::Linter brings comprehensive validation and linting capabilities directly into your Perl applications and development workflow, helping you catch issues before they impact your API consumers.

Increasing Code coverage with Gemini

Excellent, showing the prompts help a lot!

Enhance your Gemini code assistance with a PRD document

I made a multiple-insert as well as other methods for Mojo::Pg

ANNOUNCE: Perl.Wiki V 1.33 & Mojolicious.Wiki V 1.08

Ron moved to a retirement village and still coding at 75. Nice.

App::Test::Generator 0.12

App::Test::Generator - Generate fuzz and corpus-driven test harnesses. This module takes a formal input/output specification for a routine or method and automatically generates test cases.

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

Welcome to a new week with a couple of fun tasks "Longest Parenthesis" and "Magic Expression". 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 - 345

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

TWC345

Code that is clear, effective and useful and that accurately addresses both issues. The solutions demonstrate good Perl fundamentals with straightforward algorithmic approaches.

Last Peak

This is an excellent example of using Raku's special feature set to solve a problem in a stylish, understandable and effective manner. In addition to solving the problem, Arne uses it to illustrate why Raku is a delight for algorithmic and data-centric programming. It is a brilliant pedagogical move to go from a naive to an idiomatic solution.

I Went to the Mountains

Excellent practical Perl programming is demonstrated in this post, with an emphasis on readable, maintainable code that addresses the issue at hand directly. Bob takes a methodical, deliberate approach that is full of the kind of practical judgment that distinguishes good code from great code. The technical content is very interesting because of the conversational tone and cultural allusions.

Perl Weekly Challenge: Week 345

Excellent approach to problem-solving that combines efficient debugging and logical reasoning. By pointing out edge cases, clearing up early misunderstandings and offering comprehensive explanations, Jaldhar exhibits strong analytical abilities.

The Last Peak

This is a thorough, engineering-focused in-depth analysis that places a premium on robustness, accuracy and beautiful API design. It is not merely a solution post. Jorg approaches the challenges with the rigor of a software engineer building production-grade code, not just solving puzzles.

Perl Weekly Challenge 345

A sophisticated, functionally-focused Perl solution that showcases complex programming methods like closures, iterators and functional composition. He tackles the problems with a thorough knowledge of Perl's functional programming features.

Visiting the Peaks

Brilliantly idiomatic Perl that makes use of sophisticated language features to produce succinct, effective and ingenious solutions. Matthias exhibits a thorough comprehension of Perl's contemporary features and functional programming capabilities.

Teach Them How To Say PWC…

This is a philosophical and pedagogical analysis of the Perl Weekly Challenge itself rather than a solution post. The difficulties serve as a starting point for more in-depth conversations about community, learning and the nature of programming expertise.

Peak at the answers

A simple, effective and useful Perl implementation that uses little code to accurately address both issues. Without superfluous abstraction or flourish, Peter concentrates on the fundamental algorithmic requirements. It is an example of "get the job done" programming.

The Weekly Challenge #345

A comprehensive, expertly designed set of solutions with a focus on robustness, extensive testing and unambiguous documentation. Robbie shows how to develop software in a methodical, quality-focused manner.

Position the Visitor

A highly analytical and mathematically complex method that investigates the problems underlying structure. Beyond simple implementation, Roger explores mathematical properties, algorithmic complexity and sophisticated Raku idioms.

Peak Visitors

A simple, useful implementation that puts accuracy and readability ahead of cunning. Simon is refreshingly honest about their comprehension of the issues and exhibits a methodical approach to problem-solving.

Perl Weekly Challenge: 345

A clear, useful Perl implementation that uses simple, readable code to accurately address both issues. Vinod exhibits solid Perl foundations and a pragmatic approach to problem-solving.

Weekly collections

NICEPERL's lists

Great CPAN modules released last week.

Events

Perl Maven online: Adding tests to legacy Perl code

November 11, 2025

Paris.pm monthly meeting

November 12, 2025

London Perl and Raku Workshop

November 29, 2025

Toronto.pm - online - How SUSE is using Perl

December 6, 2025

Paris.pm monthly meeting

December 10, 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.

I found the two tasks this week straight-forward and oddly specific, respectively.

Music: the task titles this week are "Peak Positions" and "Last Visitor", which led me to the refrain "I went to the mountains." It's a reference to Closer to Fine by the Indigo Girls, which references Perl philosophy: "There's more than one answer to these questions pointing me in a crooked line, and the less I seek my source for some definitive, the closer I am to fine."

However, for "Peak Positions", let's go with Ain't No Mountain High Enough by Marvin Gaye; and for "Last Visitor", with it's odd back and forth, how about the venerable Hello, Goodbye by the Beatles.

Task 1: Peak Position

The task

You are given an array of integers, @ints. Find all the peaks in the array. A peak is an element that is strictly greater than its left and right neighbors. Return the indices of all such peak positions.

The thought process

My first thought was to use List::MoreUtils::indexes to test each element, but the edges make it weird. One way or another, they will have to be handled separately. Maybe put a fake element on each end? Do them first and then process the rest? Or test for edges while looping?

My mental model is that the edges of the list fall away into an abyss, so anything outside the list should be below the altitudes given at the edge positions. I suppose it's equally valid to assume that the list is surrounded by huge ice walls (winter is coming).

There are a couple of unspecified anomalies, for which I'm going to take executive decisions:

• Empty list: return an empty list
• Single element: that's one peak at index 0
• Ramp up: (e.g. 7,8,9) the rightmost element is the only peak
• Ramp down: (e.g. 6,5,4) the left-most element is the only peak
• Plateau: (e.g., 7,7,7) No peak, return an empty list. This contradicts my decision for a single element (a plateau of one). Do I contradict myself? Very well then, I contradict myself. (I am large, I contain multitudes.)

The code

sub peakPos(@int)
{
    my @peak = ();
    for my ($i, $n) ( indexed @int )
    {
        my $left  = ( $i == 0     ) ? $n-1 : $int[$i-1];
        my $right = ( $i == $#int ) ? $n-1 : $int[$i+1];
        push @peak, $i if ( $n > $left && $n > $right );
    }
    return \@peak;
}

Notes:

• Once again I chose indexed (anointed as non-experimental in Perl 5.40) for concise and efficient array traversal.
• Each element has a left neighbor and a right neighbor. For the edges, I'm going to conjure up the missing neighbor and make it less, assuming that outside the list is a bottomless void. You know the one -- the one we scream into while we're on mute during Zoom calls.

Task 2: Last Visitor

The task

You are given an integer array @ints where each element is either a positive integer or -1. We process the array from left to right while maintaining two lists:

• @seen: stores previously seen positive integers (newest at the front)
• @ans: stores the answers for each -1

Rules:

• If $ints[i] is a positive number -> insert it at the front of @seen
  • If $ints[i] is -1:
  • Let $x be how many -1s in a row we’ve seen before this one.
  • If $x < len(@seen) -> append seen[x] to @ans
  • Else -> append -1 to @ans

At the end, return @ans.

The thought process

This task description is highly proscriptive. I'm not sure there's anything better to do here than to translate the text into Perl statements.

sub lastVisitor(@int)
{
    my @seen = ();
    my @ans  = ();

    my $x = 0;  # Count of consecutive -1s
    for ( @int )
    {
        if ( $_ > 0 )
        {
            $x = 0;
            unshift @seen, $_;
        }
        else
        {
            if ( $x < @seen )
            {
                push @ans, $seen[$x];
            }
            else
            {
                push @ans, -1;
            }
            $x++;
        }
    }
    return \@ans;
}

Notes: I don't think there's much to add. There's a couple of basic language features being exploited.

• for (@int) -- use the implicit $_ variable for array elements to avoid having to think of a name
• unshift -- put things on the front of a list
• @seen -- in scalar context gives the size of the array (no need for a length())

The only thing tricky here is incrementing and resetting $x so that it correctly counts the consecutive occurrences of -1. Because there was a possibility of error, I of course made that error, but unit tests straightened me out.

Originally published at Perl Weekly 744

Hi there,

We are excited to announce that The Trampery, located on Old Street in London, will host the London Perl Workshop 2025 on November 29, 2025. Bring your thoughts, your code, your queries and your excitement to this next must-attend Perl community event. To help shape the day, the organisers are already taking suggestions from sponsors and the community. We would like to express our gratitude in advance to all of the sponsors who help make this event possible. Our community thrives because of your support; if you or your organisation are interested in sponsorship opportunities, please review the information on the website. This is your chance to interact, learn, share and develop whether you're an experienced Perl hacker, module author, maintainer or someone who is interested in the language's future developments.

The Perl core team released the development release Perl v5.43.4 concurrently with the announcement of the event. This version provides the most recent advancements in Perl's development and is a member of the blead (development) branch. Please find the changes in the perldelta page.

26th Oct marks the 30th anniversary of the Comprehensive Perl Archive Network (CPAN), which has been driving innovation, teamwork and the Perl ecosystem for 30 years. I can still clearly recall my initial feelings of excitement and apprehension when I uploaded a module to CPAN, knowing that it would be instantly mirrored globally. When CPAN was founded in 1995, it was truly revolutionary. Built before GitHub even existed, it gave Perl a superpower that no other language at the time possessed: a global, searchable, installable archive of reusable code. The people who created the archive as well as the archive itself are what most amaze me. CPAN has always been primarily a human network, with volunteers running PAUSE, tireless testers finding bugs before users ever notice them, authors who ship with care and toolsmiths who make installations run more smoothly each year. To celebrate the occassion, I uploaded v0.67 of BankAccount::Validator::UK.

Enjoy rest of the newsletter.

--
Your editor: Mohammad Sajid Anwar.

Announcements

Development release of Perl v5.43.4

This release focuses on Unicode handling improvements and internationalization support.

London Perl Workshop 2025

It's back again, please join us for an exciting informative one day event.

Dancer2 2.0.1 Released

Dancer2 2.0.1 has been released. It's a small maintenance release that fixes a few broken documentation links.

The Perl IDE - Developer Survey 2025 is now live!

After 12 year hiatus, the Perl IDE Developer Survey has returned! Please do take part in the survey.

Articles

Perl in Jupyter Notebook: A Modern Look for a Classic Language

The article is valuable and motivational, especially for people in the Perl community who feel Perl has had less representation in data science / notebooks / ML. It shows convincingly that the building blocks exist and invites people to experiment.

0xblog — About “Perl”, in 2022

This article is inspiring and helpful, in my opinion. Anyone in the Perl community (or nearby) who wants to be reminded of Perl's modern capabilities and feel that it is still relevant should read it.

A palindromic polyglot program in x86 machine code, Perl, shell, and make

Binary Golf Grand Prix is an annual small file format competition, currently in it's sixth year. The goal is to make the smallest possible file that fits the criteria of the challenge.

Beware of Geeks bearing Grifts

Excellent technical writing - accessible deep knowledge, strong literary craft, authentic developer humor and clearly rooted in the Perl ecosystem.

CPAN

Test2::Plugin::SubtestFilter

Test2::Plugin::SubtestFilter released for Perl tests, which allows filtering test targets by subtest name, similar to --testNamePattern in jest and vitest.

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

Welcome to a new week with a couple of fun tasks "Peak Positions" and "Last Visitor". 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 - 344

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

TWC344

This blog post successfully guides the reader through the process of resolving two programming challenges and is technically sound and well-written. It exhibits sound coding techniques and strong problem-solving abilities. The main strength of the post is its easy-to-understand, step-by-step explanation style, which makes it suitable for programmers of all skill levels.

Form Formation

The post is well structured and easy to follow, introducing the challenge clearly and then solving it step by step. It uses clean, idiomatic Raku, showcasing native language strengths like permutations, MAIN signature validation and concise array/string transformations. The solutions are compact yet readable, demonstrating how expressive Raku can be for problems that would be verbose in other languages.

Pick Up the Pieces

The post provides a clear, correct and well-structured solution using backtracking. It balances readability with reasonable efficiency for small to medium-sized inputs.

Perl Weekly Challenge: Week 344

This is a brief and useful article that emphasizes offering practical solutions with little fanfare. The author demonstrates a get-it-done mentality by using a "one-liner" approach for the first problem and a simple brute-force permutation strategy for the second. The review will draw attention to some crucial scalability and robustness considerations, even though the solutions are functionally correct for the examples provided.

Turning Arrays Into Arrays

The blog post provides clear, concise and idiomatic Perl solutions to the week 344 tasks. The post provides multiple examples for each task, covering various scenarios and edge cases. This helps readers understand the problem's nuances and test their solutions effectively.

Lazyness and too much tasks!

The post is excellent as an educational and practical demonstration of Raku for these algorithmic challenges. It leverages Raku’s expressive features well amd for small to medium inputs, the solutions work effectively.

Perl Weekly Challenge 344

This is a sophisticated and well-engineered set of solutions that demonstrates deep expertise in Perl, particularly with the Perl Data Language (PDL). It provides multiple approaches for each task, showing a thorough understanding of different algorithmic strategies and their trade-offs. The code is professional, robust and well-documented.

Take it to the Limits

This is a superb example of production-quality thinking that goes far beyond typical challenge solutions. Matthias demonstrates exceptional foresight in identifying edge cases and designing scalable, robust algorithms.

A-ray Sunshine!

This technical blog post is incredibly well-written and captivating. It effectively achieves its main objective, which is to guide the reader through a challenging programming problem while elucidating the reasoning behind it, its dead ends and its elegant solution. In technical writing, it's the ideal illustration of "show your work".

Hip, hip, array!

In the great majority of real-world use cases, this solution accurately resolves the issue and is clear, practical and effective. It creates a sophisticated one-liner by utilizing Perl's advantages in handling strings and numbers. The fundamental requirement of the problem—converting between array and numerical representations—is clearly understood by Peter.

The Weekly Challenge #344

For the examples provided, Robbie offers two workable solutions that accurately address the challenge problems. The solutions are straightforward and practical, prioritizing clarity and simplicity over scalability or optimization for edge cases. The code has a clear structure and useful documentation.

All is Array Formation

This blog post goes beyond standard challenge solutions and is incredibly intelligent and sophisticated. In addition to solving the problems, Roger delves into complex computer science ideas and skillfully makes connections between the two seemingly unconnected tasks. The post exhibits expert-level understanding of functional programming paradigms, algorithms and programming language theory.

The one about arrays

This explanation of the Weekly Challenge solutions is clear, easy to understand and useful. Beginners and intermediate developers will find Simon's conversational, tutorial-like style especially approachable. The article emphasizes readability and direct problem-solving over algorithmic optimization, with a focus on concise, practical Perl solutions.

Perl Weekly Challenge: 344

These are clean, practical and clever solutions that demonstrate excellent Perl idioms and pragmatic problem-solving. Vinod favors simplicity and readability while leveraging Perl's unique strengths effectively.

Rakudo

2025.42 Release #186 (2025.10)

Weekly collections

NICEPERL's lists

Great CPAN modules released last week.

Events

Paris.pm monthly meeting

November 12, 2025

London Perl and Raku Workshop

November 29, 2025

Toronto.pm - online - How SUSE is using Perl

December 6, 2025

Paris.pm monthly meeting

December 10, 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 344

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: Array Form Compute

Task

You are given an array of integers, @ints and an integer, $x.

Write a script to add $x to the integer in the array-form.

The array form of an integer is a digit-by-digit representation stored as an array, where the most significant digit is at the 0th index.

My solution

The easiest solution would be to turn the ints array into an integer, add the value and then turn it back into an array. However, I don't think this is what this challenge is about.

So it's back to doing things like we did in primary school math classes. For input from the command line, I take the last argument as x and the rest of the arguments as ints (a list in Python, array in Perl).

I start by making sure that ints only contains a single digit and x is a non-negative integer.

def array_form_compute(ints: list[int], x: int) -> list[int]:
    if any(not isinstance(n, int) or n < 0 or n > 9 for n in ints):
        raise ValueError("All elements in the list must be single digit integers (0-9).")

    if x < 0:
        raise ValueError("The integer x must be a non-negative integer.")

The next step is to handle all but the most significant (first) digit. Working backwards (last digit first), I set the pos variable to determine the position of the digit I am working on. I set i to the value of the integer at the position.

I take the x value and split it using the divmod function. The remainder is the remainder of diving x by 10 (i.e. the last digit), and x is now the integer division which is used in the next iteration.

    for pos in range(len(ints) -1, 0, -1):
        i = ints[pos]
        x, remainder = divmod(x, 10)

This is where primary school math comes into play. If i + remainder is more than one digit (i.e. greater than 9), then the last digit of the sum becomes the new i and the other digits are added to the integer before it. In this case, it is added to the x value.

        add_x, add_i = divmod(i + remainder, 10)
        ints[pos] = add_i
        x += add_x

Lastly I need to handle the most significant digit slightly differently. In this case, where ints[0] + x is greater than or equal to 10, I need to split the digits of the new number to a list of individual digits.

    ints[0] += x
    if ints[0] >= 10:
        digits = map(int, str(ints[0]))
        ints = list(digits) + ints[1:]

Finally, I return the new list, or print the array in Perl.

    return ints

The Perl solution follows the same logic. It doesn't have a built in divmod function, so I created one.

sub divmod($a, $b) {
    my $div = int($a / $b);
    my $mod = $a % $b;
    return ($div, $mod);
}

Examples

$ ./ch-1.py 1 2 3 4 12
[1, 2, 4, 6]

$ ./ch-1.py 2 7 4 181
[4, 5, 5]

$ ./ch-1.py 9 9 9 1
[1, 0, 0, 0]

$ ./ch-1.py 1 0 0 0 0 9999
[1, 9, 9, 9, 9]

$ ./ch-1.py 0 1000
[1, 0, 0, 0]

Task 2: Array Formation

Task

You are given two list: @source and @target.

Write a script to see if you can build the exact @target by putting these smaller lists from @source together in some order. You cannot break apart or change the order inside any of the smaller lists in @source.

My solution

For input from the command line, I take a JSON string from the first argument and convert that to the source variable. The remaining arguments make up the target value.

This is one challenge that is a lot easier to complete in Python than in Perl. I explain the Python solution.

I start by seeing if a solution is indeed possible. This is done by counting the frequency of all digits in both the source and target lists and seeing if they are the same. If they are not the same, I return False.

def array_formation(source: list[list[int]], target: list[int]) -> bool:
    # Check that a solution is possible
    if Counter(chain.from_iterable(source)) != Counter(target):
        return False

There are a few inbuilt features in the above.

• itertools.chain.from_iterable is a function that will flatten a list of lists in to a single list.
• collections.Counter will turn an iterable (in this case a list) and turn it into a dictionary with the value as the key and the frequency as the value.
• In Python, comparing two dictionaries for equality will compare to see if the key and value are the same. The order of the keys does not matter.

From here, there are two possible approaches to take. One would be to call a recursive function to try all valid starting numbers recursively until we found the one that works. Given the examples (where there is only a few lists in the source value), this seems like an unneeded optimization.

So I took the brute force approach and compute all permutations of the source list. If I find the right one, I return True. If I exhaust all permutations, I return False.

Python has the permutations function from the itertools module. In Perl, the Algorithm::Combinatorics function does the same.

    for perm in permutations(source):
        combined = list(chain.from_iterable(perm))
        if combined == target:
            return True

    return False

The Perl solution follows the same logic. It does not have an inbuilt way to flatten so I wrote my own.

sub flatten_array($list) {
    return map { @$_ } @$list;
}

It also cannot compare an array for equality, so I faked it by joining the lists with spaces and then tested if the two strings are equal.

sub compare_array ( $list1, $list2 ) {
    return join( ' ', @$list1 ) eq join( ' ', @$list2 );
}

To check that a solution is possible, I numerically sort the source and target values to check if they are equal.

sub array_formation( $source, $target ) {
    if (
        not compare_array(
            [ sort { $a <=> $b } flatten_array($source) ],
            [ sort { $a <=> $b } @$target ]
        )
      )
    {
        return 'false';
    }

    my $iter = permutations($source);
    while ( my $perm = $iter->next ) {
        if ( compare_array( [ flatten_array($perm) ], $target ) ) {
            return 'true';
        }
    }

    return 'false';
}

Examples

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

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

$ ./ch-2.py "[[9,1], [5,8], [2]]" 5 8 2 9 1
True

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

$ ./ch-2.py "[[7,4,6]]" 7 4 6
True

Task 2: Array Formation

The Task

You are given two lists: @source and @target.

Write a script to see if you can build the exact @target by putting these smaller lists from @source together in some order. You cannot break apart or change the order inside any of the smaller lists in @source.

Example 1:

• Input: @source=([2,3], [1], [4]), @target=(1, 2, 3, 4)
• Output: true
• Use in the order: [1], [2,3], [4]

Example 2:

• Input: @source=([1,3], [2,4]), @target=(1, 2, 3, 4)
• Output: false

Example 3:

• Input: @source=([9,1], [5,8], [2]), @target=(5, 8, 2, 9, 1)
• Output: true
• Use in the order: [5,8], [2], [9,1]

Example 4:

• Input: @source=([1], [3]), @target=(1, 2, 3)
• Output: false
• Missing number: 2

Example 5:

• Input: @source=([7,4,6]), @target=(7, 4, 6)
• Output: true
• Use in the order: [7, 4, 6]

The Thought Process

The musical selection for our programming journey is the funky disco-adjacent Pick Up the Pieces, by Average White Band. It was a number one hit in 1974, a time when it was still possible for an instrumental tune to make the charts. Fun personal anecdote: in my high school, the English department partnered with a local radio station (KYVA AM 1230 in Gallup, New Mexico) to put on a 15-minute show on Thursday evenings, and "Pick Up the Pieces" was our intro music.

Nostalgia aside, with a small number of lists in @source, it's tempting to just plow through all the possible combinations and see if any work, but factorial complexity is scary.

There's a little bit of ambiguity in the description. Although the examples imply it, it's not clear if we need to use all the substrings in @source, or if we can accept a solution that only uses some of them. I'm going with not necessarilly using all of the lists in @source if we don't need them.

What about reusing them? I'm going to say no to that.

The solution I lean toward is to use a stack of possibilities and backtrack if we can't satisfy the @target.

The Code

Does it blend?

Let's start with the sub-problem of checking if one of the lists in @source is a prefix of @target. I want a predicate function that answers whether a list p is a leading prefix of a list t.

sub isPrefix($p, $t)
{
    return false if @$p > @$t;
    my $match = true;
    for my ($i, $n) ( indexed $p->@* )
    {
        $match &&= ($n == $t->[$i]);
    }
    return $match;
}

Notes:

• Our arguments are array references, so we'll be de-referencing them a lot.
• If $p is longer than $t, then it can't possibly be a prefix.
• Start by assuming that the answer is yes.
• The indexed builtin in Perl is a convenient way to get variables for the index and the thing at the index in a simple syntax. Love it.
• For each element in the prefix, $match continues to be true if the same position $t matches. We could bail from the loop as soon as $match becomes false, but with expected short lists, it might be faster to complete the loop than to insert more logic into each execution. No, I'm not going to benchmark for it.

Does it match?

On to the main event. I want to pick lists from @source that match the beginning of @target. Then, I remove that from consideration, both from @source and from the front of @target. Repeat.

If we hit a dead end, I want to be able to backtrack to an earlier point, so I'll stack my possibilities.

sub canMake($source, $target)
{
    my @stack = ( [ [ $source->@* ], [ $target->@*] ] );
    while ( @stack )
    {
        my ($s, $t) = pop(@stack)->@*;

        for my ($i, $p) (indexed $s->@* )
        {
            next unless isPrefix($p, $t);

            my @t = $t->@*;     # Make a copy of remaining target.
            splice(@t, 0, @$p); # Remove prefix from target.

            # Have we completely matched the target?
            if ( @t == 0 )
            {
                return true;
            }

            my @s = $s->@*;     # Make a copy of remaining source.
            splice(@s, $i, 1);  # Remove the segment we used.

            push @stack, [ \@s, \@t ];  # Try again with smaller sets.
        }
    }
    return false;
}

Notes:

• Although the task description uses arrays, I'm passing in array references.
• @stack = ( [ ..., ...] ) -- Every element of @stack is a pair: the current set of possible lists, and the current target list. The stack starts with a copy of @source and a copy of @target. There's a lot of references here, and I want to operate on copies, not accidentally change things by going through references.
• The main loop continues as long as there are things to try on the stack. There will be at least one iteration, because we explicitly pushed one possibility.
• Take the top thing off the stack, and assign the anonymous references to variables we can use. $s will be a reference to the possible source lists, and $t will be a reference to the remaining target list that we have to match.
• Oh look, it's indexed again. When I want to remove a list from @source, I'll need to know its position in $s, so this is a convenient way to get it.
• Weed out candidates that aren't prefixes of @target. Luckily we have that isPrefix function. If none of the remaining lists match $t, then we'll backtrack to whatever was on the stack.
• If we have a working prefix, we'll want to reduce our data. Make copies, and remove the matching pieces.
• There are two uses of splice: one to chop off the prefix of $t, and one to surgically remove one element out of $s. It amazes and depresses me that after all these years, I still have to re-read the documentation for splice to remind myself of the order of arguments and what gets returned.
• If we've whittled $t down to nothing, success! At this point, if we wanted to enforce the requirement to use all of @source, we could also check that the size of $s is down to 1 (not zero, because we haven't cleaned it up yet).
• Note here that if we wanted to allow reuse of the lists in @source, we could do it by not removing the chosen prefix at this point.
• Now we're down to a smaller set of possibilities. Push that checkpoint to the top of the stack and continue.
• If we ever get out of this loop, it means that we never got @target down to zero, so that's a "no" from me, dawg.