我需要一些逻辑来找到句子中的语法模式：
[adjective]* [noun]+ [hyphen] [verb Past Participle | verb Present Participle | one of the special adjectives] [adjective]* [noun]+
其中*表示任何数字（0或更多），？表示0或1，+表示1或更多，|意思是。或
如果我给出任何输入句子，逻辑必须搜索它是否包含上述模式。 我完全不知道如何开始。 如果有人能用某种逻辑建议我的话。
答案 0 :(得分：5)
这是伪代码。它在输入上进行2次传递，在第一次传递中，它将输入字符串中的每个单词转换为引用其类型的字母，在第二次传递中，您将第一次传递的结果与正则表达式匹配。
method(input) {
typed_input = '';
for (word in input) {
if (word is noun) {
typed_input += 'n'
else if (word is adjective)
typed_input += 'a'
else if (word is hyphen)
typed_input += 'h'
else if (word is verb Past Participle)
typed_input += 'v'
else if (word is verb Present Participle)
typed_input += 'p'
else if (word is one of the special adjectives)
typed_input += 's'
else
throw exception("invalid input")
}
return typed_input.match("a*n+h[v|p|s]a*n+")
}
答案 1 :(得分：2)
你写的语法模式非常简单而且不实用。您应该使用块解析。句子中的形容词不仅可以是一个单词（如“猫”），也可能是一大块单词（如“棕色眼睛的黑猫”）。
当句子包含“块”而不是单个形容词时，您的模式将失败。句子应该像树结构一样被解析。
语法检查是一个非常复杂的问题。 在你写任何东西之前 - 你应该熟悉语法检查和自然语言处理的理论。
你可以从这开始：
也许这也是：
SCP: A Simple Chunk Parser by Philip Brooks
我可以把它放在评论中，但标题很长，这里更具可读性。
答案 2 :(得分：2)
这可能会对你有所帮助。 Link to standford parser. 您也可以在java中下载代码。
答案 3 :(得分：0)
我使用stand ford解析器在java中编写了simler程序。你应该使用java stand ford解析器生成数组列表的标记词。
package postagger;
/*
*
*
* lphabetical list of part-of-speech tags used in the Penn Treebank Project:
Number
Tag
Description
1. CC Coordinating conjunction
2. CD Cardinal number
3. DT Determiner
4. EX Existential there
5. FW Foreign word
6. IN Preposition or subordinating conjunction
7. JJ Adjective
8. JJR Adjective, comparative
9. JJS Adjective, superlative
10. LS List item marker
11. MD Modal
12. NN Noun, singular or mass
13. NNS Noun, plural
14. NNP Proper noun, singular
15. NNPS Proper noun, plural
16. PDT Predeterminer
17. POS Possessive ending
18. PRP Personal pronoun
19. PRP$ Possessive pronoun
20. RB Adverb
21. RBR Adverb, comparative
22. RBS Adverb, superlative
23. RP Particle
24. SYM Symbol
25. TO to
26. UH Interjection
27. VB Verb, base form
28. VBD Verb, past tense
29. VBG Verb, gerund or present participle
30. VBN Verb, past participle
31. VBP Verb, non-3rd person singular present
32. VBZ Verb, 3rd person singular present
33. WDT Wh-determiner
34. WP Wh-pronoun
35. WP$ Possessive wh-pronoun
36. WRB Wh-adverb
*/
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.LinkedHashSet;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Scanner;
import java.io.StringReader;
import semanticengine.Description;
import edu.stanford.nlp.objectbank.TokenizerFactory;
import edu.stanford.nlp.process.CoreLabelTokenFactory;
import edu.stanford.nlp.process.DocumentPreprocessor;
import edu.stanford.nlp.process.PTBTokenizer;
import edu.stanford.nlp.ling.CoreLabel;
import edu.stanford.nlp.ling.HasWord;
import edu.stanford.nlp.ling.TaggedWord;
import edu.stanford.nlp.trees.*;
import edu.stanford.nlp.parser.lexparser.LexicalizedParser;
public class EnglishParser {
public static LexicalizedParser lp = null;
public static void main(String[] args)
{
EnglishParser MC=new EnglishParser();
Scanner sc=new Scanner(System.in);
String s="";
while(s!="end")
{
s=sc.nextLine();
ArrayList<TaggedWord> AT=MC.Parse(s);
Description obj= new Description(AT );
System.out.println (AT);
}
}
public static void demoDP(LexicalizedParser lp, String filename) {
// This option shows loading and sentence-segment and tokenizing
// a file using DocumentPreprocessor
TreebankLanguagePack tlp = new PennTreebankLanguagePack();
GrammaticalStructureFactory gsf = tlp.grammaticalStructureFactory();
// You could also create a tokenier here (as below) and pass it
// to DocumentPreprocessor
for (List<HasWord> sentence : new DocumentPreprocessor(filename)) {
Tree parse = lp.apply(sentence);
parse.pennPrint();
System.out.println();
GrammaticalStructure gs = gsf.newGrammaticalStructure(parse);
Collection tdl = gs.typedDependenciesCCprocessed(true);
System.out.println(tdl);
System.out.println();
}
}
//Method for Pos taging.(POS) tagger that assigns its class
//(verb, adjective, ...) to each word of the sentence,
//para@ english is the argument to be tagged
public ArrayList<TaggedWord> Parse(String English)
{
String[] sent =English.split(" ");// { "This", "is", "an", "easy", "sentence", "." };
List<CoreLabel> rawWords = new ArrayList<CoreLabel>();
for (String word : sent) {
CoreLabel l = new CoreLabel();
l.setWord(word);
rawWords.add(l);
}
Tree parse = lp.apply(rawWords);
return parse.taggedYield();
}
public EnglishParser()
{
lp =
new LexicalizedParser("grammar/englishPCFG.ser.gz");
} // static methods only
}
// return pattern of the sentence
public String getPattern(ArrayList<TaggedWord> Sen)
{
Iterator<TaggedWord> its = Sen.iterator();
while (its.hasNext()) {
TaggedWord obj = its.next();
if ((obj.tag().equals("VBZ")) || (obj.tag().equals("VBP"))) {
if (its.hasNext()) {
TaggedWord obj2 = its.next();
if (obj2.tag().equals("VBG")) {
if (its.hasNext()) {
TaggedWord obj3 = its.next();
if ((obj3.tag().equals("VBN"))) {
return "PRESENT_CONT_PASS";
}
}
return "PRESENT_CONT";
// Present Continues
} else if ((obj2.tag().equals("VBN"))) {
return "PRESENT_PASS";
}
return "PRESENT_SIMP";
} else {
return "PRESENT_SIMP";
}
} else if (obj.tag().equals("VBD")) {
if (its.hasNext()) {
TaggedWord obj2 = its.next();
if (obj2.tag().equals("VBG")) {
if (its.hasNext()) {
TaggedWord obj3 = its.next();
if ((obj3.tag().equals("VBN"))) {
return "PATT_CONT_PASS";
}
}
return "PAST_CONT";
} else if ((obj2.tag().equals("VBN"))) {
return "PAST_PASS";
}
return "PAST_SIMP";
} else {
return "PAST_SIMP";
}
}
else if (obj.tag().equals("VB")) {
if (its.hasNext()) {
TaggedWord obj2 = its.next();
if (obj2.tag().equals("VBG")) {
return "FUT_CONT";
} else if ((obj2.tag().equals("VBN"))) {
return "FUT_CONT";
}
} else {
return "FUT_SIMP";
}
}
}
return "NO_PATTERN";
}