正则表达式：查找带有额外字符的单词

Question

我想在一个句子中找到“帮助”这个词。这本身就是一件容易的事。然而，在某些情况下，这个词可能写成heelp 或hhelp，基本上包含比通常更多的字符。当然，有些例子比其他例子更真实。

查找“帮助”的基本正则表达式（忽略大小写差异 - (?i) 可以涵盖这一点）是：

(help)

但是，此正则表达式仅检测直截了当的单词，而不考虑可以添加的额外字符。

替换双字符不是一种选择，因为有些单词通常（

那么使用正则表达式，有什么方法可以让我找到以某种方式具有“帮助”的单词吗？

测试文本（说明正则表达式是否应该找到它）

heelp (match)
help (match)
help (match)
heeeelp (match)
hhhheeeelllllpppp (match)
heeeklp (match)
hlep (no match)
helper (no match)
helperp (no match) 
hhhheeeeekklllllpppp (match)
hpeepr33erlrpetertp (no match)
heplp (match)
hepl (no match)
heeeeellllllllpppppppppppl (no match)

数字应该被忽略。

h+e+l+p

（查看边界）将排除实例heplp。

至于每种类型的字符数量，它会有所不同。这就是我不能只制作字符串数组的原因。

如果相关的话，我使用的编程语言是 Java。此外，外壳并不重要。如有必要，可以在检查之前将其小写，或者我可以添加不区分大小写标志。

---

TL:DR; 目标是在中间有其他字符（可能是也可能不是与前面的字符相同）作为检测目标的单词中的字符（同样，在本例中为help）。

Answer 1

这不是一件容易的事，你需要一个好的 NLP（自然语言处理）库。

对于可能是 Apache OpenNLP 项目的 Java。

对于 Perl，有像 Lingua::Stem（如果你在 stemming 之后）或 PHP soundex（如果你在类似 语音 词之后）这样的模块。

Answer 2

这行得通。尝试任何在线正则表达式测试器，以确保它是您正在寻找的： 备注：这适用于任何数量的不需要的字母，如果您需要 1 个字母 - “\w*” 模式应替换为“\w?” （以及相应的 java 代码）

\bh+\w*e+\w*l+\w*p+\b

更新*

这是在任何单词上获取此类正则表达式的 java 代码

public static String getRegExForWord(String word){
        char[] chars =  word.toCharArray();
        StringBuilder pattern = new StringBuilder("\\b");
        for (int i = 0; i < chars.length-1; i++) {
            pattern.append(chars[i]).append("+\\w*");
        }
        return pattern.append(chars[chars.length - 1]).append("+\\b").toString();
    }

Answer 3

更新版本

h = h.trim();
h = h.replaceAll("\\s+", "\n");

Pattern p = Pattern.compile("(h+.*?e+.*?l+.*?p+)", Pattern.MULTILINE);
Matcher m = p.matcher(h);
while(m.find())
{
    System.out.println(m.group(1));
}

Answer 4

我向您提出以下（一般）解决方案：

1. 压缩每个单词，以免有任何重复的字母
2. 获取要匹配的单词字典
3. 匹配字典中具有最小 Levenshtein 距离的单词

压缩应该产生这个：

heelp -> help
help -> help
heeeelp -> help
hhhheeeelllllpppp -> help
heeeklp -> heklp
hlep -> hlep
helper -> helper

两个单词之间的 Levenshtein 距离 (LD(word1, word2)) 是要更改以使它们相等的字符数。示例：

hhhheeeelllllpppp -> help -> LD(help, help) = 0, LD(help, helper) = 2 <- help match
heeeklp -> heklp -> LD(heklp, help) = 1, LD(heklp, helper) = 3 <- help match
hlep -> hlep -> LD(hlep, help) = 2, LD(hlep, helper) = 3 <- help match
helper -> helper -> LD(helper, help) = 2, LD(helper, helper) = 0 <- helper match

这是我的解决方案：

import java.util.*;

public class LevenshteinDistance {                                               
    private static int minimum(int a, int b, int c) {                            
        return Math.min(Math.min(a, b), c);                                      
    }                                                                            

    public static int computeLevenshteinDistance(CharSequence lhs, CharSequence rhs) {      
        int[][] distance = new int[lhs.length() + 1][rhs.length() + 1];        

        for (int i = 0; i <= lhs.length(); i++)                                 
            distance[i][0] = i;                                                  
        for (int j = 1; j <= rhs.length(); j++)                                 
            distance[0][j] = j;                                                  

        for (int i = 1; i <= lhs.length(); i++)                                 
            for (int j = 1; j <= rhs.length(); j++)                             
                distance[i][j] = minimum(                                        
                        distance[i - 1][j] + 1,                                  
                        distance[i][j - 1] + 1,                                  
                        distance[i - 1][j - 1] + ((lhs.charAt(i - 1) == rhs.charAt(j - 1)) ? 0 : 1));

        return distance[lhs.length()][rhs.length()];                           
    }

  public static String compress(String s) {
    char[] chars = s.toCharArray();
    Character last_char = null;

    StringBuilder sb = new StringBuilder();
    for (Character c:chars) {
      if(c != last_char) {
        sb.append(c);
        last_char = c;
      }
    }
    return sb.toString();
  }

    public static void main(String[] argv) {
      String[] strings = {"heelp", "help", "heeeelp", "hhhheeeelllllpppp", "heeeklp", "hlep", "helper"};
      String[] dict = {"help", "helper"};

      String match = "", c;
      int min_distance, distance;
      for(String s : strings) {
        c = compress(s);
        min_distance = computeLevenshteinDistance(c, "");

        for(String d : dict) {
          distance = computeLevenshteinDistance(c, d);
          System.out.println("compressed: "+c+ " dict: "+d+" distance: "+Integer.toString(distance));
          if(distance < min_distance) {
            match = d;
            min_distance = distance;
          }
        }

        System.out.println(s + " matches " + match);
      }
    }                                                                            
}

这是输出：

compressed: help dict: help distance: 0
compressed: help dict: helper distance: 2
heelp matches help
compressed: help dict: help distance: 0
compressed: help dict: helper distance: 2
help matches help
compressed: help dict: help distance: 0
compressed: help dict: helper distance: 2
heeeelp matches help
compressed: help dict: help distance: 0
compressed: help dict: helper distance: 2
hhhheeeelllllpppp matches help
compressed: heklp dict: help distance: 1
compressed: heklp dict: helper distance: 3
heeeklp matches help
compressed: hlep dict: help distance: 2
compressed: hlep dict: helper distance: 3
hlep matches help
compressed: helper dict: help distance: 2
compressed: helper dict: helper distance: 0
helper matches helper

Answer 5

\bh+\w{0,1}e+\w{0,1}l+\w{0,1}p+\b

在 regex101.com 上针对 javascript 进行了测试，以获得示例输入所需的结果。它比使用“*”“更严格”，它只允许零个或一个杂散字母。这符合我的印象，即您允许任何数字中的正确字母，但错误字母只允许两个正确字母之间的一个。

将匹配“帮助”，每个正确字母的任意数字 (>0) 以正确的顺序排列。 在每两个（组）正确字母之间，允许任何其他“单词”字母（数字、字母、“_”）中的一个或零个。单词必须以第一个正确字母开头，并以最后一个正确字母结尾。

为了更精确地选择正确字母之间允许的字母，您可以使用[alltheallowedletters]，以防您不喜欢\w 集合。

我将? 替换为{0,1} 以展示该语法的灵活性。

Answer 6

使用普通正则表达式找到help 后，您需要使用“编辑距离”来查找相似的模式。它是用于拼写检查和单词推荐的指标。例如，如果您从帮助返回所有编辑距离为 1 的单词，您将得到：

helpp
heelp
hellp
hel
belp
...

编辑与help的距离为2：

heeelp
helppp
hhellp

使用 NLTK（Python NLP 包），可以通过以下方式实现：

my_word = 'help'
corpus = {'w1', 'w2'} # Set of all words in your corpus

word_distance = {}

for word in corpus:
    if nltk.edit_distance(my_word, word) <= 2:
        word_distance[word] = nltk.edit_distance(my_word, word)

# Sort dict by value if you choose to return greater edit distances
results = sorted(word_distance, key=word_distance.get, reverse=True)
print(results[:10])

您可以通过正则表达式施加额外的限制以获得更好的结果。例如，nltk.edit_distance 返回的所有内容只有在以h 开头并以p 结尾时才可接受。

Answer 7

我将演示为单词 help 制作正则表达式所需的步骤，但要求不明确，规则不严格，因此通常会出现一些缺点。

\bh+[a-z&&[^e]]*e+[a-z&&[^le]]*l+[a-z&&[^ p  l  e ]]*p+\b
           ^             ^^              ^  ^  ^
           |             ||              |  |--|-> [#2]
           |             ||              |-> [#1]
           |             ||-> Previous char(s) [#2]
           |             |-> [#1]
           |-> Next immediate character [#1]

• [a-z&&[^lep]] 表示除l、e 或p 之外的任何字母

正则表达式复制/粘贴：

\bh+[a-z&&[^e]]*e+[a-z&&[^le]]*l+[a-z&&[^lep]]*p+\b

Live demo