Fun with isograms

Recently I’ve been cultivating an interest in isograms (words with no repeated letter), especially those with seven letters. Another way to count laps at the pool is to run through the alphabet, so that on successive laps I think of seven-letter isograms starting with ‘a’, ‘b’, and so on. A lap (two lengths) is about the right amount of time. I like to take the view that anything acceptable in a general-knowledge crossword puzzle is fair game, so that, e.g., the first-lap choice could be either ‘acronym’ or ‘Antwerp’. Some letters may have to be skipped, or treated differently in that isograms from an explicitly remembered list are acceptable: there are some tasty ones for ‘j’, such as ‘javelin’ , ‘jealous’, ‘Jericho’, and ‘juniper’, but it’s really hard to come up with new ones quickly, and ‘k’, ‘x’, and ‘z’ are pretty much hopeless.

Six-letter words are ridiculously easy, but seven is a nice spot, or one could stipulate ‘at least seven’. Especially when plurals and other non-base forms are avoided (they seem a bit like cheating), seven-letter words are often very ‘tasty’: either they have three syllables (with, obviously, different vowels) or they feature interesting consonant or vowel clusters.

Then the real challenge is to swim 26 laps and be able to remember all the isograms ‘visited’ during the session. Basically, this means rehearsing the list-so-far constantly, although other mnemonic techniques are conceivable. This is difficult brain work! It is perilously easy to come up with ‘insular’, then go back and recite ‘anxious’, ‘Breslau’, ‘crystal’, ‘disrupt’, ‘Ecuador’, ‘foreign’, ‘Germany’, ‘hirsute’, only to find that the ‘i’ word has been completely forgotten.

This linguistic game is actually a revisiting of a spot from my mindscape of decades ago. There is a connection to discrete mathematics, considering words as specified by pattern together with choice of letters, with the pattern of ‘pattern’ being ‘ABCCDEF’, and the isogrammatic pattern ‘ABCDEFG’ being the simplest of all.

Further, there is an even more obscure connection to my days as a PDP-10 assembly language programmer. The PDP-10 had 36-bit words, and the assembler used an arithmetic coding scheme to represent symbols of up to six characters chosen from the set {‘A’, ‘B’, … ‘Z’, ‘0’, ‘1’, … ‘9’, ‘$’, ‘%’, ‘.’} in 32 bits, leaving 4 bits free for flags. The allowable characters were treated as digits with values from 1 to 39, forming a base-40 number. This scheme was known as Radix50, where ‘50’ is forty in octal. (Octal was very much the ‘native language’ of the early DEC machines; an odometer reading of ‘13777.7’ looked like it was about to roll over.)

The point here is that although 32 bits are not enough to represent an arbitrary sequence of seven letters, they are sufficient to represent a seven-letter isogram (showing octal below):

>>> print "%o" % (26*26*26*26*26*26*26)
>>> print "%o" % (26*25*24*23*22*21*20)
This entry was posted in Uncategorized. Bookmark the permalink.

Leave a Reply

Fill in your details below or click an icon to log in: Logo

You are commenting using your account. Log Out /  Change )

Google+ photo

You are commenting using your Google+ account. Log Out /  Change )

Twitter picture

You are commenting using your Twitter account. Log Out /  Change )

Facebook photo

You are commenting using your Facebook account. Log Out /  Change )

Connecting to %s

This site uses Akismet to reduce spam. Learn how your comment data is processed.