Work the Shell - Numerology, or the Number 23

I admit it, I watch a lot of movies. In the decades I've been alive (a
gentleman doesn't disclose his age!), I've watched tens of thousands of
movies, and average about, oh, 6–8 movies/week. Truth be told, I prefer
classic movies from the '40s and '50s, but my tastes range all over the map
from cheesy horror films to the latest avant-garde foreign cinema.

When I realized that the deadline for this column was rushing up, I did what
any self-respecting geek would do: I got sidetracked with something else.
In this case, the something else was the surprisingly nuanced and
interesting The Number 23, starring Jim Carrey and directed by Joel
Schumacher.

In the movie, Carrey is obsessed with numerology and how so many of the
things in his life add up to the number 23. He's “haunted by the
number”
and ultimately “attacked by the number” as the movie progresses through its
twists and turns.

What I found interesting was the method by which he found 23 to be such a
pervasive number, ranging from the character's birthday (February 3) to
the time on a clock (2:15 is 2/3 if you look at an analog clock face).
Numerology is all about the ordinal value of letters though, where A is
1, B is 2, and so on. So much of the movie is about how words and names
add up to 23 too.

Ah, I thought, could I write a shell script that would do basic
numerology? Could it be that this very magazine is infused with that evil
number? Let's find out!

Breaking Words into Characters

The first step in writing a basic numerology script is to learn how to
break down a word or phrase into its component parts, scrubbing it of all
punctuation and white space. We also want to convert all uppercase to
lowercase, or vice versa, as A and a should have the same numeric
value (1).

This can be done with a single line in a script, thanks to the ever-powerful
tr command:

tr '[A-Z]' '[a-z]' | tr -Cd '[:alnum:]'

The first call to tr converts uppercase to lowercase, as required
(though to be completely portable, I really should have written it as
'[:upper:]' '[:lower:]', but I wanted to have both common idioms
demonstrated here for your reading pleasure).

The second call to tr is a bit more tricky: the -d option instructs the
program to delete characters in the input stream that match the specified
set, and -C reverses the logic of the match. By using '[:alnum:]', I pull
out only the letters and digits, stripping everything else.

The question is what condition should we be testing so that it'll get every
character in the string, but nothing else? According to the cut man
page, the program will produce a nonzero return code on failure, and it
certainly seems to me that an invocation like this:

echo 123 | cut -c4

should be an error, because there is no fourth character, but experimentation
demonstrates that it isn't the case. Here's how I tested it:

Alas, the result is “no error condition”. On the positive side, cut does
return a null string correctly, so we can test for that. But, because we're
doing maximum paranoia coding, it's useful also to have the length of the
word or phrase. After all, what if it's 23 characters long?

Given that the length is already computed (with a quick call to
wc -c),
the conditional simply can be to test ptr against the string length,
calculated after the string is cleaned up. In other words, while [ $ptr
-lt $basislength ].

Calculating Letter Value

The hardest part of this script unquestionably is mapping letters to
numeric values. Perl, C, Awk and just about every scripting language has a
solution, but within the shell itself? There's nothing I can imagine without
extraordinary levels of effort.

Fortunately, there's a 15-character Perl solution that lets us write a
command suitable for dropping into a command pipe:

perl -e '$a=getc(); print ord($a)-96'

Thus, we have a tool to calculate the ordinal value without too much
difficulty, now that we know how to extract individual letters:

The conditional at the top lets this script be maximally flexible. If you
specify a word or phrase when you invoke the script, it'll use that. If you
forget, it'll prompt you to enter a word or phrase. Either way, that ends
up as basis, which is then successively cleaned up to remove unwanted
letters. basislength is the length of the resultant string, which is
stepped through, letter by letter, in the while loop.

Great. We have the basis of a numerology calculator with all the difficult
work taken care of. All that's left is to do some summary values and push
around possible combinations to see if we can ascertain whether that pesky
23 does indeed show up everywhere!

Dave Taylor has been hacking shell scripts for over thirty years. Really.
He's the author of the popular "Wicked Cool Shell Scripts" and
can be found on Twitter as @DaveTaylor and more generally at
www.DaveTaylorOnline.com.

The first thought that came to mind was HM what;s the sun getting ready to do? 2nd thought isn’t 2012 coming in about 2 and 1/2 years. 3 Whats going to happen then and no I was not thinking the end of the world but anythings possible. Shake my head the sun is dead, suns die violently my friends, ooooh!