Best algorithm to find anagram of word from dictonary [closed]

Answer 1

This can be done in following way:

For the given word, keep a count of all the characters in it. For example for OSTP,

count['O'] = 1;
count['S'] = 1;
count['T'] = 1;
count['P'] = 1;

You can form an array of 26 elements like this.

Then while iterating through the dictionary, just check which word has the same character count.

Answer 2

You sort the characters in each word alphabetically to form key in a map whose values are the lists of words for that key.

When you're given a word to find the anagrams for, you sort the characters in that word alphabetically and do a lookup in the map.

From your example and adding the word POOL, you'd get:

LOOP -> [LOOP, POOL, POLO]
OPST -> [STOP, POST]

The Java code would be something like:

public class AnagramGenerator
{
  private Map<String, Collection<String>> indexedDictionary;

  public AnagramGenerator(List<String> dictionary)
  {
    this.indexedDictionary = index(dictionary);
  }

  public Collection<String> getAnagrams(String word)
  {
    return indexedDictionary.get(sort(word));
  }


  private Map<String, Collection<String>> index(List<String> dictionary)
  {
    MultiMap<String, String> indexedDictionary = HashMultimap.create();

    for (String word : dictionary)
    {
      indexDictionary.put(sort(word), word);
    }

    return indexedDictionary.asMap();
  }

  private String sort(String word) 
  {
    List<Character> sortedCharacters= Arrays.asList(word.toCharArray());
    Collections.sort(sortedCharacters);

    StringBuilder builder = new StringBuilder();
    for (Character character : sortedCharacters)
    {
      builder.append(character);
    }

    return builder.toString();
  }
}

Answer 3

For best speed, you can map the characters into unique prime values, multiply them (make sure you have large enough numbers), and use the product as a numerical key for storing the valid permutations. Each number is unique for the given set of permutations as the characters form a unique prime decomposition.

Given an input word, repeat the process to get the value, and access the dictionary directly with that. Similar to sorted strings solution but saves the overhead of sorting and simplifies the key comparisons.

See also here for a related solution in c - Generate same unique hash code for all anagrams

Answer 4

You may preprocess your list: replace any word from it with its sorted anagram (i.e. abacaba becomes aaaabbc). This string uniquely represents any word which is the anagram to the word from the dictionary.

Then, when you receive a query, sort letters in it and check if this word is in preprocessed dictionary.

Answer 5

You can do this.

• sort each word and add it to a MultiMap of sorted word to actual word.
• look up each word to use as an anagram by sorting the word first.

The index cost is once and O(N) where N is the number of words.

After that the cost of sorting is O(M log M) to sort the letters where M is the number of letters. This is very cheap compared to the cost of calculating permutations.

BTW This approach, the words are only scanned once, in advance.