Perl Weekly Challenge 357

Task 1: Kaprekar Constant

"The Mystery of 6174: Number Magic Revealed!"

Given a 4-digit integer, find how many iterations are needed to reach Kaprekar's constant (6174) by sorting digits in descending and ascending order and subtracting.

The Strategy: Keep track of seen numbers to detect loops. Sort digits descending and ascending, pad with zeros, subtract, and count iterations until reaching 6174.

Perl Implementation

sub kaprekar_iterations ($n) {
    die 'Expected integer in range 0..9999' if $n !~ /^\d+$/ || $n > 9999;
    my %seen;
    my $steps = 0;
    while ( $n != 6174 ) {
        return -1 if $seen{$n}++;
        my $s = sprintf '%04d', $n;
        my @d = split //, $s;
        my $asc  = join '', sort { $a <=> $b } @d;
        my $desc = join '', sort { $b <=> $a } @d;
        $n = ( 0 + $desc ) - ( 0 + $asc );
        ++$steps;
    }
    return $steps;
}

Python Implementation

def kaprekar_iterations(value: int) -> int:
    """Return iterations needed to reach 6174 (or -1 if it never converges)."""
    if value < 0 or value > 9999:
        raise ValueError("value must be in range 0..9999")

    seen = set()
    steps = 0

    while value != 6174:
        if value in seen:
            return -1
        seen.add(value)

        digits = f"{value:04d}"
        asc = int("".join(sorted(digits)))
        desc = int("".join(sorted(digits, reverse=True)))
        value = desc - asc
        steps += 1

    return steps

Task 2: Unique Fraction Generator

"Fraction Party: When Numbers Get Unique!"

Generate all unique fractions from 1 to N, sorted in ascending order, showing only the simplest form of each fraction.

The Strategy: Generate all numerator/denominator pairs, convert to fractions using gcd for reduction, sort by value, and output unique fractions.

Perl Implementation

sub unique_fractions {
    my ($n) = @_;
    my @fractions;
    for my $num (1..$n) {
        for my $denom (1..$n) {
            push @fractions, [$num, $denom];
        }
    }
    # Reduce fractions and sort...
}

Python Implementation

def unique_fractions(n: int) -> list[tuple[int, int]]:
    """Generate unique fractions from 1 to N, sorted."""
    from math import gcd
    
    fractions = set()
    for num in range(1, n + 1):
        for denom in range(1, n + 1):
            g = gcd(num, denom)
            fractions.add((num // g, denom // g))
    
    return sorted(fractions, key=lambda f: f[0] / f[1])