# Perl Weekly Challenge 109: Choowa Numbers and Sums

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

## Eyes

Last monday I got my**second sub-cataract laser treatment**against my severally damaged left eyes.

There is little hope for such an eye, that so far is going to see less than

`1/10`

.
But a little more light is better than less, right?

## PWC 109 - Task 1

The first task was about producing*Choowa*numbers, that are in short the summatory of all divisors for a specific order.

I decided to implement a

`choowa`

function that accepts the `$n`

order and computes all the *divisors*of

`$n`

: that is quite simple since it means searching for any number that provides no reminder on a division. I corced them and used the `[+]`

reduction operator to return the sum of those numbers. Please note that there is the special case where `$n`

is `1`

or `0`

, and in such case *Choowa*says the divisors should not be took into account.

In the

`MAIN`

I iterate on the order up to `$limit`

and invoke the function, than coerce the result into an array and print it. Therefore, the whole program is:
```
sub choowla( Int $n where { $n > 0 } ) {
return 0 if $n < 2;
return [+] ( $_ if $n %% $_ for 2 .. $n / 2 );
}
sub MAIN( Int $limit = 20 ) {
@( choowla( $_ ) for 1 .. $limit ).join( ',' ).say;
}
```

## PWC 109 - Task 2

The second task was about finding out a number scheme in which different sums provide the same result.In particular, given numbers called from

`a`

to `g`

, the following sums must have the equal values:
`a`

+`b`

;`b`

+`c`

+`d`

;`d`

+`e`

+`f`

;`f`

+`g`

.

I decided to implement an hash named`%squares`

that contain every letter as a key and the value assigned to the letter as the number to sum. Then, I push all the sums into an array named`@sums`

, and this can be done with the`[+]`

reduction operator and the slicing of the hash itself.

Therefore`[+] %squares{ 'b' .. 'd' };`

is the sum of`b`

+`c`

+`d`

.

Last, I check if the first sum in the array`@sums`

is equal to**all**the remaining sums in the array, and this is done with the`all`

special keyword for junctions and the array slicing.

If the sum condition is met, I push the current`%squares`

configuration hash to a`@solutions`

array, so that I can print it at the end of the script.

The script therefore is:

```
multi sub MAIN( *@nums where { @nums.grep( * ~~ Int ).elems == @nums.elems && @nums.elems == 7 } ) {
my @letters = 'a' .. 'g';
my @solutions;
# permutate all numbers to find out the correct sum
for @nums.permutations -> @current {
# build an hash to help visualize the answer
my %squares;
%squares{ @letters[ $_ ] } = @current[ $_ ] for 0 ..^ @letters.elems;
# compute the sums
my @sums;
@sums.push: [+] %squares{ 'a' .. 'b' };
@sums.push: [+] %squares{ 'b' .. 'd' };
@sums.push: [+] %squares{ 'd' .. 'f' };
@sums.push: [+] %squares{ 'f' .. 'g' };
# if the first sum is equal to all the others, push this solution
@solutions.push: %squares if @sums[ 0 ] == all @sums[ 1 .. * ];
}
say $_ for @solutions;
}
multi sub MAIN() {
MAIN( <1 2 3 4 5 6 7> );
}
```

Note the usage of a

`multi MAIN`

to allow the user to run the script without having to specify any value.