Forem: vinodk89

Perl Weekly Challenge - 360: Perl Power: Two Tiny Scripts, Big Learning!

vinodk89 — Sun, 15 Feb 2026 11:09:05 +0000

This week, I challenged myself to write small but meaningful Perl programs for Weekly Challenge — focusing on clean logic, edge cases, and test-driven validation.

Sometimes, the simplest problems teach the strongest lessons.

Challenge 1: Text Justifier (Centering Text with Custom Padding)

Problem Statement
Write a script to return the string that centers the text within that width using asterisks * as padding.

If the string length is greater than or equal to the width, return the string as-is.

Example
Input:

("Hi", 5)

Output:

*Hi**

Implementation Highlights

Calculated total padding required.
Split padding evenly left and right.
Handled odd padding differences correctly.
Covered edge cases like:
- Empty string
- Width equal to string length
- Width smaller than string length

Key Logic

my $pad_total = $width - $len;
my $left_pad = int($pad_total / 2);
my $right_pad = $pad_total - $left_pad;

This ensures perfect centering even when padding is odd.

What I Learned

Importance of integer division in layout formatting
Handling edge cases makes logic robust
Writing test cases increases confidence immediately

Challenge 2: Word Sorter (Alphabetical Word Sorting)

Problem Statement
Write a script to order words in the given sentence alphabetically but keeps the words themselves unchanged.

Example
Input:

"I have 2 apples and 3 bananas!"

Output:

2 3 and apples bananas! have I

Implementation Highlights

Split words using whitespace regex
Used Perl’s built-in sort
Rejoined words with single spaces
Managed multiple spaces correctly

Core Logic

my @words = split /\s+/, $str;
return join ' ', sort @words;

Simple. Elegant. Effective.

What I Learned

Perl’s sort is powerful and concise
Regex-based splitting handles messy input cleanly
Even small scripts benefit from structured testing

Perl Weekly Challenge - 358: When Strings Become Numbers and Letters Start Shifting

vinodk89 — Sun, 01 Feb 2026 12:58:09 +0000

One of the things I enjoy about the Weekly Perl Challenge (WPC) is how small problems often hide neat programming ideas.
This week, I solved two challenges that look simple at first glance but beautifully showcase Perl’s strengths in:

String handling
Regex usage
Numeric/string duality
ASCII manipulation
Writing clean, testable code

Let’s walk through both problems and the approach I used.

Challenge 1 — When Strings Become Numbers

Problem
You are given a list of strings. For each string:

If it contains only digits, treat it as a number
Otherwise, treat its length as its value From these values, return the maximum.

Example

Strings	Interpreted as	Maximum
`"123", "45", "6"`	123, 45, 6	123
`"abc", "de", "fghi"`	3, 2, 4	4
`"0012", "99", "a1b2c"`	12, 99, 5	99

Key Observation
The heart of the problem is deciding:

“Is this string purely numeric, or not?”
Perl makes this very easy with a simple regex.

Solution

use List::Util qw(max);

sub get_value {
    my $str = shift;

    return length($str) unless $str =~ /^\d+$/;
    return 0 + $str;
}

A tiny function does all the work:

^\d+$ → checks if the string is fully numeric
length($str) → used when it’s not
0 + $str → converts "0012" into number 12 Then finding the maximum is trivial with map and max:

my $max = max(map { get_value($_) } @strings);

This is where Perl shines — very little code, very clear intent.

Challenge 2 — Caesar Cipher (Letter Shifting)

Problem
Implement a Caesar Cipher:

Shift every lowercase letter by N
Wrap around from z to a
Leave other characters unchanged

Input	Shift	Output
`"abc"`	1	`"bcd"`
`"xyz"`	2	`"zab"`
`"hello"`	5	`"mjqqt"`
`"perl"`	26	`"perl"`

Key Observation
This problem is a perfect use case for ASCII arithmetic.
Instead of thinking in terms of alphabets, think in numbers from 0 to 25.

sub caesar_encrypt {
    my ($str, $int) = @_;
    $int %= 26;

    my $result = '';
    for my $char (split //, $str) {
        if ($char =~ /[a-z]/) {
            $result .= chr(
                (ord($char) - ord('a') + $int) % 26 + ord('a')
            );
        } else {
            $result .= $char;
        }
    }
    return $result;
}

This one line does the magic:

chr((ord($char) - ord('a') + $int) % 26 + ord('a'))

Steps:

Convert letter → ASCII (ord)
Normalize to 0–25 range
Add the shift
Use modulo to wrap around
Convert back to character (chr)
No lookup tables. No special cases. Just math.

Testing the Solutions
For both challenges, I wrote small test cases and printed PASS/FAIL results.
This is a habit I’ve picked up from solving WPC regularly — even small scripts deserve tests.

Why I Loved These Challenges
These problems highlight why Perl is still a joy for problem solving:

Regex makes validation trivial
Numeric and string contexts work naturally
Character manipulation is straightforward
Functional tools like map make code concise
Very expressive in very few lines

Final Thoughts
At first glance, these look like beginner problems.
But they actually touch on important concepts:

Data interpretation
Input validation
ASCII math
Writing minimal, readable logic And Perl handles all of this elegantly.

That’s what makes the Weekly Perl Challenge so enjoyable — small puzzles, big learning.

Perl Weekly Challenge: 357 - Kaprekar Steps & Ordered Fractions (Perl)

vinodk89 — Sun, 25 Jan 2026 17:01:54 +0000

This week’s Perl Weekly Challenge had two very interesting problems that look simple at first, but hide some beautiful logic underneath.

I solved both tasks in Perl, and here’s a walkthrough of my approach and what I learned.

Task 1 — Kaprekar Steps

We are given a 4-digit number and asked to repeatedly perform the following process:

Arrange digits in descending order → form number A
Arrange digits in ascending order → form number B
Compute: A - B
Repeat with the result

This process is known as Kaprekar’s routine for 4-digit numbers.

A fascinating fact:

Every valid 4-digit number (with at least two different digits) will reach 6174 in at most 7 steps.

6174 is called Kaprekar’s Constant.

My Approach:

The key requirements:

Handle leading zeros (e.g., 1001 → "1001")
Keep track of numbers already seen (to avoid infinite loops)
Count the number of steps until 6174 is reached I used:
sprintf("%04d", $n) to preserve leading zeros
A hash %seen to detect loops
Sorting digits to build ascending and descending numbers

Core Logic

my $s = sprintf("%04d", $n);
my @digits = split('', $s);
my @desc = sort { $b cmp $a } @digits;
my @asc  = sort { $a cmp $b } @digits;

my $desc_num = join('', @desc);
my $asc_num  = join('', @asc);

$n = $desc_num - $asc_num;

Showing Each Iteration
I also added a helper function to print each iteration like:

3524 → 5432 - 2345 = 3087
3087 → 8730 - 0378 = 8352
8352 → 8532 - 2358 = 6174

This makes the program educational rather than just returning a number.

Task 2 — Ordered Unique Fractions**

Given a number N, generate all fractions:
num / den where 1 ≤ num ≤ N and 1 ≤ den ≤ N
Then:

Sort them by their numeric value
Remove duplicate values
Keep the fraction with the smallest numerator for equal values

My Approach
Step 1: Generate all possible fractions

for my $num (1..$n) {
    for my $den (1..$n) {
        push @fractions, [$num, $den];
    }
}

Step 2: Sort by fraction value

@fractions = sort {
    my $val_a = $a->[0] / $a->[1];
    my $val_b = $b->[0] / $b->[1];
    $val_a <=> $val_b || $a->[0] <=> $b->[0]
} @fractions;

Step 3: Remove duplicates intelligently
Instead of reducing fractions (like 2/4 → 1/2), I tracked numeric values and kept the fraction with the smallest numerator.

if (!exists $seen_values{$value} || $num < $seen_values{$value}) {
    $seen_values{$value} = $num;
    push @unique, [$num, $den];
}

Example Output (N = 4)

1/4, 1/3, 1/2, 2/3, 3/4, 1/1, 4/3, 3/2, 2/1, 3/1, 4/1

Notice:

Fractions are ordered by value
Duplicates like 2/2, 3/3, 4/4 don’t appear
2/4 is replaced by 1/2 because it has a smaller numerator

What I Learned This Week

From Kaprekar problem

Importance of preserving leading zeros
Detecting infinite loops with a hash
How a simple number routine hides deep mathematical beauty

From Fraction problem

Sorting by computed values
Eliminating duplicates without using GCD
Writing clean data-structure driven Perl code using array references

Conclusion

Both tasks looked straightforward, but required careful thinking about:

Edge cases
Ordering
Data handling

Perl made these tasks elegant to implement thanks to:

Powerful sorting
Flexible data structures
String formatting utilities

Another fun and educational week with Perl Weekly Challenge!

Happy hacking :)

Perl Weekly Challenge: 345

vinodk89 — Sat, 01 Nov 2025 12:40:10 +0000

Both challenges provided this week (Challenge-345) an excellent opportunity to practice array manipulation and dynamic state tracking in Perl, using simple constructs like for loops, unshift, and effective boundary/state checks.

Challenge 1: Peak Positions

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 neighbours. Return the indices of all such peak positions.

Example:

Input: @ints = (1, 3, 2)
Output: (1)

My Solution:
The core challenge is handling the boundary conditions—the first and last elements—which only have one neighbor.
My strategy was to process the array from index 0 to N-1 and define the "neighbors" for any given element $ints[i] as follows:

Left Neighbor ($left):
- If $i is 0 (the first element), the left neighbor is non-existent. To ensure the condition $ints[i] > $left is always true, I set $left = -1.
- Otherwise, $left = $ints[$i-1].
Right Neighbor ($right):
- If $i is N-1 (the last element), the right neighbor is non-existent. Again, I set $right = -1.
- Otherwise, $right = $ints[$i+1].

The final check is simply: $ints[$i] > $left && $ints[$i] > $right.

The solution uses a clean for loop to iterate over the indices and the Perl range operator 0..$#ints for concise code.

sub find_peaks {
    my @ints = @_;
    my @peaks;

    # Iterate through all indices
    for my $i (0..$#ints) {
        # Define the left neighbor, using -1 for the first element
        my $left  = ($i == 0 ) ? -1 : $ints[$i-1];

        # Define the right neighbor, using -1 for the last element
        my $right = ($i == $#ints) ? -1 : $ints[$i+1];

        # A peak is strictly greater than both its effective neighbors
        if ($ints[$i] > $left && $ints[$i] > $right) {
            push @peaks, $i;
        }
    }
    return @peaks;
}

# Example: [2, 4, 6, 5, 3] -> Peak is 6 at index 2
# Output: (2)

Challenge 2: Last Visitor

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 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 Logic and State Management:

This problem is all about maintaining and querying state.

State Management with @seen: The requirement "newest at the front" is key. When a positive number comes in, we use unshift to put it at the start of @seen. This makes it behave like a stack, but with array-based indexing (index 0 is newest, index 1 is next newest, and so on).
The -1 Rule: When we hit a -1, we must look backward to count the consecutive -1s ($x).
- I used a small while loop within the main loop to handle this lookback, starting from the element immediately before the current index $i-1. The loop increments $x as long as it finds -1s.
- Once we have $x, we check if it's a valid index: $x < @seen.
  - If it is, we retrieve the x-th newest element: $seen[x].
  - If it's not (meaning we haven't seen enough positive numbers to satisfy the lookup), we append -1.

The use of unshift and direct array indexing in Perl makes the solution quite easy.

sub process_ints {
    my @ints = @_;
    my @seen;  # Newest seen numbers are at the front (index 0)
    my @ans;

    for (my $i = 0; $i < @ints; $i++) {
        if ($ints[$i] == -1) {
            # 1. Calculate x: count of consecutive -1s before this one
            my $x = 0;
            my $j = $i - 1;
            while ($j >= 0 && $ints[$j] == -1) {
                $x++;
                $j--;
            }

            # 2. Apply the lookup rule
            if ($x < @seen) {
                # $seen[0] is the newest (x=0)
                # $seen[1] is the next newest (x=1), etc.
                push @ans, $seen[$x]; 
            } else {
                push @ans, -1;
            }
        } else {
            # If positive number, insert at the front (newest)
            unshift @seen, $ints[$i];
        }
    }
    return @ans;
}

# Example: [2, -1, 4, -1, -1] 
# i=0: 2 -> @seen=(2)
# i=1: -1, x=0. x < @seen (0 < 1). @ans=(2).
# i=2: 4 -> @seen=(4, 2)
# i=3: -1, x=0. x < @seen (0 < 2). @ans=(2, 4).
# i=4: -1, x=1. x < @seen (1 < 2). @ans=(2, 4, 2).
# Output: (2, 4, 2)

Perl Weekly Challenge: 344

vinodk89 — Sat, 25 Oct 2025 13:08:05 +0000

Writing a blog for first time and this week's challenges provided a fantastic opportunity to explore different problem-solving strategies in Perl. I tried to solve one of the problem in Raku aswell :)

Challenge 1: Add to Array Form

The Problem
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:
In Perl, when we use a list of digits in a string context, they are automatically concatenated. This allows us to convert the array-form number into a standard integer, perform the addition, and then convert the sum back into its array form in three concise steps.

Here is the add_to_array_form subroutine:

sub add_to_array_form {
    my ($ints_ref, $x) = @_;

    # 1. Convert the array of digits into a single string/number.
    my $int_form = join('', @$ints_ref);

    # 2. Perform the arithmetic. Perl handles the large number arithmetic here.
    my $sum = $int_form + $x;

    # 3. Split the resulting sum back into an array of individual digits.
    my @result_array = split //, $sum;

    return @result_array;
}

This solution is highly efficient and perfectly illustrates Perl's strength in handling scalar contexts and type coercion.

Example

vinod@vinod:~/my_folder/git/perlweeklychallenge-club/challenge-344/vinod-k/perl$ perl ch-1.pl 

Input Array: (1, 2, 3, 4)
Input X: 12
Output Array: (1, 2, 4, 6)

Input Array: (2, 7, 4)
Input X: 181
Output Array: (4, 5, 5)

Input Array: (9, 9, 9)
Input X: 1
Output Array: (1, 0, 0, 0)

Input Array: (1, 0, 0, 0, 0)
Input X: 9999
Output Array: (1, 9, 9, 9, 9)

Input Array: (0)
Input X: 1000
Output Array: (1, 0, 0, 0)

Challenge 2: Build Target from Source Subarrays

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:
They way used to solve this is - to convert the array sequences into strings and use the power of Perl's regular expression engine to perform prefix matching and consumption.

Convert the $target array into a string (e.g., "1234").
In a loop, iterate through all unused source subarrays.
For each source subarray, check if it matches the current beginning of the target string.
If a match is found, use the substitution operator (s///) to remove the matched prefix from the target string, mark the source subarray as used, and continue to the next iteration.

This logic is in the can_build_target subroutine:

sub can_build_target {
    my ($source_ref, $target_ref) = @_;
    my $target_string = join('', @$target_ref);

    my $source_count = scalar @$source_ref;
    my %used_source_indices = ();
    my @used_order = ();

    while (length $target_string) {
        my $match_found_in_cycle = 0;

        for my $i (0 .. $source_count - 1) {
            next if exists $used_source_indices{$i};

            my $sub_array_ref = $source_ref->[$i];
            my $source_pattern = join('', @$sub_array_ref);

            # The core of the greedy match:
            # s/ ... / / checks for a match AND removes it if successful.
            # ^: Anchors the match to the start of the string.
            # \Q...\E: Quotes the pattern so it's treated literally (no regex metacharacters).
            if ($target_string =~ s/^\Q$source_pattern\E//) {
                $used_source_indices{$i} = 1;
                push @used_order, $sub_array_ref;
                $match_found_in_cycle = 1;
                last; # Move to the next prefix
            }
        }

        # If we couldn't match any source subarray, we fail.
        unless ($match_found_in_cycle) {
            return (0, []);
        }
    }
    return (1, \@used_order);
}

Example

inod@vinod:~/my_folder/git/perlweeklychallenge-club/challenge-344/vinod-k/perl$ perl ch-2.pl 
Input: @source = ([2,3], [1], [4])
Input: @target = (1, 2, 3, 4)
Output: true
Use in the order: ([1], [2,3], [4])

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

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

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

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