Originally published at Perl Weekly 751

Hi there,

Ten days ago I participated at an online event organized by the Toronto Perl Mongers. where we had some really nice presentations about OpenQA and the Open Build Service, both written (partially) in Perl. I hope they are going to organize more such events about other projects written in Perl.

Last week I spent some time tracking down the LinkedIn profile of some of the authors who had entries included in the Perl Weekly and I also managed to include the picture of quite a few people. However I'd like to get your help to further enhance this.

All the authors are described in the authors.json file. I'd love to get your help in tracking down the missing details. For some authors we don't even have the names. Many are missing the image and the other details you might find for others. In addition I'd like to further enhance the listing by adding a link to the github and gitlab profile of each author. Would you like to help? Send a Pull-Request!

If we are already talking about contribution, we are going to have another online Perl Maven event contributing to a CPAN module. Register now!

Enjoy your week!

--
Your editor: Gabor Szabo.

Articles

Teaching Art to Computers the Hard Way

How many of you were told that "You shouldn't do art" by some teacher? Was Mondrian told the same? Here Ruth breaks the spell using Moo, SVG::Simple, and Imager.

The Ghost of Web Frameworks Future

PAGI, Perl Asynchronous Gateway Interface: The Spiritual Successor to PSGI. discuss

Layout strategy for a script with supporting functions

Talking about your in-house solution, getting feedback, getting suggestions how to pick a name for it, where is your public repo?

A Pod plugin for VSCode

The Night Before Deployment: How Melian Saved Christmas (and How It Can Speed Up Your App Too)

December 23rd is the annual Mega Load Test for the Christmas Eve delivery system. Every service (the Toy Inventory API, the Naughty-or-Nice Scoring Engine, the Elf Logistics Portal) suddenly wakes up to millions of requests. And every year, something new falls over. This year, it was the Toy Service.

Thirty Slices, Twenty-Four Days: How Christmas Was Saved By Abandoning Estimation

The Twelve Slices Of Christmas: How Vasco Chained the Chaos

Behind the scenes at Perl School Publishing

Grants

Maintaining Perl (Tony Cook) November 2025

Tony wrote: "In addition to the typical stream of small changes to review, Dave's second AST rebuild of ExtUtils::ParseXS arrived (#23883), and I spent several hours reviewing it."

PEVANS Core Perl 5: Grant Report for November 2025

Paul wrote: "A mix of things this month, though I didn't get much done in the final week because of preparations for my talk at LPW2025. A useful event though because a few ideas came out of discussions that I shall be looking at for core perl soon."

Maintaining Perl 5 Core (Dave Mitchell): November 2025

Dave wrote: "Last month was relatively quiet. I worked on a couple of bugs and did some final updates to my branch which rewrites perlxs.pod - which I intend to merge in the next few days."

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

Welcome to a new week with a couple of fun tasks "Match String" and "Binary Prefix". 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 - 351

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

TWC351

The post provides concise, runnable Perl code that solves the stated problems for typical cases.

Special Progression

This is a well-crafted, educational post. Arne successfully solves the challenges with idiomatic Raku, provides clear explanations, and thoughtfully explores the efficiency vs. elegance trade-off by implementing multiple solutions.

Average Progression

Special Average task uses a standard and efficient approach. The solutions correctly filter out the minimum and maximum values and calculate the average of the remaining numbers. Arithmetic Progression task employs a highly advanced and unconventional method.

Perl Weekly Challenge 351

This solution takes a mathematical, array-oriented approach using Perl Data Language (PDL), demonstrating sophisticated numerical computing techniques rather than traditional Perl list processing.

A pretty average progression…

The post presents clean, readable, and correct solutions to both programming tasks in Raku, Perl, Python, and Elixir. It adopts a straightforward, practical approach without unnecessary complexity. Packy thoughtfully acknowledges trade-offs in their design choices.

Fun with arrays

This is a well-structured, practical implementation with good documentation and error handling. Peter demonstrates solid Perl programming practices while making reasonable design decisions based on their interpretation of the problem requirements.

The Weekly Challenge #351

This is a professional, well-documented, robust implementation with excellent attention to detail, defensive programming, and clean code organization. Robbie demonstrates advanced Perl expertise with thoughtful design choices.

Special Arithmetic

The blog post provides functionally correct and easy-to-understand solutions for two programming tasks. Roger makes deliberate, practical choices in their implementations, explicitly favoring simplicity over micro-optimizations for problems of "this scale."

Average Progression

This post presents concise, readable solutions to two programming tasks Perl and Python. The solutions are algorithmically correct, efficient, and practically focused, making them suitable for real-world use.

Weekly collections

NICEPERL's lists

Great CPAN modules released last week.

Events

Perl Maven online: Live Open Source contribution

December 26, 2025

Boston.pm - online

January 13, 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 351

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

Task

You are given an array of integers.

Write a script to return the average excluding the minimum and maximum of the given array.

My solution

This task doesn't require much explanation. I start by calculating the min_value and max_value. I then have a list (array in Perl) called short_list which has the original integers with any min_value or max_value values removed.

If the short_list is empty, I return 0. Otherwise I return the average ( sum ÷ length ) of the short list.

def special_average(ints: list) -> float:
    min_value = min(ints)
    max_value = max(ints)
    short_list = [n for n in ints if n != min_value and n != max_value]

    if not short_list:
        return 0

    return sum(short_list)/len(short_list)

The Perl solution has the same logic, and uses the grep function to remove values.

sub main (@ints) {
    my $min_value = min(@ints);
    my $max_value = max(@ints);
    my @short_array = grep { $_ != $min_value && $_ != $max_value } @ints;

    if ($#short_array == -1) {
        say 0;
    }

    say sum(@short_array) / scalar(@short_array);
}

Examples

$ ./ch-1.py 8000 5000 6000 2000 3000 7000
5250.0

$ ./ch-1.py 100000 80000 110000 90000
95000.0

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

$ ./ch-1.py 2000
0

$ ./ch-1.py 1000 2000 3000 4000 5000 6000
3500.0

Task 2: Arithmetic Progression

Task

You are given an array of numbers.

Write a script to return true if the given array can be re-arranged to form an arithmetic progression, otherwise return false.

A sequence of numbers is called an arithmetic progression if the difference between any two consecutive elements is the same.

My solution

This task might throw up some gotchas by some less experience developers. Experienced developers should know that 0.1 + 0.2 is not 0.3. The reason for this is explained in this Python web page.

$ python3
Python 3.13.9 (main, Oct 14 2025, 00:00:00) [GCC 15.2.1 20250808 (Red Hat 15.2.1-1)] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>> 0.1 + 0.2
0.30000000000000004

Therefore the inputs to this function need to be either integers or of the Decimal type. With that out of the way, these are the steps I take

1. Create a sorted_list list (array in Perl) which has the values sorted numerically (smallest first).
2. Create a variable diff that is the difference between the first two values (i.e. sorted_ints[1] - sorted_ints[0]).
3. Have a loop called i which stats with 2 to one less than the length of the list. For each iteration, I check the difference between the number at that position and the previous one is the same as diff. If it isn't, I return False.
4. Once the loop is exhausted, I return True.

def arithmetic_progression(ints: list) -> bool:
    sorted_ints = sorted(ints)
    diff = sorted_ints[1] - sorted_ints[0]

    for i in range(2, len(sorted_ints)):
        if sorted_ints[i] - sorted_ints[i - 1] != diff:
            return False

    return True

Perl also uses the same floating point arithmetic, and thus has the same issue. Perl has the Math::BigFloat function to handle this. The Perl solution uses the same logic, and converts the values to BigFloat before doing the computations.

sub main (@ints) {
    my @sorted_ints = map { Math::BigFloat->new($_) } sort { $a <=> $b } @ints;
    my $diff        = $sorted_ints[1] - $sorted_ints[0];

    foreach my $i ( 2 .. $#sorted_ints ) {
        if ( $sorted_ints[$i] - $sorted_ints[ $i - 1 ] != $diff ) {
            say 'false';
            return;
        }
    }

    say 'true';
}

Examples

$ ./ch-2.py 1 3 5 7 9
True

$ ./ch-2.py 9 1 7 5 3
True

$ ./ch-2.py 1 2 4 8 16
False

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

$ ./ch-2.py 1.5 3 0 4.5 6
True

$ ./ch-2.py 0.1 0.3 0.2 0.4
True

Originally published at Perl Weekly 750

Hi there,

One of the most enjoyable yearly customs in the community, the Perl Advent Calendar 2025, is being introduced this week. A new article, tutorial, or in-depth analysis demonstrating the ingenuity and skill that continue to propel Perl forward is released every day.

The calendar has something for every skill level, whether you're interested in cutting-edge Perl techniques, witty one-liners, CPAN gems, or true engineering tales. It serves as a reminder that Perl's ecosystem is still active, creative, and developing-driven by a fervent community that enjoys exchanging knowledge.

If you still want more, be sure to check out, The Weekly Challenge Advent Calendar 2025. There you'll find not just Perl, but Raku as well.

Last but not least, I'd like to extend my heartfelt thanks to Gabor Szabo for kindly promoting my book: Design Patterns in Modern Perl - your support means a great deal. And to the Perl community: thank you for embracing my first book with such warmth and encouragement. Your enthusiasm continues to inspire me.

Enjoy rest of the newsletter, stay safe and healthy.

--
Your editor: Mohammad Sajid Anwar.

Articles

PAGI: ASGI For Perl, or the Spiritual Successor to Plack

PAGI (Perl Asynchronous Gateway Interface) is a new specification for async Perl web applications, inspired by Python's ASGI. It supports HTTP, WebSockets, and Server-Sent Events natively, and can wrap existing PSGI applications for backward compatibility.

plenv-where

A plenv plugin to show which Perl versions have a particular module.

LPW 2025 - Event Report

Here is my detailed report of LPW 2025 that includes the slides of my presentation.

Living Perl: Building a CNN Image Classifier with AI::MXNet

This article demonstrates Perl's continued relevance in cutting-edge fields by showcasing integration with MXNet, a major deep learning framework. The ability to build convolutional neural networks (CNNs) in Perl for image classification represents significant technical sophistication.

Perl Advent Calendar

The Ghost of Perl Developer Surveys Past, Present, and Future

The article demonstrates sophisticated understanding of developer tooling ecosystems and community trends. The comparison between 2009-2010 surveys and the 2025 results shows deep insight into how Perl development practices have evolved while maintaining continuity.

All I Want for Christmas Is the Right Aspect Ratio

The step-by-step progression from simple Perl script to full Docker deployment serves as an excellent tutorial on modern Perl module distribution. It shows how a well-designed module can serve diverse audiences from command-line power users to web developers to DevOps teams.

Santa's Secret Music Studio

The step-by-step approach from "need to identify devices" to "controlling a synth" serves as an excellent mini-tutorial. The mention of related modules (MIDI::RtController, MIDI::RtController::Filter::Tonal) provides helpful pointers for readers wanting to explore further.

Stopping the Evil Grinch: A Holiday Defense Guide

This article demonstrates enterprise-grade security automation using Perl as a robust orchestration layer. The solution elegantly combines multiple security tools (Lynis for auditing, ClamAV for malware scanning) with professional email reporting.

Santa needs to know about new toys...

This article successfully teaches professional API integration through storytelling, making technical concepts accessible while demonstrating production-ready Perl code patterns. The holiday theme enhances rather than distracts from the educational content.

ToyCo want to push new toy updates

This article beautifully demonstrates transitioning from a polling-based API client to a webhook-based service - a common and important architectural pattern in modern web development. The scenario of "crippling ToyCo's servers" with excessive polling is both realistic and educational.

Abstract storage of Christmas letters

This solution demonstrates sophisticated software design with the strategic use of Storage::Abstract to create a clean abstraction layer between business logic and data storage. The anticipation of changing storage requirements and preemptive abstraction is professional forward-thinking.

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

Welcome to a new week with a couple of fun tasks "Special Average" and "Arithmetic Progression". 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 - 350

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

TWC350

This implementation demonstrates elegant Perl craftsmanship. The good substrings solution is particularly clever, using a regex lookahead to capture all overlapping 3-character substrings in one pass, then filtering to ensure no repeated characters - a beautifully concise one-liner.

The Good Shuffle

The solutions demonstrate strong understanding of both algorithmic thinking and Raku language features. The shuffle pairs solution is particularly clever in its use of canonical forms and early termination conditions.

Good Substring / Shuffle Pairs

The Perl implementation demonstrates clean, readable code with thoughtful organization. The good substrings solution uses efficient array slicing and clear manual comparison logic that's easily understandable.

Shuffled Strings

This is an exceptionally elegant Perl implementation showcasing expert-level Perl idioms. Both solutions exemplify Perl's philosophy of "making easy things easy and hard things possible" with concise, expressive code that solves the problems elegantly without unnecessary complexity.

only Perl!

This is a comprehensive and impressively diverse implementation across multiple languages and environments. The Raku solutions showcase excellent use of the language's functional features. The PL/Perl implementations are particularly noteworthy for their adaptability to database environments.

Perl Weekly Challenge 350

This solution stands out for its deep mathematical analysis and optimization. The Task 2 solution demonstrates remarkable theoretical insight by using modular arithmetic with modulo 9 to significantly reduce the search space - achieving a 5.2x speedup is an impressive feat of algorithmic optimization.

Shuffling the Good

This solution demonstrates exceptional cross-language programming skills with clean, idiomatic implementations across four different languages (Raku, Perl, Python, Elixir). The consistent algorithmic approach while respecting each language's unique idioms shows deep understanding of multiple programming paradigms.

Good pairs

Both solutions showcase excellent Perl craftsmanship with thoughtful comments, clear variable naming, and robust handling of edge cases. Peter demonstrates both theoretical understanding (mathematical bounds, algorithmic complexity) and practical implementation skills.

The Weekly Challenge #350

This is a masterclass in professional Perl documentation and code structure. The solutions feature comprehensive POD documentation with clear attribution, problem descriptions, notes, and IO specifications - demonstrating exceptional software engineering practices.

A Good Shuffle

This solution demonstrates elegant Perl craftsmanship with a particularly clever approach. Using a regex with a lookahead assertion /(?=(...))/g to capture overlapping substrings is an expert-level Perl idiom that showcases deep understanding of the language's regex capabilities.

Good shuffling

This solution demonstrates excellent cross-language programming skills with clear parallel implementations in both Python and Perl. The Task 1 solution is elegantly simple - the Python version using set(substr) for uniqueness checking and the Perl version using a hash with early returns showcase appropriate idioms for each language while maintaining the same algorithmic approach.

Rakudo

2025.48 Advent is Here

Weekly collections

NICEPERL's lists

Great CPAN modules released last week;
MetaCPAN weekly report.

Events

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 350

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

Task

You are given a string.

Write a script to return the number of good substrings of length three in the given string. A string is good if there are no repeated characters.

My solution

This is relatively straight forward, so doesn't require much explanation. I have a variable called i that starts at zero and ends with three less than the length of the string. For each iteration, I extract the the three letters starting at the specified position. If the three letters are unique, I add one to the count variable.

def good_substr(input_string: str) -> int:
    count = 0

    for i in range(len(input_string) - 2):
        substr = input_string[i:i + 3]

        if len(set(substr)) == 3:
            count += 1

    return count

In Python, I convert the three characters to a set. If the length of the set is 3, I know all characters are unique (sets can only store unique values). In Perl, I use a %chars hash. If a letter is already seen, it will return 0.

sub is_unique ($substr) {
    my %chars;
    foreach my $char (split //, $substr) {
        return 0 if exists $chars{$char};
        $chars{$char} = 1;
    }
    return 1;
}

Examples

$ ./ch-1.py abcaefg
5

$ ./ch-1.py xyzzabc
3

$ ./ch-1.py aababc
1

$ ./ch-1.py qwerty
4

$ ./ch-1.py zzzaaa
0

Task 2: Shuffle Pairs

Task

If two integers A <= B have the same digits but in different orders, we say that they belong to the same shuffle pair if and only if there is an integer k such that B = A × k where k is called the witness of the pair.

For example, 1359 and 9513 belong to the same shuffle pair, because 1359 * 7 = 9513.

Interestingly, some integers belong to several different shuffle pairs. For example, 123876 forms one shuffle pair with 371628, and another with 867132, as 123876 × 3 = 371628, and 123876 × 7 = 867132.

Write a function that for a given $from, $to, and $count returns the number of integers $i in the range $from <= $i <= $to that belong to at least $count different shuffle pairs.

My solution

This is an interesting challenge as the solution requires some thinking. Additionally there was an error with the original page, so I raised a pull request to fix it.

I start by setting the shuffle_pairs variable to zero. I have a loop with the variable value that starts at from and ends with to (inclusive). As from is a reserved word in Python, I use the variables start and end.

For each iteration of value, I do the following.

1. Set the variable this_count to zero. This will store the number of shuffle pairs for this value.
2. Set the variable multiplier to 2.
3. Set a variable called candidate to the product of value and multiplier.
4. If this is a shuffle_pair, increment the this_count value.
5. If the candidate is equal to or greater then 10^{length of value}, end the loop. As this number has more digits than the original, no shuffle pair can be found for this candidate.
6. Once the previous step is reached, increment the shuffle_pair value if this_count >= count.

def shuffle_pairs(start: int, stop: int, count: int) -> int:
    shuffle_pairs = 0

    for value in range(start, stop + 1):
        this_count = 0

        multiplier = 2
        while True:
            candidate = value * multiplier
            if candidate >= 10 ** len(str(value)):
                break
            if is_shuffle_pair(value, candidate):
                this_count += 1

            multiplier += 1

        if this_count >= count:
            shuffle_pairs += 1

    return shuffle_pairs

The Perl solution follows the same logic.

Examples

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

$ ./ch-2.py 1500 2500 1
3

$ ./ch-2.py 1000000 1500000 5
2

$ ./ch-2.py 13427000 14100000 2
11

$ ./ch-2.py 1030 1130 1
2

Musical Interlude

The movie version of Wicked is in theaters right now, so I am reminded of the song For Good -- but I'm gonna link to the Broadway version, because I'm classy like that. It's relevant to programming in Perl because "I don't know if I've been changed for the better, but I have been changed for good." For part two, Lido Shuffle by Boz Scaggs.

Task 1: Good Substrings

The Task

You are given a string. Write a script to return the number of good substrings of length three in the given string. A string is good if there are no repeated characters.

• Example 1: Input $str = "abcaefg", Output: 5
  • Good substrings of length 3: abc, bca, cae, aef and efg
• Example 2: Input: $str = "xyzzabc", Output: 3
• Example 3: Input: $str = "aababc", Output: 1
• Example 4: Input: $str = "qwerty", Output: 4
• Example 5: Input: $str = "zzzaaa", Output: 0

The Think-y Part

There's probably a regular expression for this, but I'm not going to find it. Do the simplest thing that works: take three characters at a time and see if they're different.

The Code-y Part

sub goodSubstring($str)
{
    my $good = 0;
    my @s = split(//, $str);
    for ( 0 .. $#s - 2 )
    {
        my ($first, $second, $third) = @s[$_, $_+1, $_+2];
        $good++ if ( $first ne $second && $first ne $third && $second ne $third );
    }
    return $good;
}

Notes:

• Start by turning the string into a list of characters. It could be done with substr, but that would be untidy.
• @s[$_, $_+1, $_+2] -- With a nod to readability, I'll extract three consecutive characters with an array slice. It occurs to me that I'll always have two of the next three characters in hand at the bottom of the loop, so doing a complete splice every time could probably be optimized, but I declare it "good" enough.
• Since there's exactly three characters in play, check for uniqueness in the most obvious way.

Task 2:Shuffle Pairs

The Task

If two integers A <= B have the same digits but in different orders, we say that they belong to the same shuffle pair if and only if there is an integer k such that A = B * k. k is called the witness of the pair. For example, 1359 and 9513 belong to the same shuffle pair, because 1359 * 7 = 9513.

Interestingly, some integers belong to several different shuffle pairs. For example, 123876 forms one shuffle pair with 371628, and another with 867132, as 123876 * 3 = 371628, and 123876 * 7 = 867132.

Write a function that for a given $from, $to, and $count returns the number of integers $i in the range $from <= $i <= $to that belong to at least $count different shuffle pairs.

• Example 1:
  • Input: $from = 1, $to = 1000, $count = 1
  • Output: 0
  • There are no shuffle pairs with elements less than 1000.

• Example 2:

  • Input: $from = 1500, $to = 2500, $count = 1
  • Output: 3
  • There are 3 integers between 1500 and 2500 that belong to shuffle pairs.
    • 1782, the other element is 7128 (witness 4)
    • 2178, the other element is 8712 (witness 4)
    • 2475, the other element is 7425 (witness 3)

• Example 3:

  • Input: $from = 1_000_000, $to = 1_500_000, $count = 5
  • Output: 2
  • There are 2 integers in the given range that belong to 5 different shuffle pairs.
    • 1428570 pairs with 2857140, 4285710, 5714280, 7142850, and 8571420
    • 1429857 pairs with 2859714, 4289571, 5719428, 7149285, and 8579142

• Example 4:

  • Input: $from = 13_427_000, $to = 14_100_000, $count = 2
  • Output: 11
  • 6 integers in the given range belong to 3 different shuffle pairs,
  • 5 integers belong to 2 different ones.

• Example 5:

  • Input: $from = 1030, $to = 1130, $count = 1
  • Output: 2
  • There are 2 integers between 1020 and 1120 that belong to at least one shuffle pair:
    • 1035, the other element is 3105 (witness k = 3)
    • 1089, the other element is 9801 (witness k = 9)

Deliberations

It takes a minute to digest this one.

I first wondered if there's some algebraic number theory trick that would cut the search space way down, but that made my head hurt, so I moved to doing what computers do best: grinding through a lot of possibilities.

A bad first thought was to try all combinations of the digits, but that's going to die an excruciating slow death on the crucifix of combinatorics, not to mention that we'd be completely wasting our time on all but a few combinations.

A better thought is to look only at the multiples of a given number. There are at most 8 multiples of a number in play: the 10th would add a digit, and therefore can't possibly be a reordering. Examples 3 and 4 have a lot of numbers to grind through, but how long can it take, really? It's one banana, Michael; how much could it cost, ten dollars?

How will I decide that a number is a re-ordering? I think I'll reduce each number to a canonical form where the digits are sorted, then use string compare to see if a multiple has the same canonical form.

To the bat-editor, Robin!

First, a little function to turn a number into a canonical form with its digits in sorted order. Turn the number into a list of digits, sort, and then join the digits back into a string.

sub canonical($n)
{
    join("", sort split(//, $n));
}

Now the main course. I'll want to examine every number in the range $from to $to, inclusive. For each number, I'll want to examine its multiples to see if they have the same digits. I need to count the ones that work so that I can check that there are at least $count of them.

sub shufflePair($from, $to, $count)
{
    my $answer = 0;

    for my $n ( $from .. $to )
    {
        my $base = canonical($n);
        my $max = (9 x length($n))+0;
        my $pair = 0;
        for ( 2 .. 9 )
        {
            my $multiple = $n * $_;

            next if $multiple > $max
                 || index($base, substr($multiple,  0, 1)) < 0
                 || index($base, substr($multiple, -1, 1)) < 0;

            if ( canonical($multiple) eq $base )
            {
                $pair++;
            }
        }
        $answer++ if $pair >= $count;
    }
    return $answer;
}

Notes:

• my $base = canonical($n) -- hang on to this for comparison.
• my $max = (9 x length($n))+0; -- An optimization. The maximum number we need to be concerned with is one that has the same number of digits, but is all 9s. For example, if $n is 480, then we are dealing with 3-digit numbers, so the largest possible is 999. That's less than 480*3=1440, so we don't have to examine any of the multiples beyond 480*2.
• for ( 2..9 ) -- These are the only multiples of $n that could possibly have the same number of digits.
• next if ... -- Besides the check on $max, we can make cheap checks on a single digit. If the first or last digit isn't one of the possible digits, we can avoid the overhead of canonical(), which isn't horrendous, but it does involve allocating lists and a sort.
• canonical($multiple) eq $base -- This string compare is where we decide if we have a shuffle pair.
• $answer++ if $pair >= $count -- We increment the answer if this number has at least $count shuffle pairs.

This solution takes a few seconds to run the examples. My optimizations to bail early in many cases cut the run time approximately in half (from about 8 seconds to about 4.5).