RogerBW's Blog

I’ve been doing the Weekly Challenges. The latest involved substrings and array mapping. (Note that this ends today.)

Task 1: Acronym

You are given two arrays of strings and a check string.

Write a script to find out if the check string is the acronym of the words in the given array.

This is a one-liner in almost every language. Rust is more verbose than most (though it's probably easier to see what's going on as a result):

fn acronym(strs: Vec<&str>, chk: &str) -> bool {
    strs.iter()
        .map(|x| x.chars().next().unwrap())
        .collect::<String>()
        .to_ascii_lowercase()
        == chk.to_ascii_lowercase()
}

whereas e.g. Python has:

def acronym(strs, chk):
  return "".join(x[0] for x in strs).lower() == chk.lower()

and in PostScript I was able to do it without local variables (which gives a slight speed improvement, but mostly it's more fun).

/acronym {
    exch
    [ exch
      {
          0 get
      } forall
    ] a2s tolower deepeq
} bind def

My library functions s2a (convert a string to an array of integer character values) and a2s (the reverse) turn out to be remarkably useful, because PostScript arrays can be mangled slightly more conveniently than its strings; for example there's no way to say "this is the marker for the start of a string, I'll just push characters onto the stack and eventually drop an end-string marker" the way you can with an array.

Task 2: Build Array

You are given an array of integers.

Write a script to create an array such that new[i] = old[old[i]] where 0 <= i < new.length.

Again this is fairly straightforward. Where there's complexity it's in the specific syntax. Raku:

sub buildarray(@a) {
    return [@a.map({@a[$_]})];
}

Full code on github.