如果字典单词中的所有字符都出现在短语中，则正则表达式匹配。 每个字符出现的次数也必须相互匹配

Question

I'm writing a recursive backtracking search to find anagrams for a phrase. For the first step, I'm trying to filter out all the wrong words from a dictionary before I feed it to the recursive algorithm.

The dictionary file looks like this:

aback
abacus
abalone
abandon
abase
... 
[40,000 more words]

The regex I want to construct must filter out words that contain characters that the phrase do not contain, and also words that contain more occurrences of a character than exists in the phrase.

For example, given the phrase "clint eastwood", the word "noodle" matches, but the word "stonewall" does not, since "stonewall" contains more "l" characters than "clint eastwood" does.

Simply using "[clint eastwood]+" as the regex almost does what I want, but it includes words with any number of the characters in the phrase.

Answer 1

A regex is the wrong tool for comparing character counts. Any regex that satisfies this requirement is likely to be awkward and terribly inefficient. You will be far better off traversing each word and keeping track of the individual character counts.

Anyway, here is a method for constructing a regex that matches the "wrong words" (the other way around is much harder): First, from the set of distinct characters {a1,...,aN} contained in the phrase, you can match all words containing any illegal character with [^a1,...,aN] . Then, for each character c that appears n times in your target string, build a sub-expression (.*c.*){n+1} , then join these fragments with | . For clint eastwood you should get:

(.*c.*){2}|(.*l.*){2}|(.*i.*){2}|(.*n.*){2}|(.*t.*){3}|(.*e.*){2}|(.*a.*){2}|(.*s.*){2}|(.*w.*){2}|(.*o.*){3}|(.*d.*){2}|[^clinteaswod]

Answer 2

As stated in the previous answer, regex is not what you should be looking at. You need to record character counts for each word to quickly filter invalid rows later on. I have a solution that uses a Map<String, Map<Character, Integer>> to do so.

Map<String, Map<Character, Integer>> wordCharacterCount = new HashMap<>();
try (Scanner scanner = new Scanner(new File(...))) {
    while (scanner.hasNextLine()) {
        String word = scanner.nextLine();
        Map<Character, Integer> characterCount = new HashMap<>();
        char[] characters = word.toCharArray();
        for (int i = 0; i < characters.length; i++) {
            char c = Character.toLowerCase(characters[i]);
            if (Character.isLetter(c)) {
                if (!characterCount.containsKey(c)) {
                    characterCount.put(c, 1);
                } else {
                    characterCount.put(c, characterCount.get(c) + 1);
                }
            }
        }
        wordCharacterCount.put(word, characterCount);
    }
}

I used the Stream API for simplicity. For every phrase you would like to filter the dictionary entries on, you construct a similar Map<Character, Integer> and iterate through the Map to filter entries depending on whether it (1) contains invalid characters or (2) has a character count greater than that of the provided phrase.

String testWord = "clint eastwood";
char[] characters = testWord.toCharArray();
for (int i = 0; i < characters.length; i++) {
    char c = Character.toLowerCase(characters[i]);
    if (Character.isLetter(c)) {
        if (!testWordCharacterCount.containsKey(c)) {
            testWordCharacterCount.put(c, 1);
        } else {
            testWordCharacterCount.put(c, testWordCharacterCount.get(c) + 1);
        }
    }
}

List<String> validWords = wordCharacterCount.keySet().stream()
        .filter(word -> {
            Map<Character, Integer> currentWordCharacterCount = wordCharacterCount.get(word);
            for (Entry<Character, Integer> entry : currentWordCharacterCount.entrySet()) {
                char c = entry.getKey();
                int count = entry.getValue();
                if (!testWordCharacterCount.containsKey(c) || testWordCharacterCount.get(c) < count) {
                    return false;
                }
            }
            return true;
        }).collect(Collectors.toList());

I didn't benchmark this thoroughly but in my usage, with a dictionary of 460,000 entries, preprocessing took ~600ms and filters took ~50-150ms each.