I’ve been doing the Weekly
Challenges. The
latest
involved splitting sentences and processing arrays. (Note that this
ends today.)
Task 1: Max Words
You are given a list of sentences, @list
.
A sentence is a list of words that are separated by a single space
with no leading or trailing spaces.
Write a script to find out the maximum number of words that appear
in a single sentence.
Not having to account for multiple, leading, or trailing spaces makes
this much easier than it might be. Broadly I used two approaches
depending on which was easier in each language: counting the spaces
(then adding 1), as in Lua:
function maxwords(a)
local m = 0
for i, v in ipairs(a) do
local ct = 0
for n, m in string.gmatch(v, "%s") do
ct = ct + 1
end
if ct > m then
m = ct
end
end
return m + 1
end
or splitting the string, as in Javascript:
function maxwords(a) {
return Math.max(...a.map(x => x.split(" ").length));
}
Task 2: Left Right Sum Diff
You are given an array of integers, @ints.
Write a script to return left right sum diff array as shown below:
(I.e. for a sequence [a..e]
, produce a sequence [-(c+d+e), a-(d+e), (a+b)-(e), (a+b+c)]
- taking the absolute value of each term.)
My basic approach is in two stages: build up the list of sums (from
front and back), then produce the differences.
In Raku:
sub leftrightsumdiff(@a) {
my $al = @a.end;
@left
is 0, a, a+b, etc.; @right
is 0, e, e+d, etc.
my @left = [0];
my @right = [0];
for 0 .. $al-1 -> $i {
@left.push(@left[$i] + @a[$i]);
@right.push(@right[$i] + @a[$al - $i]);
}
I reverse @right
and combine the two.
return Array(zip(@left, @right.reverse).map({abs($_[0] - $_[1])}));
}
Basically every modern language seems to have something like zip
for
iterating two arrays in parallel. The exceptions were Perl, Lua,
PostScript and JavaScript, for which I used an explicit index.
(Probably I should add one to my PostScript libraries, though I
haven't often needed it outside these problems.)
Full code on
github.
Comments on this post are now closed. If you have particular grounds for adding a late comment, comment on a more recent post quoting the URL of this one.