Stocker des groupes de mots dans une table de hachage

Question

J'ai une liste de mots, et je veux comparer les mots les uns par rapport aux autres, pour les stocker dans un HashTable (dans des groupes d'anagrammes).

Je sais comment comparer deux mots pour tester si elles sont une anagramme, mais je ne peux pas comprendre comment comparer une plus longue liste de mots.

Par exemple:

• Il 10 mots dans la liste
• 5 d'entre eux sont anagrammes les uns des autres
• 2 d'entre eux sont également anagrammes les uns des autres (mais pas du premier groupe)
• Donc, 3 groupes; 1 groupe d'un ensemble de anagrammes (5 mots), 1 groupe pour l'autre ensemble (2 mots), et 1 groupe (3 mots) de mots aléatoires

Comment puis-je comparer les 10 mots pour trouver les 5 +2 anagrammes, et stockez ces groupes d'anagrammes (séparément) dans une table de hachage?

EDIT:

Le code que j'ai pour comparer deux mots:

public static boolean isAnagram(String firstWord, String secondWord) { 

    boolean anagram; 
    if (firstWord.length() != secondWord.length()) { 
     return false; 
    } 
    firstWord = firstWord.toLowerCase(); 
    secondWord=secondWord.toLowerCase(); 
    char[] c1 = firstWord.toCharArray(); 
    char[] c2 = secondWord.toCharArray(); 
    Arrays.sort(c1); 
    Arrays.sort(c2); 
    String sc1 = new String(c1); 
    String sc2 = new String(c2); 
    if (sc1.equals(sc2)) { 
     System.out.println("ANAGRAMS"); 
    } else { 
     System.out.println("NOT ANAGRAMS"); 
    } 
    return sc1.equals(sc2); 
} 

Je suis sûr que cela pourrait être adapté pour fonctionner avec la comparaison d'un nombre illimité de chaînes. Ensuite, le dilemme suivant consiste à s'assurer que les groupes séparés d'anagrammes sont stockés dans la table de hachage.

Answer 1

import org.springframework.util.LinkedMultiValueMap; 
import org.springframework.util.MultiValueMap; 

import java.util.ArrayList; 
import java.util.Arrays; 
import java.util.List; 

public class AnagramDetector { 
    public static void main(String[] args) { 
     List<String> words = new ArrayList<>(); 
     words.add("Abc"); 
     words.add("cba"); 
     words.add("bca"); 
     words.add("bc"); 
     words.add("ba"); 
     words.add("ab"); 

     MultiValueMap<String, String> res = new LinkedMultiValueMap<>(); 
     words.stream().forEach(word -> { 
      String key = getAnagramKey(word); 
      res.add(key, word); 
     }); 
     System.out.println(res); 
    } 
    public static String getAnagramKey(String word) { 
     char[] c = word.toLowerCase().toCharArray(); 
     Arrays.sort(c); 
     return new String(c); 
    } 

} 

Mise à jour pour Hashtable:

import java.util.ArrayList; 
import java.util.Arrays; 
import java.util.Hashtable; 
import java.util.List; 

public class AnagramDetector { 
    public static void main(String[] args) { 
     List<String> words = new ArrayList<>(); 
     words.add("Abc"); 
     words.add("cba"); 
     words.add("bca"); 
     words.add("bc"); 
     words.add("ba"); 
     words.add("ab"); 

     Hashtable<String, List<String>> res = new Hashtable<>(); 
     words.stream().forEach(word -> { 
      String key = getAnagramKey(word); 
      List<String> anWords = res.get(key); 
      if (anWords == null) { 
       anWords = new ArrayList<>(); 
       res.put(key, anWords); 
      } 
      anWords.add(word); 
     }); 
     System.out.println(res); 
    } 
    public static String getAnagramKey(String word) { 
     char[] c = word.toLowerCase().toCharArray(); 
     Arrays.sort(c); 
     return new String(c); 
    } 

} 

Answer 2

Je vois que vous avez déjà compris que vous pouvez trier les chaînes pour savoir si deux chaînes sont des anagrammes.

Vous pouvez stocker chaque chaîne dans la table de hachage lorsque la clé est la chaîne triée. Par exemple, la chaîne "CBA" sera sauvegardée au point "ABC", alors il est assez facile de vérifier si un anagramme d'une chaîne est déjà apparu.

Si vous avez réellement besoin des chaînes elles-mêmes, vous pouvez les stocker dans une liste de listes, ou mieux utiliser Multimap.