RogerBW's Blog

I’ve been doing the Weekly Challenges. The latest involved word selections and manipulations. (Note that this is open until 24 April 2022.)

Task 1:

An abecedarian word is a word whose letters are arranged in alphabetical order. For example, "knotty" is an abecedarian word, but "knots" is not. Output or return a list of all abecedarian words in the dictionary, sorted in decreasing order of length.

My polyglot approach means I need to find out how to read standard input (or a file) in each of the various languages. Javascript and PostScript can't manage line by line, but the rest can.

Then it's a matter of testing each word. Regular expressions would be the obvious way, but they're slow, even in Perl (here's a one-liner in bash, without the length sort).

grep ^$(echo {a..z}\*|sed -e 's/ //g')$

So instead I compare each pair of adjacent characters and break out of the loop if an earlier one has a higher numerical value than a later one. (There are no character sets in common use now that have gaps in the A-Z sequence…)

Perl:

my @b;

while (<>) {
  chomp;
  my @a=split '',$_;
  my $u=1;
  foreach my $i (0..$#a-1) {
    if ($a[$i] gt $a[$i+1]) {
      $u=0;
      last;
    }
  }
  if ($u) {
    push @b,$_;
  }
}

Then sort by length. Everything I use can take a custom comparison function for its built-in sort, except the Quicksort library I wrote for PostScript - so I'd better fix that.

print map {"$_\n"} sort {length($b) <=> length($a)} @b;

Python's pairwise only shows up in 3.10 (October 2021) so still isn't in Debian/stable.

I do not pry: a chin hit is not a dirty blow, bell or not.

Task 2:

A pangram is a sentence or phrase that uses every letter in the English alphabet at least once. For example, perhaps the most well known pangram is:

the quick brown fox jumps over the lazy dog

Using the provided dictionary, so that you don't need to include individual copy, generate at least one pangram.

Your pangram does not have to be a syntactically valid English sentence (doing so would require far more work, and a dictionary of nouns, verbs, adjectives, adverbs, and conjunctions). Also note that repeated letters, and even repeated words, are permitted.

I decided to be moderately efficient. Here's the Ruby:

Forward and reverse lookup tables:

f = {}
r = {}

Each word gets a hash value to indicate which letters it contains: if it has an a, we set bit 0, b, bit 1, etc. (We store only the shortest word for each hash value, so "erase" would be used rather than "erasers".)

while line = gets
  line = line.chomp
  b = 1
  v = 0
  "a".upto("z") do |l|
    if !line.index(l).nil? then
      v |= b
    end
    b <<= 1
  end
  if !r.has_key?(v) || r[v].length > line.length then
    f[line]=v
    r[v]=line
  end
end

The final output will have at least one of each letter – i.e. the combined hash value will be (1) × 26. It starts at zero.

w = []
lt = (1 << 26) - 1
lu = [0]
while (lu[-1] != lt) do
  wn = ""

If we've already got one or more words, we look through the list.

  if (w.length > 0) then
    mode = 0
    sc = []
    r.each_key do |wv|

For each candidate word, if it has no letters in common with what's already in the output, that's a first class candidate. (Delete the list of second-class candidates, if any, and don't add any more.)

      if (wv & lu[-1]) == 0 then
        if mode == 0 then
          mode = 1
          sc = []
        end
        sc.push(r[wv])

Otherwise, if it has at least one letter that we don't already have, it's a second class candidate.

      elsif mode == 0 && (wv | lu[-1]) != lu[-1] then
        sc.push(r[wv])
      end
    end

If we have any candidates, pick one at random – otherwise back out of the last word and try a different one.

    if sc.length == 0 then
      w.pop
      lu.pop
    else
      wn = sc[rand(sc.length)]
    end
  else

If we don't already have one or more words, just pick one at random.

    sc = f.keys
    wn = sc[rand(sc.length)]
  end

If we have a new word, then update both the list and the current hash value.

  if wn != "" then
    w.push(wn)
    lu.push(lu[-1] | f[wn])
  end
end

print(w.join(" ") + "\n")

Ideally then I'd go back over the list, to see if any of the earlier words could be removed without compromising the pangram, but I found myself feeling lazy. Other suggestions were to generate pangrams of only abecedarian words (just feed it the output from task 1 in place of a dictionary file), produce the shortest possible pangram or pangrams where each word would add just one new letter (which could be done with this code, but would need bit-counting), etc.

This was fairly easy to write in various languages, though I was bitten by Raku and its special bitwise operators, different from any other language. (All right, Lua uses "or" rather than "|", but if I use "|" in Lua it doesn't accept it without question and then do the wrong things with it. Apparently "|" on its own "creates an any Junction from its arguments" which seems to be a thing Raku enthusiasts want to do.)

Full code on github.