Perl Weekly Challenge 133: in a rush

One way to let me improve my knowledge about Raku (aka Perl 6) is to implement programs in it. Unluckily, I don’t have any production code to implement in Raku yet (sob!). So, why not try solving the Perl Weekly Challenge tasks?

In the following, the assigned tasks for Challenge 110.

• Task 1
• Task 2

PWC 133 - Task 1

The first task was about implementing a way to compute the square root of an integer without using any pre-made function, nor library. I just re-implemented in Raku the alghoritm you can find around to get an approximation of the sqrt:

sub MAIN( Int $n where { $n > 0 } ) {
    $n.say and exit if $n == 1;

    my Int $current-solution = $n +> 1;  # divide by two
    my Int $next-solution    = 0;
    while ( $next-solution < $current-solution ) {
        $next-solution    = ( $current-solution + $n / $current-solution ) +> 1 if ! $next-solution;
        ( $current-solution, $next-solution ) = $next-solution,
                                                ( $next-solution + $n / $next-solution ) +> 1;
        
    }

    $current-solution.say;

}

PWC 133 - Task 2

The second task was about computing the first ten Smith numbers, numbers where the sum of the factors is the same as the sum of its digits.
The code looks like:

# a lazy list of all prime numbers
my @PRIMES = grep {.is-prime}, 1..*;

# divide a number into a list of its own factors
multi do-factor( 1 ) { (1) }
multi do-factor( Int $n where { $n > 1 } ) {
    my $needle = $n;
    my @factors;

    for @PRIMES -> $current-factor {
        # stop if we got a bigger number
        last if $current-factor > $needle;

        # skip if the number is not a divisor of what we are searching for
        next unless $needle %% $current-factor;

        # if here, it is a good factor
        @factors.push: $current-factor;

        # compute the remainder
        $needle /= $current-factor;
    }

    
    @factors.sort;
    

}


# It is a smith number if the sum of the digits
# is the sum of the factors
sub is-smith-number( Int $n where { $n > 0 } ) {
    return $n.comb.sum == do-factor( $n ).sum;
}


sub MAIN( Int $limit where { $limit > 0 } = 10 ) {

    my @smith-numbers;
    for 1 .. Inf {
        next if ! is-smith-number( $_ );
        @smith-numbers.push: $_;
        last if @smith-numbers.elems == $limit;
    }

    @smith-numbers.join( "\n" ).say;
}

I did not implemented a lazy approach here, rather I do iterate until I’ve found 10 numbers. The is-smith-number is the method that checks if a number is good or not, and it does rely on the multi method do-factors that returns a list of numbers (factors) for the given input integer.
The do-factors method in turn exploits a pre-made list of prime numbers, and iterates to find out all the prime numbers that can be used to made up a given input.