This week’s challenge brought two new tasks: Friday the 13th & Roman Maths.
Task 1: Friday 13th
You are given a year number in the range 1753 to 9999.
Write a script to find out how many dates in the year are Friday 13th, assume that the current Gregorian calendar applies.
Example
Input: $year = 2023
Output: 2
Since there are only 2 Friday 13th in the given year 2023 i.e. 13th Jan and 13th Oct.
This was going to be easy, because I knew there were date manipulation modules in the core distribution: Time::Piece and Time::Seconds. I figured I wanted to start at the first of the year, add one day in a loop until I found the first Friday, and then skip from one Friday to the next by adding seven days, using the wday property of a Time::Piece object to check whether or not the date was the 13th. Yes, instantiating the first day of the year would have been easier using the DateTime module, but I wanted to use only core modules if they did what I needed (and, really how much more complex is Time::Piece->strptime("$year-01-01", "%Y-%m-%d")->truncate(to => 'day'); versus DateTime->new(year => $year, month => 1, day => 1)->truncate(to => 'day');).
#!/usr/bin/env perl
use v5.38;
# let's use the core modules for date manipulation
use Time::Piece;
use Time::Seconds qw( ONE_DAY );
# get the year from the command line
my $year = shift @ARGV
or die "usage: $0 year\n";
# do bounds checking as specified in the problem
if ($year < 1753 || $year > 9999) {
die "Only years between 1753 to 9999 are allowed ($year is out of range)\n";
}
# create an object for Jan 01 of the given year
my $t = Time::Piece->strptime("$year-01-01", "%Y-%m-%d")
->truncate(to => 'day');
# find the first friday
# in Time::Piece->wday, 1 = Sunday, 6 = Friday
while ( $t->wday != 6) {
$t += ONE_DAY; # add 1 day
}
# now keep adding 7 days to the date until the year changes,
# noting how many times the day of the month is 13
my $thirteen_count = 0;
while ( $t->year == $year ) {
$thirteen_count++ if $t->mday == 13;
$t += ONE_DAY * 7;
}
say "Input: \$year = $year";
say "Output: $thirteen_count";
Doing this problem in Raku wound up being even easier, because in Raku, Date objects are a native part of the language, and incrementing a Date object increases the value by one day. Even instantiating a Date object was easier, because I didn’t need to parse a date format or specify an array with 0-indexed months or years with 1900 subtracted from them, I was able to specify a year, month, day in my new() call:
#!/usr/bin/env raku
sub MAIN($year) {
# do bounds checking as specified in the problem
if ($year < 1753 || $year > 9999) {
say "Only years between 1753 to 9999 are allowed ($year is out of range)";
exit 1;
}
# create an object for Jan 01 of the given year
my $t = Date.new($year, 1, 1);
# find the first friday
# in Date.day-of-week, 0 = Sunday, 5 = Friday
while ( $t.day-of-week != 5) {
$t++; # add 1 day
}
# now keep adding 7 days to the date until the year changes,
# noting how many times the day of the month is 13
my $thirteen_count = 0;
while ( $t.year == $year ) {
$thirteen_count++ if $t.day == 13;
$t += 7;
}
say "Input: \$year = $year";
say "Output: $thirteen_count";
}
Task 2: Roman Maths
Write a script to handle a 2-term arithmetic operation expressed in Roman numeral.
Example
IV + V => IX
M - I => CMXCIX
X / II => V
XI * VI => LXVI
VII ** III => CCCXLIII
V - V => nulla (they knew about zero but didn't have a symbol)
V / II => non potest (they didn't do fractions)
MMM + M => non potest (they only went up to 3999)
V - X => non potest (they didn't do negative numbers)
Now, I’m not going to get into how Roman numerals did have ways of expressing fractions or numbers larger that 3,999, because that’s not part of the challenge. Remember, I want to showcase how easy it is to solve problems in Perl & Raku. And I knew just the module to use: Roman. Unfortunately, none of the modules for manipulating Roman numerals are in the core Perl distribution, so I had to use cpanm to install it: $ cpanm Roman (I could have used $ cpan install Roman instead, but I like the cpanm tool).
#!/usr/bin/env perl
use v5.38;
use Roman; # there's a module for handling Roman Numerals!
sub do_arithmetic {
my $line = shift;
# split the inout line into the three parts:
# the two operands and the infix operator
my($operand1r, $operator, $operand2r) = split /\s+/, $line;
unless (defined $operand1r &&
defined $operator &&
defined $operand2r) {
say q{Lines must be of the form "operand1 operator operand2"};
say q{where both operands are valid roman numerals and the};
say q{operator is one of the following: + - * / **};
return;
}
my($operand1a, $operand2a);
# check that the first operand is a roman numeral
if (isroman($operand1r)) {
# it is a roman numeral, convert it
$operand1a = arabic($operand1r);
}
else {
say "'$operand1r' is not a roman numberal!";
return;
}
# check that the second operand is a roman numeral
if (isroman($operand2r)) {
# it is a roman numeral, convert it
$operand2a = arabic($operand2r);
}
else {
say "'$operand2r' is not a roman numberal!";
return;
}
# calculate the results
my $result;
if ($operator eq '+') {
$result = $operand1a + $operand2a;
}
elsif ($operator eq '-') {
$result = $operand1a - $operand2a;
}
elsif ($operator eq '*') {
$result = $operand1a * $operand2a;
}
elsif ($operator eq '/') {
$result = $operand1a / $operand2a;
}
elsif ($operator eq '**') {
$result = $operand1a ** $operand2a;
}
else {
die "Unknown operator '$operator'; valid operators are + - * / **\n";
}
# handle all the special output cases
if ($result == 0) {
say "$operand1r $operator $operand2r => nulla "
. "(they knew about zero but didn't have a symbol)";
}
elsif (int($result) != $result) {
say "$operand1r $operator $operand2r => non potest "
. "(they didn't do fractions)";
}
elsif ($result > 3999) {
say "$operand1r $operator $operand2r => non potest "
. "(they only went up to 3999)";
}
elsif ($result < 0) {
say "$operand1r $operator $operand2r => non potest "
. "(they didn't do negative numbers)";
}
else {
say "$operand1r $operator $operand2r => " . uc roman($result);
}
}
# while we have input on STDIN, process the calculations
while (my $line = <>) {
chomp $line;
do_arithmetic($line);
}
At first, I whipped it up as a command-line tool that accepted the two operands and the operator on the command line, but I realized it wouldn’t be easy to produce output as close to the sample as possible doing things this way, so I modified it to read the operations from STDIN. This also allowed me to add a file that could be used by both my Perl and Raku solutions to make the input standardized.
I also wanted to do some extra checking: not just the stuff between lines 53-72 to handle the special cases called out in the example; I wanted to check for invalid Roman numerals and for input that didn’t have two operands separated by an operator. Lines 22-40 do the check using the isroman() function provided by the Roman module, and lines 49-51 make sure that we generate an error if we’re not passed one of the five operators specified in the requirements.
The Raku version of this proved slightly more challenging, because the Math::Roman module available for Raku didn’t have a function corresponding to Perl’s Roman module’s isroman() function. So I had to make one:
#!/usr/bin/env raku
use Math::Roman; # it's v0.0.1, but usable
sub isroman ( $var ) {
# Math::Roman doesn't have a test to see if a string is
# a Roman numeral, but it does throw an exception if it
# cannot convert it
my $result;
try {
CATCH {
default {
return False;
}
}
$result = Math::Roman.new: $var;
}
# Math::Roman also doesn't respect the maximum of 3999
if ($result.as-arabic > 3999) {
return False;
}
return True;
}
sub do_arithmetic (Str $line) {
# split the inout line into the three parts:
# the two operands and the infix operator
my ($operand1, $operator, $operand2) = $line.split(/\s+/);
unless (defined $operand1 &&
defined $operator &&
defined $operand2) {
say q{Lines must be of the form "operand1 operator operand2"};
say q{where both operands are valid roman numerals and the};
say q{operator is one of the following: + - * / **};
return;
}
# check that the first operand is a roman numeral
if (isroman($operand1)) {
# it is a roman numeral, convert it
$operand1 = Math::Roman.new: $operand1;
}
else {
say "'$operand1' is not a roman numberal!";
return;
}
# check that the second operand is a roman numeral
if (isroman($operand2)) {
# it is a roman numeral, convert it
$operand2 = Math::Roman.new: $operand2;
}
else {
say "'$operand2' is not a roman numberal!";
return;
}
# # calculate the results
my $result;
if ($operator eq '+') {
$result = $operand1.as-arabic + $operand2.as-arabic;
}
elsif ($operator eq '-') {
$result = $operand1.as-arabic - $operand2.as-arabic;
}
elsif ($operator eq '*') {
$result = $operand1.as-arabic * $operand2.as-arabic;
}
elsif ($operator eq '/') {
$result = $operand1.as-arabic / $operand2.as-arabic;
}
elsif ($operator eq '**') {
$result = $operand1.as-arabic ** $operand2.as-arabic;
}
else {
die "Unknown operator '$operator'; valid operators are + - * / **\n";
}
# handle all the special output cases
if ($result == 0) {
say "$operand1 $operator $operand2 => nulla "
~ "(they knew about zero but didn't have a symbol)";
}
elsif ($result.truncate != $result) {
say "$operand1 $operator $operand2 => non potest "
~ "(they didn't do fractions)";
}
elsif ($result > 3999) {
say "$operand1 $operator $operand2 => non potest "
~ "(they only went up to 3999)";
}
elsif ($result < 0) {
say "$operand1 $operator $operand2 => non potest "
~ "(they didn't do negative numbers)";
}
else {
$result = Math::Roman.new: value => $result.Int;
say "$operand1 $operator $operand2 => $result";
}
}
# while we have input on STDIN, process the calculations
for $*IN.lines -> $line {
do_arithmetic($line);
}