# RogerBW's Blog

The Weekly Challenge 262: Count Max, Type O Negative 31 March 2024

I’ve been doing the Weekly Challenges. The latest involved various sorts of filtering arrays. (Note that this ends today.)

You are given an array of integers, `@ints`.

Write a script to return the maximum number of either positive or negative integers in the given array.

The obvious way would be to iterate over the array once, counting both positives and negatives, as in this Lua:

``````function maxpositivenumber(a)
local pos = 0
local neg = 0
for _, c in ipairs(a) do
if c > 0 then
pos = pos + 1
elseif c < 0 then
neg = neg + 1
end
end
return math.max(pos, neg)
end
``````

However, I mostly ended up iterating twice with something like a filter, as in this Raku:

``````sub maxpositivenumber(@a) {
return max(
@a.grep({\$_ > 0}).elems,
@a.grep({\$_ < 0}).elems,
);
}
``````

It's innately slightly slower; even if iteration overhead is low, it'll test each positive integer for negativity, which the Lua version avoids with its `elseif`. But I find it distinctly more elegant. In PostScript I don't even need any variables (though my implementation of `filter` hides some).

``````/maxpositivenumber {
dup
{ 0 gt } filter length exch
{ 0 lt } filter length
max
} bind def
``````

What I'd really like is a multi-way filter that would give me both the accepted and the rejected streams, but I don't know whether that's a thing in any of the languages I'm using.

You are given an array of integers, `@ints` and an integer `\$k`.

Write a script to return the number of pairs `(i, j)` where

a) `0 <= i < j <` size of `@ints`

b) `ints[i] == ints[j]`

c) `i × j` is divisible by `k`

Where the language had a built-in combination calculator (Raku, Ruby) or an easily-available module (Perl, Rust, Python) I used that. Where I'd had to write my own (Lua, JavaScript, Kotlin, Scala), I didn't bother. I'd had to write my own in PostScript but my build system makes it trivial to use library functions.

Best of all was the Rust where I can run combinations off an enumerated list, so the inner loop already has both the index and the value of each active element:

``````fn countequaldivisible(a: Vec<u32>, k: usize) -> u32 {
let mut s = 0;
for c in a.iter().enumerate().combinations(2) {
if c[0].1 == c[1].1 && c[0].0 * c[1].0 % k == 0 {
s += 1;
}
}
s
}
``````

Mostly I ran combinations on the indices and looked up the values, as in Ruby:

``````def countequaldivisible(a, k)
s = 0
0.upto(a.length - 1).to_a.combination(2) do |c|
if a[c[0]] == a[c[1]] && c[0] * c[1] % k == 0 then
s += 1
end
end
return s
end
``````

Or just had a nested loop, as in Kotlin:

``````fun countequaldivisible(a: List<Int>, k: Int): Int {
var s = 0
for (i in 0 .. a.size - 2) {
for (j in i + 1 .. a.size - 1) {
if (a[i] == a[j] && i * j % k == 0) {
s += 1
}
}
}
return s
}
``````

Full code on github.