RogerBW's Blog

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

Task 1: Same Row Column

You are given a n x n matrix containing integers from 1 to n.

Write a script to find if every row and every column contains all the integers from 1 to n.

This is a traversal in two stages, and it's easier if one can return from the function early (PostScript can't, Typst doesn't like to, and Scala is so purist that it can't even break out of a loop).

But in PostScript:

/samerowcolumn {
    0 dict begin
    /a exch def

By default return true if no reason is found to change that.

    true

Row by row first:

    a {
        /row exch def

Build a set of all required numbers.

        /notfound [ 1 1 row length { } for ] toset def

Remove each number in the row from that set.

        row {
            notfound exch undef
        } forall

If there's anything left, the return will be false.

        notfound length 0 gt {
            pop false
            exit
        } if
    } forall

If the return is still true, check the columns.

    dup {

Iterate over column numbers.

        0 1 a 0 get length 1 sub {
            /coln exch def

Again, build the set of required numbers.

            /notfound [ 1 1 a length { } for ] toset def

But iterate over the array, picking out the correct column entry from each row.

            a {
                coln get notfound exch undef
            } forall
            notfound length 0 gt {
                pop false
                exit
            } if
        } for
    } if
    end
} bind def

Task 2: Smaller Greater Element

You are given an array of integers.

Write a script to find the number of elements that have both a strictly smaller and greater element in the given array.

This is very similar to challenge 231 task 1 "Min Max" — except that here we want the length of the list of matching elements, not the list itself. So I recycled my existing code, except for Crystal, Scala and Typst, which I wasn't writing at the time.

In Raku:

sub smallergreaterelement(@a) {
    my $mn = min(@a);
    my $mx = max(@a);
    @a.grep({$_ != $mn && $_ != $mx}).elems;
}

Full code on codeberg.