Question

my home assignment is to decipher a sentence based on a known and finite dictionary.

Example:
Dict – show,blow,while

then the code 12345 8291 came as input.
if we will check the possibilities the the only option is “while show”.

can some one give me a direction or a known algorithm that handle this problem.
pseudo code or java will be great.

thanks

Answer 1

You need to implement some kind of backtracking or other search technique. I’d suggest the following approach:

1. Create a table of cipher-to-character translations. Initially, each cipher (digit) maps to 0 (nothing).
2. Process the input. Every time you come across an unassigned cipher digit, you have a choice of letters based on the dictionary and what’s been determined so far. If there are no assignable letters, backtrack (or report failure in whatever way makes sense for your search technique). Add each choice to your search control logic. (For instance, if you’re using backtracking, save the list of choices and record an arbitrary choice in the translation table. If you backtrack to that point, assign another choice.)
3. Proceed until you either get to the end or you run out of choices.

EDIT: In step 2, the difficult part is determining what letters (if any) can be assigned to the next cipher digit. Suppose we are keeping track of the decoded current word and we want to process the next cipher digit in the word. We have a global map of cipher digit assignments already made. The logic might be something like this (in Java-ish pseudocode):

Set assignableLetters(String wordSoFar, int nextCipher) {
    Character assignment = map.get(nextCipher);
    Set set = new Set();
    if (assignment != null) {
        // The next cipher is already assigned. Add the assignment to the
        // return set only if it is compatible with the dictionary contents
        if (dictionary.hasWordsWithPrefix(wordSoFar + assignment)) {
            set.add(assignment);
        }
    } else {
        // The next cipher is not assigned. We will return a set of all
        // compatible characters that can be assigned to it.
        for (Character c : unassignedCharacters()) {
            if (dictionary.hasWordsWithPrefix(wordSoFar + c)) {
                set.add(c);
            }
        }
    }
    return set;
}

If this returns an empty set, the current assignment (before the method is called) is incompatible with the dictionary and the search must backtrack. Otherwise, the search should pick one assignment at a time from the set and continue, backtracking as necessary.

Rather than trying each unassigned character and asking the dictionary whether it is compatible, it might be more efficient (but logically equivalent) to query the dictionary directly for the list of compatible next characters and intersect that with the unassigned character set.