Programming

I recently heard about a Car Talk puzzler.  I don’t listen to Car Talk as much as I used to.  Anyway, you can read about the puzzler and the fellow who solved it here.  This is an excerpt.

During Christmas week on the popular National Public Radio show Car Talk, the weekly puzzler required listeners to find the longest English word that remains a valid English word as you remove its letters one at a time, but without rearranging any of the letters. For example: sprite, spit, pit, it, I. There are many such words, but, as Barr discovered, only one with 11 letters.

So, only one word with eleven letters: complecting.  Maybe.  I’m not convinced, but finding out is easy.

Recursion

Okay, so how would you know?  Well, suppose you had a list of valid words.  The statement of the problem suggests a simple recursive algorithm to find a solution.

• Put the words in a heap, ordered longest to shortest.
• Iterate until the heap is empty.
  • Take the next word $w$ from the heap, and perform $\mbox{search}(w)$

The procedure $\mbox{search}(w)$ works as follows.  It returns true if it finds a solution.

• If $w$ is the empty string, then return true.
• For each letter $l$ of $w$, do the following.
  • Drop $l$ from $w$, generating the candidate word $v$.
  • If $v$ is in the dictionary, then execute $r=\mbox{search}(v)$.
    • If $r$ is true, then write out $w$ and return true.
• The word $w$ is a dead end; drop it from the dictionary and return false.

Dropping the words from the dictionary, or otherwise marking them as dead ends in some other way is necessary to avoid re-searching them later.  The time complexity is roughly $O(n)$, where $n$ is the size of the dictionary to search.  If the average length of a word is $k$, then we can be more specific, and say the complexity is $O(kn)$, but $k$ is very small with respect to $n$, and does not vary much with the data size, so it can be safely ignored.

Iteration

The problem was explained to me in the reverse fashion.  Given a letter, generate words by adding a single letter at a time.  Every word must be in the dictionary.  Find the longest word you can generate from a single letter.  This suggests a different algorithm.

• Put the words in a heap, ordered shortest to longest.
• Mark the empty string as reachable and set $long$ to the empty string.
• Iterate through the heap, considering each word $w$.
  • For each position $i$ of $w$, do the following.
    • Drop the $i$th letter from $w$, generating the candidate word $v$.
      • If $v$ is marked as reachable, then mark $w$ as reachable by omitting $i$, and set $long=w$.
• While $long$ is not the empty string, do the following.
  • Write $long$.
  • Omit the character $i$ by which $long$ was reached, and set $long$ equal to the new word.

We can improve this by checking against the length of the longest word reached.  If we ever have $|w|>|longest|+1$, then we can stop the loop immediately, since we cannot reach any further words.  We can’t do that with the prior algorithm.

So… What’s the Longest Word?

The solution given was complecting, at 11 letters.  When I download the aspell dictionaries, and run the algorithm (the iterative one), I find the following derivation.

-> a
-> ah
-> ach
-> bach
-> banch
-> banchi
-> branchi
-> branchia
-> branchiae
-> branchiate
-> abranchiate
-> abranchiates

Ooh.  12 letters.  But, it’s a plural.  Does that count?  Well, complecting is a participle, so it seems it should.  Time to send a note to Tom and Ray?

So… Which Algorithm?

Well, I coded up the iterative one in Java, since originally I was asked how I would code it in Java.  Again, the question suggesting the solution.  I suspect there are a lot of long words that are not reachable, so it seemed better to use the trick to terminate the search when the current word is longer than the longest found (so far) plus one.  Plus, it isn’t recursive, and I don’t have to modify the data structure by deleting an item from the heap.

The Java

So… here’s the Java source.  Enjoy!

/**
 * Given some iterable object that provides strings, find the longest
 * string in the collection that can be reached from the empty string
 * by adding one character at a time such that every intermediate step
 * is also in the collection.
 *
 
 * For example, if the collection is {@code {@literal {}a,
 * at, cat, chat, chart, cart, car{@literal }}},
 * then the longst word is {@code chart}, and it's derivation is:
 * {@code a => at => cat => cart => chart}.  If there are multiple
 * longest words, then only one is detected.
 *
 
 * Note that if single letters are not in the collection, then no words
 * can be derived, and only the empty derivation is returned.
 *
 * @param strings    An iterable providing the strings.
 * @return    The derivation of the longest, from the shortest word to the
 *             longest.  If there is no longest word, then the empty
 *             derivation is returned.
 */
public List search(Iterable strings) {
    if (strings == null) {
        throw new NullPointerException("The string iterator is null.");
    }
 
    // Read each string from the iterable.  The strings assumed to be
    // single words, and the words are not assumed to occur in any
    // particular order.  We put the words we read into a heap, ordered
    // by length.  Our "heap" is a sorted map.
    //
    // Every entry in the map has an associated integer value, which
    // tells us the position of the last inserted character.  This can
    // be used to "unwind" the derivation of the word.  If there is not
    // (yet) any way to reach the word, then the word is mapped to -1.
    TreeMap heap =
        new TreeMap(new Comparator() {
            public int compare(String first, String second) {
                // Okay, we sort first by length, and then alphabetically.
                // This is necessary because of the way TreeMap tests
                // equality; it uses the comparator.  Thus we must only
                // return zero if the two are actually equal.  So, we
                // first order by length, and then for items of the same
                // length, we order using the natural comparator for
                // strings.
                int order = first.length() - second.length();
                if (order == 0) {
                    order = first.compareToIgnoreCase(second);
                }
                return order;
            }
        });
    for (String str : strings) {
        heap.put(str,-1);
    } // Add all strings to the heap.
 
    // Prime the pump by adding the empty string as "reachable."
    String longest = "";
    int length = 0;
    heap.put("", 0);
 
    // At this point the heap is constructed.  We now iterate over the
    // heap looking for connected words.  If we find one, we mark it.
    for (String str : heap.keySet()) {
        // Watch for a case where we skip a length.  If we do, we're done.
        if (str.length() > length+1) {
            break;
        }
        length = str.length();
 
        // Now we have a string, we need to find out if the string is
        // reachable from a previously-reached string.  We drop each
        // character, and then check if the resulting string is
        // present in the heap and is marked.
        for (int index = 0; index < str.length(); index++) {
            // Omit the character at position index.
            String test = str.substring(0,index) + str.substring(index+1);
            // See if the resulting test string is in the heap.
            Integer pos = heap.get(test);
 
            // Now there are three cases:
            // (1) The test string is not in the heap.
            // (2) The test string is in the heap, but not reachable.
            if (pos == null || pos < 0) {
                continue;
            }
            // (3) The test string is in the heap, and is reachable.
            // In this last case we know we can reach the current string
            // from the test string by adding the character at position
            // index, so put this in the heap.
            heap.put(str, index);
            // Note that whenever this happens, we might have just found
            // (one of) the longest words, so save it.
            longest = str;
            // We don't need to test any other positions.
            break;
        } // Construct new words by omitting each character.
    } // Search the heap for words.
 
    // Now we have (hopefully) found a long word.  We need to generate
    // the derivation and return it.
    List derivation = new LinkedList();
    while (longest.length() > 0) {
        // Get the insertion position from the heap.
        int pos = heap.get(longest);
        // Add the word to the derivation.
        derivation.add(0, longest);
        // Generate the prior string in the derivation.
        longest = longest.substring(0, pos) + longest.substring(pos+1);
    } // Build the derivation.
 
    // Done!  Return the derivation.
    return derivation;
}

The code isn’t optimal, but it is commented. I assume you are all capable of putting this in a class and feeding it a dictionary. Have fun!

The Secret Steps

1. Have a really, really good idea. Don’t bother with “good” ideas. We all have those all the time.
2. Summarize your idea in short, choppy sentences suitable for bullet points. Drop articles, verbs, and anything else that gets in the way. Have you ever known a successful grammar teacher?
3. Identify forceful art that is in some way related to your points. Got a great idea to make cars safer? Find a picture of a monkey driving a car! Or that movie of the monkey washing the cat! Or that kitten hanging in mid air! That’s classic.
4. Combine the results of steps 2 and 3 on slides in PowerPoint. Remember: Good ideas fit on slides. After all, if you can’t fit it on a slide, how are you going to prepare an elevator pitch? But I don’t have time for that, because we’re on to the next step!
5. Read the slides to a room of otherwise intelligent people who are already successful because they followed the Secret Steps. They’ll love that kitten picture. The kitten’s just hanging there, and it says “hang in there!” So cute. What were we talking about?
6. Pick three points from your presentation to re-emphasize on the last slide. Keep them short. I recommend you keep them to single words, if you can. Something like “monkey washing cat.” That’s the “hook.”
7. A long process of phone and email tag ensues. Be forceful! Remind them of the three points. It won’t hurt to say how brilliant your idea is, and how these folks are super smart because they “get it.”
8. Profit!
9. Repeat.

Conclusion

Remember: All projects eventually fail, even if they succeed first. Going to the moon? We don’t go there any more. WW2? That war is sooo over. Curing polio? Now there’s very little money in polio research.

The trick is to realize when the project is about to fail and get out fast. I recommend bailing out right after the project kicks off, since that’s the only time you can be sure the project isn’t failing. Then you get a reputation as a starter, an entrepreneur, a “go to” guy.

Now, go forth and $ucceed!

The plugin is WP Hooks. This is a plugin that lets you add content to the page head, and that’s just what we want!

1. Download and install jsMath on your local server.
2. Download, install, and activate WP Hooks in WordPress.
3. Configure this and add the following to the header (change the path to point to your local installation of jsMath):
   <SCRIPT SRC="jsMath/easy/load.js"></SCRIPT>
4. Start writing math on pages.

This seems to work fine. Here’s an example. \[\int \sin x\ dx= -\cos\ x + C\]

This was created as a display equation via writing \[\int \sin x\ dx= -\cos\ x + C\] in the page.

Update: As pointed out in the comments, you need to install the fonts on the client (browser) side for things to look really nice and for math rendering to be fast; otherwise you get a warning and bitmap fonts.  It’s really easy; the instructions are here.

The Cause

This group espouses the following two principles, which I shamelessly copied verbatim from their site.

1. Allow Teaching of and only the Bible by teachers at any time to students anytime.
2. Allowing the Bible (and only the Bible) to be an elective in all schools, and not forced upon.

Continuing on, they state:

We believe every teacher should have the right to teach the Bible at any time.

Please note: To clearify, this group is for teaching of the entire Bible, and only the Bible.

According 1st Amendment of the Constitution of the United States of America, every person has the right to religion. Why is praying/reading of the Bible not allowed in most schools?

The last question is the interesting one. Why is praying / reading of the Bible not allowed in most schools? I’ll take on the challenge of answering that here.

First, neither prayer nor reading the Bible (or any other holy text) is disallowed per se. Courts in the United States have consistently held that religious expression by students cannot be suppressed or abridged unless it can be shown to cause substantial disruption. What is disallowed is school sponsored prayer or Bible reading, even when it is ostensibly student-led.

Agents of the State and the Establishment Clause

The trick is that education is compulsory in the United States, and for this reason public schools are provided using public funding (i.e., our money). The schools are an institution of the government, and teachers and staff are acting as agents of the government.

Even so, prior to Reconstruction the individual states were free to do more or less what they wanted in this regard. The passage of the 14th Amendment to the U.S. Constitution applied the restrictions of the 1st Amendment to the several states via its “due process” clause. The historians and lawyers will correct me here if I’m incorrect, I’m sure.

Anyway, the 1st Amendment:

Congress shall make no law respecting an establishment of religion, or prohibiting the free exercise thereof; or abridging the freedom of speech, or of the press; or the right of the people peaceably to assemble, and to petition the Government for a redress of grievances.

The first two clauses are the “establishment” clause and the “free exercise” clause, respectively. The free exercise clause protects students who wish to pray. The establishment clause restricts what teachers, administrators, or other agents of the government can do and, importantly, what they can use their positions to promote.

So, in summary, this is what has been interpreted by the courts (consistently, I might add) to prohibit school-sponsored religious activities.

The Courts

Daily prayer and Bible readings continued long after Reconstruction ended. In particular, there was a daily Bible reading and devotional at my public junior high school. So why doesn’t this continue?

The answer is that there have been court cases that have ruled that this is not permissible. There seems to be a misconception that those pesky atheists, led by the pesky Madalyn Murray O’Hair were the cause of all the trouble. Not (entirely) true.

The challenges to Bible reading and prayer that make up the case law were predominantly brought by religious people, and usually Christians. Some cases of note are the following.

In Weiss v. District Board, 1890, Catholics objected to the use of the King James Bible in Wisconsin Public Schools. I assume everyone knows the story of the formation of the Church of England, and why Catholics would prefer a translation such as the Douay-Rheims be used.

This case was later cited by Justice Brennan in Abington School District v. Schempp, 1963. This is actually the case where the Supreme Court articulated the ban on school-sponsored Bible reading. Schempp was a Unitarian, and here’s where Madalyn O’Hair shows up. She had a separate case that was consolidated with Schempp’s.

Back to prayer. In Engel v. Vitale, 1962 (the previous year), the Supreme Court ruled that school sponsored prayer violated the establishment clause. The plaintiff’s were primarily rabbinical organizations who objected to opening the school day with a prayer.

The Engel v. Vitale decision has since been extended in a variety of cases, and it is to many of these cases that most recent attention appears to be paid. For instance, in Santa Fe Independent School District v. Doe, 2000 the Court ruled that a school policy sanctioning student-initiated and student-led prayer at school events violated the establishment clause. This action was brought by Catholic and Mormon families. Note that the school policy was held to violate the Constitution, not the prayer itself.

In the majority opinion written by Justice Stevens, the Court objected to prayer:

[...] on school property, at school-sponsored events, over the school’s public address system, by a speaker representing the student body, under the supervision of school faculty, and pursuant to a school policy that explicitly and implicitly encourages public prayer [...]

In short, the student was held to be acting as an agent of the school, and thus of the government. Teachers, administrators, and staff cannot act by proxy through students.

The Court’s position is nicely summarized in the “Lemon Test” arising from Lemon v. Kurtzman. A government action is deemed unconstitutional under the establishment clause if it fails to pass all three prongs of the test:

1. The government’s action must have a secular legislative purpose;
2. The government’s action must not have the primary effect of either advancing or inhibiting religion;
3. The government’s action must not result in an “excessive government entanglement” with religion.

Solutions?

I personally believe it is not necessary to have prayer or Bible reading in the public schools. We have churches and, for that matter, private religious schools. The real issue hinges on compulsory education and public schools.

I would suggest that the members of this particular cause instead consider supporting the elimination of or alternatives to public schools to disentangle the federal government from education altogether. If we wish to retain compulsory education (and most of us probably do), then we could institute a voucher system or other mechanism to provide more school choice.

I’ll close with the following quotation, that I believe summarizes my point quite nicely.

[...] we should at least be able to see that our interest would be best served not by asking the state to promulgate our values but by forbidding the state to promulgate any values at all. If the state can espouse some value that we love in spite of evidence and reason, it can, with equal justice, espouse others that we do not love.

– Richard Mitchell, The Underground Grammarian, v. 6, n. 7