Perl Weekly Challenge 122: mangling numbers

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 122.

• Task 1
• Task 2

PWC 122 - Task 1

The first task was about computing the average of a stream of numbers. Since it is not clear to me if the word stream here means a continuos input from the user, I provided two different MAINs: one that gets an array of numbers, and one that reads from STDIN.
The application is as follows:

multi sub MAIN( *@N where { @N.elems == @N.grep( * ~~ Int ).elems }) {
    my @average;
    @average.push: (@N[ 0 .. @average.elems - 1 ].sum + $_) / ( @average.elems + 1 ) for @N;


    @average.say;
}


multi sub MAIN() {
    "Insert a number at time".say;

    my @average;
    my $sum = 0;
    for lines() {
        "Not a number".say && next if $_ !~~ / \d+ /;
        $sum += $_;
        @average.push: $sum / ( @average.elems + 1 );
        "Average trend so far: { @average.say }";

    }
}

The streaming MAIN (the second one) is a little boring: it accumulates the sum of provided numbers into a $sum variable, and pushes the computed average into an @average array. I don’t keep track of how many numbers have been provided, since @average contains that information too. Also, I do test for good numbers before computing any value.
The first MAIN does pretty much the same, but the @average array is populated within a for loop that scans every input number, and the average value is made by summing the current value with the slice of previous values on the input @N array.

PWC 122 - Task 2

The second task was about finding out all possible sequences of available baseball scores that provide a final score specified as input.
I decided to let Raku do a lot of computations, producing all available permutations of numbers and throwing away those that do not provide the right final score. I could not come up with a simpler solution, from the point of view of code, than this, but clearly it is strongly de-optimized!

sub MAIN( Int $S ) {
    my @available-points = 1, 2, 3;
    my $begin = ( @available-points[ 0 ] x $S ).Int;
    my $end   = ( @available-points[ * - 1 ] x $S ).Int;
    my @scores;


        for ( $begin .. $end ) {
            my @digits = $_.split( '', :skip-empty ).grep( * == any( @available-points ) );
            next if ! @digits.grep: $_ for @available-points;
            next if @digits.sum != $S;
            my $score =  @digits.grep( * == any( @available-points ) ).join;;
            @scores.push: $score if ( ! @scores.grep( $score ) );

        }


    @scores.join( "\n" ).say;
}

The idea is that, assuming the final score $S as 4, I got all values between 1111 and 3333. After that I check if the number, split into its @digits can give me a sum up to $S, and in the case I place it into the @scores array, after trimming out all zeros. If the number includes digits that are not within the @available-points or if the sum of those digits is not the one I’m looki9ng for, I discard the number.
Trimming out the 0 from a number means that the @scores array is going to include duplicates (e.g., 1002 and 1200 will both result in 12), so at the end I apply unique to get a single value out of all duplicates.