Perl Weekly Challenge: Week 238
Challenge 1:
Running Sum
You are given an array of integers.
Write a script to return the running sum of the given array. The running sum can be calculated as sum[i] = num[0] + num[1] + …. + num[i].
Example 1
Input: @int = (1, 2, 3, 4, 5)
Output: (1, 3, 6, 10, 15)
Example 2
Input: @int = (1, 1, 1, 1, 1)
Output: (1, 2, 3, 4, 5)
Example 3
Input: @int = (0, -1, 1, 2)
Output: (0, -1, 0, 2)
Hooray we can do a one-liner again this week!
$t stores the running total. It is initially 0. .map() is used to iterate through the command line arguments adding each
to the current value of $t. And that's it. The result is a transformed array where each element is the total of itself and
all the elements preceding it. The rest of the code is just for outputting the results in a pretty way.
my $t=0;say q{(},@*ARGS.map({$t+=$_}).join(q{, }),q{)}
The Perl version is even shorter because, unlike in Raku, we don't need to initialize $t.
say q{(},(join q{, },map{$t+=$_}@ARGV),q{)}
Challenge 2:
Persistence Sort
You are given an array of positive integers.
Write a script to sort the given array in increasing order with respect to the count of steps required to obtain a single-digit number by multiplying its digits recursively for each array element. If any two numbers have the same count of steps, then print the smaller number first.
Example 1
Input: @int = (15, 99, 1, 34)
Output: (1, 15, 34, 99)
15 => 1 x 5 => 5 (1 step)
99 => 9 x 9 => 81 => 8 x 1 => 8 (2 steps)
1 => 0 step
34 => 3 x 4 => 12 => 1 x 2 => 2 (2 steps)
Example 2
Input: @int = (50, 25, 33, 22)
Output: (22, 33, 50, 25)
50 => 5 x 0 => 0 (1 step)
25 => 2 x 5 => 10 => 1 x 0 => 0 (2 steps)
33 => 3 x 3 => 6 (1 step)
22 => 2 x 2 => 4 (1 step)
To solve this problem in Raku we start by creating a hash that will map the integers provided to the number of steps it takes to reduce them to single-digit numbers.
my %steps;
Then for each integer...
for @ints -> $int {
...first we have to copy it into another variable $n because $int is immutable.
my $n = $int;
We use a variable $s to count the number of steps taken. It is initially set to 0.
my $s = 0;
Then while $n has more than one digit...
while $n.chars > 1 {
...we split it into individual digits with .comb() and multiply all these digits together with [*].
The result becomes the new value of $n.
$n = [*] ($n.comb);
And we increment the number of steps taken.
$s++;
}
Once we are down to a single digit, the original integer and the numbers of steps are added to
the %steps hash. $n is thrown away; we won't need it.
%steps{$int} = $s;
}
Once we have the step count for all the integers, we can sort them into a new array in ascending numerical order by number of steps. When there is a tie, as the spec suggests, we place the smaller integer first.
my @sorted = %steps.keys.sort({ %steps{$^a} <=> %steps{$^b} || $^a > $^b });
And then we nicely format the results and print them.
say q{(}, @sorted.join(q{, }), q{)};
The Perl version only has one big difference.
my %steps;
for my $int (@ints) {
my $n = $int;
my $s = 0;
while (length $n > 1) {
Because we don't have the handy [*] operator, we have to split $n into digits and
loop through them multiplying them as we go.
my $t = 1;
my @digits = split //, $n;
for my $digit (@digits) {
$t *= $digit;
}
The rest is the same.
$n = $t;
$s++;
}
$steps{$int} = $s;
}
my @sorted = sort { $steps{$a} <=> $steps{$b} || $a > $b } keys %steps;
say q{(}, (join q{, }, @sorted), q{)};