Given a dictionary and a list of letters find all valid words that can be built with the letters

Question

The brute force way can solve the problem in O(n!), basically calculating all the permutations and checking the results in a dictionary. I am looking for ways to improve the com

Answer 1

I was recently asked the same question in BankBazaar interview. I was given the option to (he said that in a very subtle manner) pre-process the dictionary in any way I want.

My first thought was to arrange the dictionary in a trie or ternary search tree, and make all the words from the letters given. In any optimization way, that would take n! + n-1! + n-2! n-3! + ..... + n word checks(n being the number of letters) in worst case, which was not acceptable.

The other way could be to check all the dictionary words whether they can be made from the given letters. This again in any optimized way would take noOfDictionaryWords(m) * average size of dictionary words(k) at worst case, which was again not acceptable.

Now I have n! + n-1! + n-2! + .... + N words, which I have to check in the dictionary, and I don't want to check them all, so what are the situations that I have to check only a subset of them, and how to group them.

If I have to check only combination and not permutation, the result gets to 2^n.

so I have to pre-process the dictionary words in such a way that if I pass a combination, all the anagrams would be printed.

A ds something like this : http://1.bp.blogspot.com/-9Usl9unQJpY/Vg6IIO3gpsI/AAAAAAAAAbM/oTuhRDWelhQ/s1600/hashmapArrayForthElement.png A hashvalue made by the letters(irrespective of its positions and permutation), pointing to list containing all the words made by those letters, then we only need to check that hashvalue.

I gave the answer to make the hash value by assigning a prime value to all the alphabets and while calculating the hash value of a word, multiply all the assigned values. This will create a problem of having really big hash values given that 26th prime is 101, and many null values in the map taking space. We could optimize it a bit by rather than starting lexicographically with a = 2, b = 3, c = 5, d = 7.... z = 101, we search for the most used alphabets and assign them small values, like vowels, and 's', 't' etc. The interviewer accepted it, but was not expecting the answer, so there is definitely another answer, for better or worse but there is.

Answer 2

You can sort each word in your dictionary so that the letters appear in the same order as they do in the alphabet, and then build a trie out of your sorted words. (where each node contains a list of all words that can be made out of the letters). (linear time in total letter length of dictionary) Then, given a set of query letters, sort the letters the same way and proceed through the trie using depth first search in all possible directions that use a subset of your letters from left to right. Any time you reach a node in the trie that contains words, output those words. Each path you explore can be charged to at least one word in the dictionary, so the worst case complexity to find all nodes that contain words you can make is O(kn) where n is the number of words in the dictionary and k is the maximum number of letters in a word. However for somewhat restricted sets of query letters, the running time should be much faster per query.

Answer 3

1. "Sign" the letters available by sorting them in order; that's O(m log m), where m is the number of letters.

2. "Sign" each word in the dictionary by sorting the letters of the word in order; that's O(k log k), where k is the length of the word.

3. Compare the letter signature to each word signature; that's O(min(m, k) * n), where n is the number of words in the dictionary. Output any word that matches.

Assuming an English word list of approximately a quarter-million words, and no more than about half a dozen, that should be nearly instantaneous.

Answer 4

If letters can be repeated, that means that a word can be infinitely long. You would obviously cap this at the length of the longest word in the dictionary, but there are still too many words to check. Like nmore suggested, you'd rather iterate over the dictionary to do this.

List<String> findAllValidWords(Set<String> dict, char[] letters) {
  List<String> result = new LinkedList<>();
  Set<Character> charSet = new HashSet<>();
  for (char letter : letters) {
    charSet.add(letter);
  }
  for (String word : dict) {
    if (isPossible(word, charSet)) {
      result.add(word);
    }
  }
  return result;
}

boolean isPossible(String word, Set<Character> charSet) {
  // A word is possible if all its letters are contained in the given letter set
  for (int i = 0; i < word.length(); i++) {
    if (!charSet.contains(word.charAt(i))) {
      return false;
    }
  }
  return true;
}

Answer 5

Swift 3

 func findValidWords(wordsList: [String] , string: String) -> [String]{

    let charCountsDictInTextPassed = getCharactersCountIn(string: string)
    var wordsArrayResult: [String] = []

    for word in wordsList {

        var canBeProduced = true
        let currentWordCharsCount = getCharactersCountIn(string: word)

        for (char, count) in currentWordCharsCount {
            if let charCountInTextPassed = charCountsDictInTextPassed[char], charCountInTextPassed >= count {
                continue
            }else{
                canBeProduced = false
                break
            }
        }// end for

        if canBeProduced {
            wordsArrayResult.append(word)
        }//end if
    }//end for
        return wordsArrayResult
}


// Get the count of each character in the string
func getCharactersCountIn(string: String) -> [String: Int]{
    var charDictCount:[String: Int] = [:]
    for char in string.characters {
        if let count = charDictCount[String(char)] {
            charDictCount[String(char)] = count + 1
        }else{
            charDictCount[String(char)] = 1
        }
    }//end for
    return charDictCount
}

Answer 6

A better way to do this is to loop through all the words in the dictionary and see if the word can be built with the letters in the array.