RogerBW's Blog

I’ve been doing the Weekly Challenges. The latest involved array rebuilding and combinations. (Note that this ends today.) I did this in fewer languages than usual because of UK Games Expo, but I included my favourites.

Task 1: 2D Array

You are given an array of integers and two integers $r amd $c.

Write a script to create two dimension array having $r rows and $c columns using the given array.

Well, the r parameter is irrelevant for a start; I'll just fill c-column subarrays until I run out of content. Rust:

fn twodarray(i: Vec<i32>, _r: usize, c: usize) -> Vec<Vec<i32>> {

Initialise the output array.

    let mut out = Vec::new();

Iterate over the inputs.

    for (ct, n) in i.into_iter().enumerate() {

If we should be starting a new subarray, do so.

        if ct % c == 0 {
            out.push(Vec::new());
        }

Then push the current item onto the latest subarray.

        let ol = out.len() - 1;
        out[ol].push(n);
    }
    out
}

This was fun in PostScript:

/twodarray {
    0 dict begin
    /c exch def
    pop
    /i exch def

Set up the outer array.

    [
        i enumerate.array {
            aload pop
            /n exch def
            /ct exch def

If we're at the start of a subarray, close the previous one if necessary, then start the new one.

            ct c mod 0 eq {
                ct 0 gt {
                    ]
                } if
                [
            } if

And drop the latest value onto it.

            n
        } forall

Close subarray and array, and return them directly.

    ]
    ]
    end
} bind def

(twodarray) test.start
[1 2 3 4] 2 2 twodarray [[1 2] [3 4]] deepeq test
[1 2 3] 1 3 twodarray [[1 2 3]] deepeq test
[1 2 3 4] 4 1 twodarray [[1] [2] [3] [4]] deepeq test
test.end

Task 2: Total XOR

You are given an array of integers.

Write a script to return the sum of total XOR for every subset of given array.

The interesting bit of this is a combination generator. in languages that don't have one (and in which I haven't previously written one, i.e. Typst). Otherwise it's very straightforward: generate the combinations and reduce each one over an XOR. Raku:

sub totalxor(@i) {
    my $tot = 0;
    for @i.combinations(1..@i.elems) -> @c {
        $tot += reduce(&infix:<+^>, @c);
    }
    $tot
}

Full code on github.