Raku Solutions Weekly Review
Task #1: Christmas on Sunday
This is derived in part from my blog post made in answer to the Week 30 of the Perl Weekly Challenge organized by Mohammad S. Anwar as well as answers made by others to the same challenge.
The challenge reads as follows:
Write a script to list dates for Sunday Christmas between 2019 and 2100. For example, 25 Dec 2022 is Sunday.
My Solutions
In Perl 6/Raku, the Date
data type offers the builtin methods we need for date computations, including finding day of week.
use v6;
for 2019..2100 > $year {
say "Christmas of year $year falls on a Sunday."
if Date.new($year, 12, 25).dayofweek == 7;
}
which duly prints out:
Christmas of year 2022 falls on a Sunday.
Christmas of year 2033 falls on a Sunday.
Christmas of year 2039 falls on a Sunday.
Christmas of year 2044 falls on a Sunday.
Christmas of year 2050 falls on a Sunday.
Christmas of year 2061 falls on a Sunday.
Christmas of year 2067 falls on a Sunday.
Christmas of year 2072 falls on a Sunday.
Christmas of year 2078 falls on a Sunday.
Christmas of year 2089 falls on a Sunday.
Christmas of year 2095 falls on a Sunday.
We could also do it in the form of a Perl 6 oneliner:
$ perl6 e 'say grep {Date.new($_, 12, 25).dayofweek == 7}, 2019..2100;'
(2022 2033 2039 2044 2050 2061 2067 2072 2078 2089 2095)
Alternative Solutions
I did not keep track of the number of contributions for past challenges, but it seems to me that, with 15 solutions, this might be the most successful challenge so far in Perl 6. This may have to do with the fact that the core Perl 6 has all builtin methods to easily solve the task.
Arne Sommer suggested a solution quite similar to mine:
unit sub MAIN (UInt :$from = 2019, UInt :$to = 2100);
for $from ... $to > $year
{
say "25 Dec $year is Sunday." if Date.new($year, 12, 25).dayofweek == 7;
}
Kevin Colyer took essentially the same approach as my oneliner above, but using the ==>
forward feed operator to chain the statements:
2019..2100 ==> map { Date.new($_,12,25) } ==> grep { $_.dayofweek==7} ==> map { say $_.yyyymmdd };
Mark Senn also used essentially the same idea:
for (2019..2100) > $year {
(Date.new(day =>25, month=>12, year=>$year).dayofweek == 7)
and say "25 Dec $year";
}
Noud worked along the same lines:
for 2019 .. 2100 > $year {
if (Date.new($year, 12, 25).dayofweek == 7) {
$year.say;
}
}
Simon Proctor‘s program is similar to most others seen so far:
.say for (2019..2100).map( { Date.new( :year($_), :day(25), :month(12) ) } ).grep( *.dayofweek == 7 );
Athanasius made, as often, a relatively long fullfledged program, but using the same Date
methods as other challengers:
my UInt constant $STARTYEAR = 2019;
my UInt constant $ENDYEAR = 2100;
my UInt constant $DECEMBER = 12;
my UInt constant $CHRISTMASDAY = 25;
my UInt constant $SUNDAY = 7;
my Str constant $FORMAT = 'Between %d and %d (inclusive), Christmas ' ~
"Day (%dth December) falls on a\nSunday " ~
"in %s, and %s\n";
sub MAIN()
{
my UInt @years;
for $STARTYEAR .. $ENDYEAR > UInt $year
{
my Date $date = Date.new($year, $DECEMBER, $CHRISTMASDAY);
@years.push: $year if $date.dayofweek == $SUNDAY;
}
my UInt $finalyear = @years.pop;
$FORMAT.printf:
$STARTYEAR, $ENDYEAR, $CHRISTMASDAY, @years.join(', '), $finalyear;
}
Daniel Mita planned some extra features, but, when removing them, the gist of his implementation is essentially along the same lines as most others:
for 2019 .. 2100 > $year {
given Date.new( :$year, :12month, :25day ) {
if .dayofweek == 7 { .say }
}
}
Jaldhar H. Vyas suggested the following oneliner:
perl6 e '"$_1225".say for (2019..2100).grep({Date.new($_,12,25).dayofweek==0;});'
which was apparently influenced by his Perl 5 implementation and doesn’t work properly because it compares the return value of the .dayofweek
method to 0, whereas it should be compared to 7. I guess it’s simply a typo. Making that small change fixes the issue and enables the oneliner to work properly:
$ ./perl6 e '"$_1225".say for (2019..2100).grep({Date.new($_,12,25).dayofweek==7;});'
20221225
20331225
(... lines omitted for brevity)
20891225
20951225
Joelle Maslak also used the same general idea:
sub MAIN(:$start = 2019, :$end = 2100) {
my $christmasses = ($start..$end).map({ DateTime.new(:25day, :12month, :year($_)) });
my $onsunday = $christmasses.grep: *.dayofweek == 7;
say $onsunday».yyyymmdd.join("\n");
}
Markus Holzer also used the same feature as others, with just a different syntax:
constant \SUNDAY = 7;
.say for
( 2019 .. 2100 )
.map( { DateTime.new( :$^year, month => 12, day => 25 ) })
.grep( { .dayofweek == SUNDAY })
.map( { .year })
;
Roger Bell West made a oneline version of the same:
map {say "$_"}, grep {Date.new($_,12,25).dayofweek==7}, (2019..2100);
Ruben Westerberg made yet another version of essentially the same:
(2020..2099).map({
my $t=Date.new(year=>$_,month=>12,day=>25);
$t.dayofweek==7??$t!!();
})>>.put;
Ulrich Rieke also used the same basic technique:
my @dates ;
for (2019..2100) > $year {
my $d = Date.new( $year , 12 , 25 ) ;
if ( $d.dayofweek == 7 ) {
@dates.push( $d ) ;
}
}
@dates.map( { say ~$_ } ) ;
Yet Ebreo used essentially the same technique as most others:
for 2019..2100 > $year {
my $date = Date.new($year, 12, 25);
if ($date.dayofweek == 7) {
say "12/25/$year"
}
}
Task #2: Integer Triplets Whose Sum is 12
This is derived in part from my blog post made in answer to the Week 30 of the Perl Weekly Challenge organized by Mohammad S. Anwar as well as answers made by others to the same challenge.
The challenge reads as follows:
Write a script to print all possible series of 3 numbers, where in each series at least one of the number is even and sum of the three numbers is always 12. For example, 3,4,5.
This is not specified, but we will consider that all three numbers should be strictly positive (i.e. larger than or equal to 1), because if we were to admit 0 as one of the numbers, it would no longer be a real triplet (in the context of addition). A consequence is that the largest number that can be used is 10 (to obtain 12 when adding twice 1).
I started with a Perl 5 implementation and quickly found out that my initial version was doing a bit too much work when checking whether one of the numbers is even. The only case where none of the numbers of a triplet is even is when all three numbers are odd, and the sum of three odd integers cannot be 12 (and, more generally, cannot be an even number). So, we simply don’t need to check that one number is even: checking that the sum of the 3 numbers if 12 is sufficient to prove that one at least of the three numbers is even.
My Solution
We could write three nested for
loops as we did for the same challenge in Perl 5. But, for solving this problem in Perl 6/Raku, we would prefer to use the X
cross product operator in order to generate all possible triplets and then keep those whose sum is 12.
But if we do something like this:
for 1..10 X 1..10 X 1..10 > $triplet {
next unless ([+]  $triplet) == 12;
say $triplet;
}
we obtain duplicate triplets:
...
(1 2 9)
...
(2 1 9)
...
(2 9 1)
...
(9 1 2)
(9 2 1)
...
We can get rid of this problem by keeping only triplets in which the numbers are in (non strict) ascending order:
use v6;
for 1..10 X 1..10 X 1..10 > $triplet {
next unless [<=]  $triplet; # ascending order
say $triplet if 12 == [+] $triplet;
}
which produces the desired result:
$ perl6 triplets.p6
(1 1 10)
(1 2 9)
(1 3 8)
(1 4 7)
(1 5 6)
(2 2 8)
(2 3 7)
(2 4 6)
(2 5 5)
(3 3 6)
(3 4 5)
(4 4 4)
Note that the header of the for
loop could be made slightly more concise using the xx
sequence repetition operator and the [X]
cross operator associated with the reduction metaoperator:
for [X] (1..10) xx 3 > $triplet { # ...
Alternative Solutions
This week’s challenge was highly successful for Perl6/Raku solutions. The Christmas on Sunday task received 15 solutions, and this Triplets adding to 12 challenge did even better with 16 challengers responding.
Arne Sommer used the combinations method to generate triplets, filtered them on their sum (equal to 12), and then removed duplicates by storing in a hash the sorted individual triplets:
my %seen;
for (1 .. 10, 1..10, 1..10).flat.combinations(3).unique(:with(&[eqv])).grep(*.sum == 12)
{
my @sorted = $_.sort;
next if %seen{@sorted.Str};
say @sorted;
%seen{@sorted.Str} = True;
}
Kevin Colyer used three nested for
loops and a separate SumsTwelve
subroutine to check the triplets’ sums:
sub SumsTwelve(*@tri) {
return True if ( [+] @tri ) == 12; # this will always fullfil condition one of number is even as can only add to twelve is ALL even or TWO odd. sum of all odd or one odd can never an even number!
return False;
}
for 1..10 > $a {
for 1..11$a > $b {
for 1..12$b$a > $c {
say "$a,$b,$c" if SumsTwelve($a,$b,$c);
}
}
}
Note that Kevin’s interpretation of the challenge doesn’t not consider (2 1 9), (2 9 1), (1 2 9), (1 9 2), (9 2 1), and (9 1 2) to be duplicates. So he found many more triplets than Arne or me:
1,1,10
1,2,9
1,3,8
1,4,7
1,5,6
1,6,5
1,7,4
1,8,3
1,9,2
1,10,1
2,1,9
2,2,8
2,3,7
2,4,6
2,5,5
2,6,4
2,7,3
2,8,2
2,9,1
3,1,8
3,2,7
3,3,6
3,4,5
3,5,4
3,6,3
3,7,2
3,8,1
4,1,7
4,2,6
4,3,5
4,4,4
4,5,3
4,6,2
4,7,1
5,1,6
5,2,5
5,3,4
5,4,3
5,5,2
5,6,1
6,1,5
6,2,4
6,3,3
6,4,2
6,5,1
7,1,4
7,2,3
7,3,2
7,4,1
8,1,3
8,2,2
8,3,1
9,1,2
9,2,1
10,1,1
Marl Senn first suggested a Wolfram (formerly known as Mathematica) implementation which you can check by following the link. He then proposed two Perl6/Raku implementations using nested for
loops. The first one is this:
for (1..10) > $i {
for (1..10) > $j {
for (1..10) > $k {
($i + $j + $k == 12) and say "$i,$j,$k";
}
}
}
Just like Kevin, Mark doesn’t not consider (2 1 9), (2 9 1), (1 2 9), (1 9 2), (9 2 1), and (9 1 2) to be duplicates.
Mark also provided an optimized version of the same modifying the for
loops to reduce the number of unnecessary calculations:
for (1..10) > $i {
for (1..12$i1) > $j {
for (12$i$j..10) > $k {
($i + $j + $k == 12) and say "$i,$j,$k";
}
}
}
}
Noud cleverly used two nested for
loops combined with the permutations
builtin method:
my $total = 12;
my @triplets = [];
for 2, 4 ... $total > $i {
for 1 .. ($total  $i  1) > $j {
@triplets = [(@triplets), ([$i, $j, $total  $i  $j].permutations)];
}
}
# Because we use permutations we have duplicates. Ex. (10, 1, 1) with j <> k
# gives (10, 1, 1).
say @triplets.unique;
It seems to me that there is a problem in this program: the unique
method does not remove duplicates from the list, because it apparently doesn’t work as expected with sublists (probably because (1, 1, 10) === (1, 1, 10)
returns False
).
Jaldhar H. Vyas also cleverly used only two nested for
loops:
my %results;
for (1 .. 10) > $i {
for (1 .. (12  $i  1)) > $j {
my $k = 12  $i  $j;
%results{($i, $j, $k).sort.join(q{ })}++;
}
}
.say for %results.keys.sort;
Roger Bell West also used the same clever technique to have only two nested for
loops:
my $target=12;
for (0..$target) > $a {
for ($a..$target) > $b {
my $c=$target$a$b;
if ($c>=$b) {
say "$a $b $c";
}
}
}
Ruben Westerberg also managed to use only two nested for
loops, but with a slightly different approach:
my %s;
for (2,4,6,8,10) {
my $e=$_;
my $r=12$e;
for 1..$r1 {
my @val=sort($e,$_,$r$_);
%s{@val.join(",")}=@val if @val.sum ==12;
}
}
for %s.keys.sort {
put %s{$_}.join(",");
}
Ozzy adopted yet another interpretation of the challenge: for him, all three numbers of a triplet have to be different. He used the combinations
method to generate triplets of unique integers adding up to 12 (yielding (0 4 8) (0 5 7) (1 3 8) (1 4 7) (1 5 6) (2 3 7) (2 4 6) (3 4 5)
) and then applied the permutations
method on each triplet:
say "Combinations: ", my @c = (^9).combinations(3).grep: { .sum == 12 && (.first: * %% 2).defined };
say "Permutations: ", my @p = gather { my @x; for @c > $l { @x = $l.permutations; .take for @x } };
Simon Proctor had the same interpretation as Ozzy and also used the combinations
method to generate triplets of integers in strict ascending order adding up to 12:
.join(",").say for (1..9).combinations(3).grep( { [<] $_ } ).grep( { 12 == [+] $_ } ).grep( { any($_) %% 2 } );
Athanasius also went for monotonic ascending series of 3 positive numbers summing to 12. He used three nested for
loops essentially boiling down to this:
my UInt constant $SUM = 12;
for 0 .. $SUM > UInt $i
{
for $i .. $SUM > UInt $j
{
my UInt $subtotal = $i + $j;
for $j .. $SUM > UInt $k
{
if $subtotal + $k == $SUM
{
"(%d, %d, %2d)\t".printf: $i, $j, $k;
}
}
}
}
Daniel Mita considered that (2 1 9) and (2 9 1) are different triplets. His solution uses the [X]
cross operator and reduction metaoperator combination to produce the triplets and then prints those whose sum is 12:
for [X] ( 1..10 ) xx 3 {
.fmt('%2u', '').say when .sum == 12;
}
Joelle Maslak used chained methods in a data pipeline to solve the problem:
cross((1..9) xx 3)\ # Create a list where each element is a list of
# 3 numbers inclusively between 1 and 9.
».Set # Turn those elements into sets
.grep( *.elems == 3 ) # Sets flatten duplicates, so we want to be sure
# there are still 3 elements in the set.
.unique # We will have duplicate sets, remove the dupes
.map( *.keys.list ) # Turn the list back into a list
.grep( *.sum == 12 ) # Do the set members add to 12?
.map( *.sort ) # Sort the numbers in each set
.map( *.join(",") ) # Make the sets into commadeliminated strings
.sort # Sort the sets of numbers
.join("\n") # Build a string, seperating sets by newlines
.say
Markus Holzer wrote his own combinations
recursive subroutine generating all possible permutations of two integers in the range 1 to 10. He then used it together with the X
cross operator to generate the triplets:
.say for
( ( 2, 4 ... 10 ) X combinations( 1 .. 10, 2 ) )
.map( { .flat.cache })
.grep( { .sum == 12 })
.map( { .join(", ") })
;
sub combinations( @combinatees, $places) { combinations( @combinatees, $places  1 ) X @combinatees if $places > 0 }
I’m not sure Markus’s program is correct, though. As an example of the possible issue, it displays both (2, 1, 9) and (2, 9, 1), so Markus presumably considers that these triplets are not duplicates, one of which having to be removed. But, if we take this interpretation, then I would expect to also get (9, 1, 2) and (9, 2, 1), but these two triplets are not in the output of his program.
Ulrich Rieke use three nested for
loops to generate the triplets:
my @triples ;
for (1..10) > $a {
for (1..10) > $b {
for (1..10) > $c {
my @treble.push($a , $b , $c ) ;
@treble .= sort ;
@triples.push( @treble ) if ( (([+] @treble) == 12) &&
(@treble.grep( { $_ %% 2 } ).elems > 0) ) ;
}
}
}
say @triples.unique(:with(&[eqv])) ;
Yet Ebreo wrote a very concise oneliner solution:
$_.sum == 12 && .say for [X] (0 .. 12) xx 3;
SEE ALSO
Only three blog posts this time (in addition to mine):

Arne Sommer: https://perl6.eu/xmas12.html;

Roger Bell West: https://blog.firedrake.org/archive/2019/10/Perl_Weekly_Challenge_30.html;

Jaldhar H. Vyas: https://www.braincells.com/perl/2019/10/perl_weekly_challenge_week_30.html.
Wrapping up
Please let me know if I forgot any of the challengers or if you think my explanation of your code misses something important (send me an email or just raise an issue against this GitHub page).