输入： "tableapplechairtablecupboard..."多个字
将此类文本拆分为单词列表并获取的有效算法是什么：
输出： ["table", "apple", "chair", "table", ["cupboard", ["cup", "board"]], ...]
首先想到的是通过所有可能的单词（从第一个字母开始）并找到最长的单词，从position=word_position+len(word)继续
P.S。
我们列出了所有可能的单词
单词“橱柜”可以是“杯子”和“板子”，选择最长
语言：python，但主要的是算法本身。
答案 0 :(得分：148)
当应用于真实世界的数据时，天真的算法不会给出好的结果。这是一个20行算法，它利用相对字频率为真实文本文本提供准确的结果。
（如果你想要一个不使用单词频率的原始问题的答案，你需要改进“最长单词”的确切含义：最好有一个20个字母的单词和10个单词3 - 或者最好有五个10个字母的单词？一旦你确定了一个精确的定义，你只需要改变定义wordcost的行来反映预期的含义。）
最好的方法是建模输出的分布。一个好的第一近似是假设所有单词都是独立分布的。然后你只需要知道所有单词的相对频率。可以合理地假设它们遵循Zipf定律，即单词列表中具有等级 n 的单词的概率大概为1 /（ n log N < / em>）其中 N 是字典中的单词数。
修复模型后，可以使用动态编程来推断空间的位置。最可能的句子是最大化每个单词的概率乘积的句子，并且通过动态编程很容易计算它。我们不是直接使用概率，而是使用定义为概率倒数的对数的成本来避免溢出。
from math import log
# Build a cost dictionary, assuming Zipf's law and cost = -math.log(probability).
words = open("words-by-frequency.txt").read().split()
wordcost = dict((k, log((i+1)*log(len(words)))) for i,k in enumerate(words))
maxword = max(len(x) for x in words)
def infer_spaces(s):
"""Uses dynamic programming to infer the location of spaces in a string
without spaces."""
# Find the best match for the i first characters, assuming cost has
# been built for the i-1 first characters.
# Returns a pair (match_cost, match_length).
def best_match(i):
candidates = enumerate(reversed(cost[max(0, i-maxword):i]))
return min((c + wordcost.get(s[i-k-1:i], 9e999), k+1) for k,c in candidates)
# Build the cost array.
cost = [0]
for i in range(1,len(s)+1):
c,k = best_match(i)
cost.append(c)
# Backtrack to recover the minimal-cost string.
out = []
i = len(s)
while i>0:
c,k = best_match(i)
assert c == cost[i]
out.append(s[i-k:i])
i -= k
return " ".join(reversed(out))
可以与
一起使用s = 'thumbgreenappleactiveassignmentweeklymetaphor'
print(infer_spaces(s))
我正在使用维基百科的一小部分this quick-and-dirty 125k-word dictionary I put together。
之前： thumbgreenappleactiveassignmentweeklymetaphor。
之后：拇指青苹果主动分配每周比喻。
的
之前：以及来自其他人的各种评论的文本信息 odelimitedcharactersinthemforexamplethumbgreenappleactiveassignmentweeklymetapho rapparentlytherearethumbgreenappleetcinthestringialsohavealargedictionarytoquery whetherthewordisreasonablesowhatsthefastestwayofextractionthxalot。
之后：有很多人民评论的文字信息，这些信息都是从html中解析出来的，但其中没有分隔符，例如拇指青苹果主动分配每周隐喻显然有拇指青苹果等在字符串中我还有一个大字典来查询这个单词是否合理，所以最快的提取方法是什么。
的
之前： itwasadarkandstormynighttherainfellintorrentsexceptatoccasionalintervalswhenitwascheckbyaviolentgustofwindwhitsptptupthestreetreetitontontonsnelnelneltlingalongthetoptopsandfiercelyratanttantyflameoftlampsthattrutledtaindtheddarkhedarkness。
之后：这是一个黑暗而暴风雨的夜晚，雨水在洪流中肆虐，除非是偶尔的间隔时间，一阵猛烈的风吹过街道，因为它在伦敦，我们的场景沿着屋顶嘎嘎作响，激烈地搅动着与黑暗作斗争的灯火焰。
正如您所看到的，它基本上是无瑕疵的。最重要的部分是确保你的单词列表被训练成类似于你实际会遇到的语料库，否则结果会非常糟糕。
实现消耗了线性的时间和内存，因此效率相当高。如果您需要进一步加速，可以从单词列表构建后缀树，以减少候选集的大小。
如果需要处理一个非常大的连续字符串，拆分字符串以避免过多的内存使用是合理的。例如，您可以处理10000个字符的块中的文本以及两侧的1000个字符的边距，以避免边界效应。这将使内存使用量降至最低，几乎肯定不会影响质量。
答案 1 :(得分：28)
根据top answer中的出色工作，我创建了一个pip包，方便使用。
>>> import wordninja
>>> wordninja.split('derekanderson')
['derek', 'anderson']
要安装，请运行pip install wordninja。
唯一的区别是轻微的。这会返回list而不是str，它在python3中有效，它包含单词列表并正确分割，即使存在非alpha字符（如下划线，短划线等）
再次感谢Generic Human！
答案 2 :(得分：15)
以下是使用递归搜索的解决方案：
def find_words(instring, prefix = '', words = None):
if not instring:
return []
if words is None:
words = set()
with open('/usr/share/dict/words') as f:
for line in f:
words.add(line.strip())
if (not prefix) and (instring in words):
return [instring]
prefix, suffix = prefix + instring[0], instring[1:]
solutions = []
# Case 1: prefix in solution
if prefix in words:
try:
solutions.append([prefix] + find_words(suffix, '', words))
except ValueError:
pass
# Case 2: prefix not in solution
try:
solutions.append(find_words(suffix, prefix, words))
except ValueError:
pass
if solutions:
return sorted(solutions,
key = lambda solution: [len(word) for word in solution],
reverse = True)[0]
else:
raise ValueError('no solution')
print(find_words('tableapplechairtablecupboard'))
print(find_words('tableprechaun', words = set(['tab', 'table', 'leprechaun'])))
产量
['table', 'apple', 'chair', 'table', 'cupboard']
['tab', 'leprechaun']
答案 3 :(得分：10)
使用trie data structure，其中包含可能的单词列表，执行以下操作不会太复杂：
答案 4 :(得分：8)
Unutbu的解决方案非常接近，但我发现代码难以阅读，并且没有产生预期的结果。 Generic Human的解决方案的缺点是它需要字频率。不适合所有用例。
以下是使用Divide and Conquer algorithm的简单解决方案。
find_words('cupboard')将返回['cupboard']而不是['cup', 'board']（假设cupboard，cup和board在词典中find_words('charactersin')可以返回['characters', 'in']，也可能会返回['character', 'sin']（如下所示）。您可以非常轻松地修改算法以返回所有最佳解决方案。代码：
words = set()
with open('/usr/share/dict/words') as f:
for line in f:
words.add(line.strip())
solutions = {}
def find_words(instring):
# First check if instring is in the dictionnary
if instring in words:
return [instring]
# No... But maybe it's a result we already computed
if instring in solutions:
return solutions[instring]
# Nope. Try to split the string at all position to recursively search for results
best_solution = None
for i in range(1, len(instring) - 1):
part1 = find_words(instring[:i])
part2 = find_words(instring[i:])
# Both parts MUST have a solution
if part1 is None or part2 is None:
continue
solution = part1 + part2
# Is the solution found "better" than the previous one?
if best_solution is None or len(solution) < len(best_solution):
best_solution = solution
# Remember (memoize) this solution to avoid having to recompute it
solutions[instring] = best_solution
return best_solution
我的3GHz机器需要大约5秒钟：
result = find_words("thereismassesoftextinformationofpeoplescommentswhichisparsedfromhtmlbuttherearenodelimitedcharactersinthemforexamplethumbgreenappleactiveassignmentweeklymetaphorapparentlytherearethumbgreenappleetcinthestringialsohavealargedictionarytoquerywhetherthewordisreasonablesowhatsthefastestwayofextractionthxalot")
assert(result is not None)
print ' '.join(result)
从html解析的人们评论的文本信息的reis群众，但是没有分隔的字符，例如拇指绿苹果活跃分配每周隐喻显然在字符串中有拇指青苹果等我也有一个大字典查询这个词是否合理所以最快的提取方式是什么
答案 5 :(得分：6)
https://stackoverflow.com/users/1515832/generic-human的答案很棒。但是，我见过的最好的实施方式是Peter Norvig本人在他的书“美丽的数据”中写的。
在我粘贴他的代码之前，让我展开为什么Norvig的方法更准确（尽管代码方面有点慢和长）。
1）数据更好 - 无论是在大小方面还是在精确度方面（他使用的是字数而不是简单的排名） 2）更重要的是，n-gram背后的逻辑确实使得方法如此准确。
他在书中提供的例子是分裂字符串＆＃39;坐下来的问题。现在，一个非二元组的字符串拆分方法会考虑p（＆＃39; sit＆＃39;）* p（＆＃39; down＆＃39;），如果这小于p（＆＃39;坐下＆＃39;） ;） - 经常会出现这种情况 - 它不会拆分它，但我们希望它（大部分时间）都是这样。
然而，当你拥有二元模型时，你可以将p（＆＃39;坐下来＆＃39;）视为一个二元对抗（＆＃39;坐下来＆＃39;）而前者获胜。基本上，如果你不使用bigrams，它会将你分裂的单词的概率视为独立，而不是这种情况，某些单词更可能一个接一个地出现。不幸的是，这些也是在很多情况下经常粘在一起并且混淆分裂器的词。
这里是指向数据的链接（3个不同问题的数据和细分只有一个。有关详细信息，请阅读本章）：http://norvig.com/ngrams/
这里是代码的链接：http://norvig.com/ngrams/ngrams.py
这些链接已经有一段时间了，但无论如何我都会复制粘贴代码的细分部分
import re, string, random, glob, operator, heapq
from collections import defaultdict
from math import log10
def memo(f):
"Memoize function f."
table = {}
def fmemo(*args):
if args not in table:
table[args] = f(*args)
return table[args]
fmemo.memo = table
return fmemo
def test(verbose=None):
"""Run some tests, taken from the chapter.
Since the hillclimbing algorithm is randomized, some tests may fail."""
import doctest
print 'Running tests...'
doctest.testfile('ngrams-test.txt', verbose=verbose)
################ Word Segmentation (p. 223)
@memo
def segment(text):
"Return a list of words that is the best segmentation of text."
if not text: return []
candidates = ([first]+segment(rem) for first,rem in splits(text))
return max(candidates, key=Pwords)
def splits(text, L=20):
"Return a list of all possible (first, rem) pairs, len(first)<=L."
return [(text[:i+1], text[i+1:])
for i in range(min(len(text), L))]
def Pwords(words):
"The Naive Bayes probability of a sequence of words."
return product(Pw(w) for w in words)
#### Support functions (p. 224)
def product(nums):
"Return the product of a sequence of numbers."
return reduce(operator.mul, nums, 1)
class Pdist(dict):
"A probability distribution estimated from counts in datafile."
def __init__(self, data=[], N=None, missingfn=None):
for key,count in data:
self[key] = self.get(key, 0) + int(count)
self.N = float(N or sum(self.itervalues()))
self.missingfn = missingfn or (lambda k, N: 1./N)
def __call__(self, key):
if key in self: return self[key]/self.N
else: return self.missingfn(key, self.N)
def datafile(name, sep='\t'):
"Read key,value pairs from file."
for line in file(name):
yield line.split(sep)
def avoid_long_words(key, N):
"Estimate the probability of an unknown word."
return 10./(N * 10**len(key))
N = 1024908267229 ## Number of tokens
Pw = Pdist(datafile('count_1w.txt'), N, avoid_long_words)
#### segment2: second version, with bigram counts, (p. 226-227)
def cPw(word, prev):
"Conditional probability of word, given previous word."
try:
return P2w[prev + ' ' + word]/float(Pw[prev])
except KeyError:
return Pw(word)
P2w = Pdist(datafile('count_2w.txt'), N)
@memo
def segment2(text, prev='<S>'):
"Return (log P(words), words), where words is the best segmentation."
if not text: return 0.0, []
candidates = [combine(log10(cPw(first, prev)), first, segment2(rem, first))
for first,rem in splits(text)]
return max(candidates)
def combine(Pfirst, first, (Prem, rem)):
"Combine first and rem results into one (probability, words) pair."
return Pfirst+Prem, [first]+rem
答案 6 :(得分：2)
如果你将wordlist预编译为DFA（这将非常慢），那么匹配输入所需的时间将与字符串的长度成正比（事实上，只比只是迭代字符串）。
这实际上是前面提到的trie算法的更一般版本。我只是完全提到它 - 到目前为止，还没有你可以使用的DFA实现。 RE2可行，但我不知道Python绑定是否允许您调整DFA的大小，然后才会丢弃已编译的DFA数据并执行NFA搜索。
答案 7 :(得分：1)
这会有所帮助
from wordsegment import load, segment
load()
segment('providesfortheresponsibilitiesofperson')
答案 8 :(得分：0)
似乎相当普通的回溯会做。从字符串的开始处开始。向右扫描，直到找到一个单词。然后，在字符串的其余部分调用该函数。如果函数在不识别单词的情况下一直向右扫描，则返回“false”。否则，返回它找到的单词和递归调用返回的单词列表。
示例：“tableapple”。找到“tab”，然后“跳跃”，但“ple”中没有单词。 “leapple”中没有其他词。找到“表”，然后“app”。 “le”不是一个字，所以尝试苹果，认识，回归。
为了尽可能长时间，继续前进，只发出（而不是返回）正确的解决方案;然后，根据您选择的任何标准（maxmax，minmax，average等）选择最佳的
答案 9 :(得分：0)
基于unutbu的解决方案，我实现了Java版本：
private static List<String> splitWordWithoutSpaces(String instring, String suffix) {
if(isAWord(instring)) {
if(suffix.length() > 0) {
List<String> rest = splitWordWithoutSpaces(suffix, "");
if(rest.size() > 0) {
List<String> solutions = new LinkedList<>();
solutions.add(instring);
solutions.addAll(rest);
return solutions;
}
} else {
List<String> solutions = new LinkedList<>();
solutions.add(instring);
return solutions;
}
}
if(instring.length() > 1) {
String newString = instring.substring(0, instring.length()-1);
suffix = instring.charAt(instring.length()-1) + suffix;
List<String> rest = splitWordWithoutSpaces(newString, suffix);
return rest;
}
return Collections.EMPTY_LIST;
}
输入： "tableapplechairtablecupboard"
输出： [table, apple, chair, table, cupboard]
输入： "tableprechaun"
输出： [tab, leprechaun]
答案 10 :(得分：0)
对于德语来说，CharSplit具有机器学习功能，并且对于只有几个单词的字符串非常有效。
答案 11 :(得分：0)
扩展使用Trie的{{3}}建议，仅在python中实施的仅附加@miku's相对简单：
class Node:
def __init__(self, is_word=False):
self.children = {}
self.is_word = is_word
class TrieDictionary:
def __init__(self, words=tuple()):
self.root = Node()
for word in words:
self.add(word)
def add(self, word):
node = self.root
for c in word:
node = node.children.setdefault(c, Node())
node.is_word = True
def lookup(self, word, from_node=None):
node = self.root if from_node is None else from_node
for c in word:
try:
node = node.children[c]
except KeyError:
return None
return node
然后我们可以根据一组单词来构建基于Trie的字典：
dictionary = {"a", "pea", "nut", "peanut", "but", "butt", "butte", "butter"}
trie_dictionary = TrieDictionary(words=dictionary)
这将产生一棵看起来像这样的树（*表示单词的开头或结尾）：
* -> a*
\\\
\\\-> p -> e -> a*
\\ \-> n -> u -> t*
\\
\\-> b -> u -> t*
\\ \-> t*
\\ \-> e*
\\ \-> r*
\
\-> n -> u -> t*
我们可以通过将其与关于如何选择单词的启发式方法相结合，将其纳入解决方案中。例如，与较短的单词相比，我们更喜欢较长的单词：
def using_trie_longest_word_heuristic(s):
node = None
possible_indexes = []
# O(1) short-circuit if whole string is a word, doesn't go against longest-word wins
if s in dictionary:
return [ s ]
for i in range(len(s)):
# traverse the trie, char-wise to determine intermediate words
node = trie_dictionary.lookup(s[i], from_node=node)
# no more words start this way
if node is None:
# iterate words we have encountered from biggest to smallest
for possible in possible_indexes[::-1]:
# recurse to attempt to solve the remaining sub-string
end_of_phrase = using_trie_longest_word_heuristic(s[possible+1:])
# if we have a solution, return this word + our solution
if end_of_phrase:
return [ s[:possible+1] ] + end_of_phrase
# unsolvable
break
# if this is a leaf, append the index to the possible words list
elif node.is_word:
possible_indexes.append(i)
# empty string OR unsolvable case
return []
我们可以像这样使用此功能：
>>> using_trie_longest_word_heuristic("peanutbutter")
[ "peanut", "butter" ]
由于我们在搜索越来越长的单词时一直保持在Trie中的位置，因此我们每个可能的解决方案最多遍历trie一次（而不是{{ 1}}：2，peanut）。最终的短路使我们免于在最坏的情况下通过字符串随意走动。
最终的检查结果很少：
pea此解决方案的一个好处是，您可以很快知道带有给定前缀的较长单词是否存在，从而无需针对字典全面测试序列组合。与其他实现相比，这样做也使peanut答案相对便宜。
该解决方案的缺点是'peanutbutter' - not a word, go charwise
'p' - in trie, use this node
'e' - in trie, use this node
'a' - in trie and edge, store potential word and use this node
'n' - in trie, use this node
'u' - in trie, use this node
't' - in trie and edge, store potential word and use this node
'b' - not in trie from `peanut` vector
'butter' - remainder of longest is a word
的内存占用量大，以及预先构建unsolvable的成本。
答案 12 :(得分：0)
以下是翻译成JavaScript的可接受答案（需要{。{3}}中的node.js和文件“ wordninja_words.txt”）：
var fs = require("fs");
var splitRegex = new RegExp("[^a-zA-Z0-9']+", "g");
var maxWordLen = 0;
var wordCost = {};
fs.readFile("./wordninja_words.txt", 'utf8', function(err, data) {
if (err) {
throw err;
}
var words = data.split('\n');
words.forEach(function(word, index) {
wordCost[word] = Math.log((index + 1) * Math.log(words.length));
})
words.forEach(function(word) {
if (word.length > maxWordLen)
maxWordLen = word.length;
});
console.log(maxWordLen)
splitRegex = new RegExp("[^a-zA-Z0-9']+", "g");
console.log(split(process.argv[2]));
});
function split(s) {
var list = [];
s.split(splitRegex).forEach(function(sub) {
_split(sub).forEach(function(word) {
list.push(word);
})
})
return list;
}
module.exports = split;
function _split(s) {
var cost = [0];
function best_match(i) {
var candidates = cost.slice(Math.max(0, i - maxWordLen), i).reverse();
var minPair = [Number.MAX_SAFE_INTEGER, 0];
candidates.forEach(function(c, k) {
if (wordCost[s.substring(i - k - 1, i).toLowerCase()]) {
var ccost = c + wordCost[s.substring(i - k - 1, i).toLowerCase()];
} else {
var ccost = Number.MAX_SAFE_INTEGER;
}
if (ccost < minPair[0]) {
minPair = [ccost, k + 1];
}
})
return minPair;
}
for (var i = 1; i < s.length + 1; i++) {
cost.push(best_match(i)[0]);
}
var out = [];
i = s.length;
while (i > 0) {
var c = best_match(i)[0];
var k = best_match(i)[1];
if (c == cost[i])
console.log("Alert: " + c);
var newToken = true;
if (s.slice(i - k, i) != "'") {
if (out.length > 0) {
if (out[-1] == "'s" || (Number.isInteger(s[i - 1]) && Number.isInteger(out[-1][0]))) {
out[-1] = s.slice(i - k, i) + out[-1];
newToken = false;
}
}
}
if (newToken) {
out.push(s.slice(i - k, i))
}
i -= k
}
return out.reverse();
}
答案 13 :(得分：0)
如果您包含字符串中包含的单词的详尽列表：
<template>
<div>
<FileUploader :uploadUrl="uploadUrl"/>
</div>
</template>
<script>
import FileUploader from './FileUploader.vue'
export default {
name: 'FileCreator',
components: {
FileUploader
},
props: {
fileId: Number,
},
data() {
return {
uploadUrl: null
}
},
created(){
if (!this.fileId) {
this.fileId = 5 // GETTING WARNING HERE
}
this.uploadUrl = 'http://localhost:8080/files/' + this.fileId
}
}
</script>
使用列表理解来遍历列表以找到单词以及单词出现的次数。
<template>
<div>
<p>URL: {{ uploadUrl }}</p>
</div>
</template>
<script>
export default {
name: 'FileUploader',
props: {
uploadUrl: {type: String, required: true}
},
mounted(){
alert('Upload URL: ' + this.uploadUrl)
}
}
</script>
该函数以列表word_list = ["table", "apple", "chair", "cupboard"]的顺序返回string = "tableapplechairtablecupboard"
def split_string(string, word_list):
return ("".join([(item + " ")*string.count(item.lower()) for item in word_list if item.lower() in string])).strip()
个单词的输出
答案 14 :(得分：0)
非常感谢https://github.com/keredson/wordninja/
中的帮助从我这方面来说，Java的贡献很小。
公共方法splitContiguousWords可以与其他2种方法一起嵌入同一目录中具有ninja_words.txt的类中（或根据编码器的选择进行修改）。并且splitContiguousWords方法可以用于此目的。
public List<String> splitContiguousWords(String sentence) {
String splitRegex = "[^a-zA-Z0-9']+";
Map<String, Number> wordCost = new HashMap<>();
List<String> dictionaryWords = IOUtils.linesFromFile("ninja_words.txt", StandardCharsets.UTF_8.name());
double naturalLogDictionaryWordsCount = Math.log(dictionaryWords.size());
long wordIdx = 0;
for (String word : dictionaryWords) {
wordCost.put(word, Math.log(++wordIdx * naturalLogDictionaryWordsCount));
}
int maxWordLength = Collections.max(dictionaryWords, Comparator.comparing(String::length)).length();
List<String> splitWords = new ArrayList<>();
for (String partSentence : sentence.split(splitRegex)) {
splitWords.add(split(partSentence, wordCost, maxWordLength));
}
log.info("Split word for the sentence: {}", splitWords);
return splitWords;
}
private String split(String partSentence, Map<String, Number> wordCost, int maxWordLength) {
List<Pair<Number, Number>> cost = new ArrayList<>();
cost.add(new Pair<>(Integer.valueOf(0), Integer.valueOf(0)));
for (int index = 1; index < partSentence.length() + 1; index++) {
cost.add(bestMatch(partSentence, cost, index, wordCost, maxWordLength));
}
int idx = partSentence.length();
List<String> output = new ArrayList<>();
while (idx > 0) {
Pair<Number, Number> candidate = bestMatch(partSentence, cost, idx, wordCost, maxWordLength);
Number candidateCost = candidate.getKey();
Number candidateIndexValue = candidate.getValue();
if (candidateCost.doubleValue() != cost.get(idx).getKey().doubleValue()) {
throw new RuntimeException("Candidate cost unmatched; This should not be the case!");
}
boolean newToken = true;
String token = partSentence.substring(idx - candidateIndexValue.intValue(), idx);
if (token != "\'" && output.size() > 0) {
String lastWord = output.get(output.size() - 1);
if (lastWord.equalsIgnoreCase("\'s") ||
(Character.isDigit(partSentence.charAt(idx - 1)) && Character.isDigit(lastWord.charAt(0)))) {
output.set(output.size() - 1, token + lastWord);
newToken = false;
}
}
if (newToken) {
output.add(token);
}
idx -= candidateIndexValue.intValue();
}
return String.join(" ", Lists.reverse(output));
}
private Pair<Number, Number> bestMatch(String partSentence, List<Pair<Number, Number>> cost, int index,
Map<String, Number> wordCost, int maxWordLength) {
List<Pair<Number, Number>> candidates = Lists.reverse(cost.subList(Math.max(0, index - maxWordLength), index));
int enumerateIdx = 0;
Pair<Number, Number> minPair = new Pair<>(Integer.MAX_VALUE, Integer.valueOf(enumerateIdx));
for (Pair<Number, Number> pair : candidates) {
++enumerateIdx;
String subsequence = partSentence.substring(index - enumerateIdx, index).toLowerCase();
Number minCost = Integer.MAX_VALUE;
if (wordCost.containsKey(subsequence)) {
minCost = pair.getKey().doubleValue() + wordCost.get(subsequence).doubleValue();
}
if (minCost.doubleValue() < minPair.getKey().doubleValue()) {
minPair = new Pair<>(minCost.doubleValue(), enumerateIdx);
}
}
return minPair;
}
答案 15 :(得分：-1)
你需要识别你的词汇 - 也许任何免费的单词列表都可以。
完成后，使用该词汇表构建后缀树，并将您的输入流与该词匹配：http://en.wikipedia.org/wiki/Suffix_tree