add grammer assignment from WCC CS 145 Spring 2019.
This commit is contained in:
Matthew Jensen
parent
46f17fac95
commit
8018490bbd
|
|
@ -0,0 +1,63 @@
|
|||
// Stuart Reges
|
||||
// 3/10/04
|
||||
//
|
||||
// GrammarMain contains a main program that prompts a user for the name of a
|
||||
// grammar file and then gives the user the opportunity to generate random
|
||||
// versions of various elements of the grammar.
|
||||
|
||||
import java.io.*;
|
||||
import java.util.*;
|
||||
|
||||
public class GrammarMain {
|
||||
public static void main(String[] args) throws FileNotFoundException {
|
||||
Scanner console = new Scanner(System.in);
|
||||
System.out.println("Welcome to the cs145 random sentence generator.");
|
||||
System.out.println();
|
||||
|
||||
// open grammar file
|
||||
System.out.print("What is the name of the grammar file? ");
|
||||
String fileName = console.nextLine();
|
||||
Scanner input = new Scanner(new File(fileName));
|
||||
|
||||
// read the grammar file and construct the grammar solver
|
||||
List<String> grammar = new ArrayList<String>();
|
||||
while (input.hasNextLine())
|
||||
grammar.add(input.nextLine());
|
||||
GrammarSolver solver =
|
||||
new GrammarSolver(Collections.unmodifiableList(grammar));
|
||||
|
||||
showResults(console, solver);
|
||||
}
|
||||
|
||||
// pre : console open for console reading, solver initialized
|
||||
// post: allows the user to repeatedly pick a grammar element to generate
|
||||
public static void showResults(Scanner console, GrammarSolver solver) {
|
||||
for(;;) {
|
||||
System.out.println();
|
||||
System.out.println("Available symbols to generate are:");
|
||||
System.out.println(solver.getSymbols());
|
||||
System.out.print("What do you want generated (return to quit)? ");
|
||||
String target = console.nextLine();
|
||||
if (target.length() == 0)
|
||||
break;
|
||||
if (!solver.grammarContains(target))
|
||||
System.out.println("Illegal symbol");
|
||||
else {
|
||||
System.out.print("How many do you want me to generate? ");
|
||||
if (!console.hasNextInt())
|
||||
System.out.println("that's not an integer");
|
||||
else {
|
||||
int number = console.nextInt();
|
||||
if (number < 0)
|
||||
System.out.println("no negatives allowed");
|
||||
else {
|
||||
String[] answers = solver.generate(target, number);
|
||||
for (int i = 0; i < number; i++)
|
||||
System.out.println(answers[i]);
|
||||
}
|
||||
}
|
||||
console.nextLine(); // to position to next line
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,158 @@
|
|||
/**
|
||||
*
|
||||
* Matt Jensen
|
||||
* CS145 - Lab 5
|
||||
* 5/30/19
|
||||
*
|
||||
*/
|
||||
|
||||
import java.util.*;
|
||||
import java.util.stream.Collectors;
|
||||
|
||||
public class GrammarSolver {
|
||||
|
||||
private Map<String, List<String>> grammarMap;
|
||||
private List<String> grammarList;
|
||||
|
||||
// sets grammar of object.
|
||||
public GrammarSolver(List<String> grammarList) {
|
||||
this.grammarList = grammarList;
|
||||
this.grammarMap = new TreeMap<String, List<String>>();
|
||||
|
||||
// add all lines to grammer.
|
||||
for(String entry : grammarList) {
|
||||
if( this.isValidEntry(entry) ) { // throws exception if illegal.
|
||||
this.addEntry(entry);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
*
|
||||
* Public Methods
|
||||
*
|
||||
*/
|
||||
|
||||
// publicly evaluate grammar
|
||||
public String[] generate(String symbol, int times) {
|
||||
String[] result = new String[times];
|
||||
for( int i = 0; i < result.length; i++) {
|
||||
result[i] = this.generate(symbol);
|
||||
}
|
||||
return result;
|
||||
|
||||
}
|
||||
|
||||
// map of available grammars.
|
||||
public Map<String, List<String>> getGrammars() {
|
||||
return this.grammarMap;
|
||||
}
|
||||
|
||||
// list of grammars.
|
||||
public List<String> getGrammarList() {
|
||||
return this.grammarList;
|
||||
}
|
||||
|
||||
// all the keys/nonterminals of the grammer
|
||||
public String getSymbols() {
|
||||
return this.getGrammars().keySet().toString();
|
||||
}
|
||||
|
||||
// grammer contains a terminal key.
|
||||
public boolean grammarContains(String key) {
|
||||
return this.getGrammars().keySet().contains(key);
|
||||
}
|
||||
|
||||
/**
|
||||
*
|
||||
* Private Helper Methods
|
||||
*
|
||||
*/
|
||||
|
||||
// recursively evaluate grammar
|
||||
private String generate(String symbol) {
|
||||
String result = "";
|
||||
Set<String> symbols = this.getGrammars().keySet();
|
||||
|
||||
// base case
|
||||
if(this.grammarContains(symbol) != true ) {
|
||||
return "";
|
||||
}
|
||||
String rule = this.getRandomTerminal(symbol);
|
||||
|
||||
// apply the rules
|
||||
for(String subRule : GrammarSolver.splitRule(rule)){
|
||||
if( ! result.isEmpty()) {
|
||||
result += " "; // keeps leading whitespace off.
|
||||
}
|
||||
if( this.grammarContains(subRule) ) { // test if a subrule is a nonterminal.
|
||||
result += this.generate(subRule); // evaluates nonterminal rule and appends it.
|
||||
} else {
|
||||
result += subRule;
|
||||
}
|
||||
}
|
||||
return result.trim();
|
||||
}
|
||||
|
||||
// add grammar to grammars.
|
||||
private void addEntry(String entry) {
|
||||
String nonterminal = GrammarSolver.nonTerminal(entry);
|
||||
List<String> rules = GrammarSolver.terminals(entry);
|
||||
this.getGrammars().put(nonterminal, rules);
|
||||
}
|
||||
|
||||
// line of a grammar is valid.
|
||||
private boolean isValidEntry(String entry) {
|
||||
// errors if bad colon count
|
||||
int colonCount = entry.length() - entry.replace(":", "").length();
|
||||
if( colonCount != 1) {
|
||||
throw new IllegalArgumentException("does not contain single colon");
|
||||
}
|
||||
|
||||
// errors if duplicate
|
||||
String nonterminal = GrammarSolver.nonTerminal(entry);
|
||||
if( this.getGrammars().keySet().contains(nonterminal) ) {
|
||||
throw new IllegalArgumentException("duplicate non-terminal detected");
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
// random element of a non-terminal's rules.
|
||||
private String getRandomTerminal(String symbol) {
|
||||
Random random = new Random();
|
||||
List<String> rules = this.getGrammars().get(symbol);
|
||||
int index = random.nextInt(rules.size());
|
||||
return rules.get(index);
|
||||
}
|
||||
|
||||
|
||||
|
||||
/**
|
||||
*
|
||||
* Static Methods
|
||||
*
|
||||
*/
|
||||
|
||||
// splits a string of rules at the whitespaces.
|
||||
private static String[] splitRule(String rule) {
|
||||
String[] split = rule.split("[ \t]");
|
||||
return split;
|
||||
}
|
||||
|
||||
// pre: no whitespace.
|
||||
// pre: non-empty.
|
||||
public static String nonTerminal(String entry) {
|
||||
return entry.substring(0, entry.indexOf(':'));
|
||||
}
|
||||
|
||||
// extracts terminals from a string.
|
||||
public static List<String> terminals(String entry) {
|
||||
List<String> rules = new ArrayList<String>();
|
||||
entry = entry.substring(entry.indexOf(':') + 1, entry.length());
|
||||
String[] exploded = entry.split("\\|");
|
||||
for(int i = 0; i < exploded.length; i++) {
|
||||
rules.add(exploded[i]);
|
||||
}
|
||||
return rules;
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,206 @@
|
|||
import static org.junit.Assert.assertEquals;
|
||||
import static org.junit.Assert.assertTrue;
|
||||
import static org.junit.Assert.assertArrayEquals;
|
||||
import org.junit.Test;
|
||||
import java.util.*;
|
||||
|
||||
public class GrammarTest {
|
||||
|
||||
@Test
|
||||
public void testMixedNonAndTerminals() {
|
||||
List<String> grammar = new ArrayList<String>();
|
||||
grammar.add("<a>:<b> <c>|<b>");
|
||||
grammar.add("<b>:Test");
|
||||
grammar.add("<c>:");
|
||||
GrammarSolver solver = new GrammarSolver(grammar);
|
||||
String[] result = solver.generate("<a>", 1);
|
||||
String[] expected = new String[1];
|
||||
Arrays.fill(expected, "Test");
|
||||
assertArrayEquals(expected, result);
|
||||
}
|
||||
@Test(expected = IllegalArgumentException.class)
|
||||
public void testGenerateNonTermDoesntExist() {
|
||||
List<String> grammar = new ArrayList<String>();
|
||||
grammar.add("<a>:Test|:Other");
|
||||
GrammarSolver solver = new GrammarSolver(grammar);
|
||||
solver.generate("<b>", 1);
|
||||
}
|
||||
|
||||
@Test(expected = IllegalArgumentException.class)
|
||||
public void testGenerateTimesInvalid() {
|
||||
List<String> grammar = new ArrayList<String>();
|
||||
grammar.add("<a>:Test|:Other");
|
||||
GrammarSolver solver = new GrammarSolver(grammar);
|
||||
solver.generate("<a>", 0);
|
||||
solver.generate("<a>", -1);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testGenerate() {
|
||||
String[] expected = new String[2];
|
||||
Arrays.fill(expected, "Test");
|
||||
|
||||
List<String> grammar = new ArrayList<String>();
|
||||
grammar.add("<a>:Test");
|
||||
GrammarSolver solver = new GrammarSolver(grammar);
|
||||
|
||||
String[] result = solver.generate("<a>", 2);
|
||||
assertArrayEquals(expected, result);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testMultipleRulePaths() {
|
||||
String[] expected = new String[3];
|
||||
Arrays.fill(expected, "Test Nest");
|
||||
|
||||
List<String> grammar = new ArrayList<String>();
|
||||
grammar.add("<a>:<b> <c>");
|
||||
grammar.add("<b>:Test");
|
||||
grammar.add("<c>:Nest");
|
||||
GrammarSolver solver = new GrammarSolver(grammar);
|
||||
|
||||
String[] result = solver.generate("<a>", 3);
|
||||
assertArrayEquals(expected, result);
|
||||
}
|
||||
@Test
|
||||
public void testMultipleSymbolsAsRules() {
|
||||
String[] expected = new String[3];
|
||||
Arrays.fill(expected, "Nest Nest");
|
||||
|
||||
List<String> grammar = new ArrayList<String>();
|
||||
grammar.add("<a>:<b> <c>");
|
||||
grammar.add("<b>:<c>");
|
||||
grammar.add("<c>:Nest");
|
||||
GrammarSolver solver = new GrammarSolver(grammar);
|
||||
|
||||
String[] result = solver.generate("<a>", 3);
|
||||
assertArrayEquals(expected, result);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testGenerateNestedTwice() {
|
||||
String[] expected = new String[3];
|
||||
Arrays.fill(expected, "Nest");
|
||||
|
||||
List<String> grammar = new ArrayList<String>();
|
||||
grammar.add("<a>:<b>");
|
||||
grammar.add("<b>:<c>");
|
||||
grammar.add("<c>:Nest");
|
||||
GrammarSolver solver = new GrammarSolver(grammar);
|
||||
|
||||
String[] result = solver.generate("<a>", 3);
|
||||
assertArrayEquals(expected, result);
|
||||
}
|
||||
@Test
|
||||
public void testGenerateNested() {
|
||||
String[] expected = new String[2];
|
||||
Arrays.fill(expected, "Nest");
|
||||
|
||||
List<String> grammar = new ArrayList<String>();
|
||||
grammar.add("<a>:<b>");
|
||||
grammar.add("<b>:Nest");
|
||||
GrammarSolver solver = new GrammarSolver(grammar);
|
||||
|
||||
String[] result = solver.generate("<a>", 2);
|
||||
assertArrayEquals(expected, result);
|
||||
}
|
||||
@Test
|
||||
public void testGrammarListImmutable() {
|
||||
List<String> grammar = new ArrayList<String>();
|
||||
grammar.add("<a>:Test");
|
||||
GrammarSolver solver = new GrammarSolver(grammar);
|
||||
String expected = grammar.get(0);
|
||||
String actual = solver.getGrammarList().get(0);
|
||||
assertEquals("got back different than instantiation.", expected, actual);
|
||||
assertArrayEquals("different grammars.", grammar.toArray(), solver.getGrammarList().toArray());
|
||||
}
|
||||
@Test
|
||||
public void testGrammarListImmutableWithPipe() {
|
||||
List<String> grammar = new ArrayList<String>();
|
||||
grammar.add("<a>:Test|Other");
|
||||
GrammarSolver solver = new GrammarSolver(grammar);
|
||||
assertArrayEquals("different grammars.", grammar.toArray(), solver.getGrammarList().toArray());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testNonTerminalExtract() {
|
||||
String entry = "<a>:Test";
|
||||
String expected = "<a>";
|
||||
String actual = GrammarSolver.nonTerminal(entry);
|
||||
assertEquals("failure - extraction failed", expected, actual);
|
||||
}
|
||||
@Test
|
||||
public void testRuleExtractContent() {
|
||||
String entry = "<a>:Test";
|
||||
List<String> expected = new ArrayList<String>();
|
||||
expected.add("Test");
|
||||
List<String> actual = GrammarSolver.terminals(entry);
|
||||
assertArrayEquals("failure - rule extraction failed", expected.toArray(), actual.toArray());
|
||||
}
|
||||
@Test
|
||||
public void testRuleCount() {
|
||||
String entry = "<a>:Test";
|
||||
List<String> expected = new ArrayList<String>();
|
||||
expected.add("Test");
|
||||
List<String> actual = GrammarSolver.terminals(entry);
|
||||
assertEquals("rule count different", expected.size(), actual.size());
|
||||
}
|
||||
|
||||
@Test(expected = IllegalArgumentException.class)
|
||||
public void testNoColon() {
|
||||
List<String> grammar = new ArrayList<String>();
|
||||
grammar.add("test");
|
||||
GrammarSolver solver = new GrammarSolver(grammar);
|
||||
}
|
||||
|
||||
@Test(expected = IllegalArgumentException.class)
|
||||
public void testDuplicateGrammar() {
|
||||
List<String> grammar = new ArrayList<String>();
|
||||
grammar.add("<a>:Test|Other");
|
||||
grammar.add("<a>:Test|Other");
|
||||
GrammarSolver solver = new GrammarSolver(grammar);
|
||||
}
|
||||
|
||||
@Test(expected = IllegalArgumentException.class)
|
||||
public void testGrammarContainsSingleColon() {
|
||||
List<String> grammar = new ArrayList<String>();
|
||||
grammar.add("<a>:Test|:Other");
|
||||
GrammarSolver solver = new GrammarSolver(grammar);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testGrammarContains() {
|
||||
List<String> grammar = new ArrayList<String>();
|
||||
grammar.add("<a>:Test");
|
||||
GrammarSolver solver = new GrammarSolver(grammar);
|
||||
assertEquals(true, solver.grammarContains("<a>"));
|
||||
assertEquals(false, solver.grammarContains("a"));
|
||||
assertEquals(false, solver.grammarContains("<b>"));
|
||||
}
|
||||
@Test
|
||||
public void testGrammarContainsCaseInsensitive() {
|
||||
List<String> grammar = new ArrayList<String>();
|
||||
grammar.add("<a>:Test");
|
||||
GrammarSolver solver = new GrammarSolver(grammar);
|
||||
assertEquals(true, solver.grammarContains("<a>"));
|
||||
assertEquals(false, solver.grammarContains("<A>"));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testGetSymbols() {
|
||||
List<String> grammar = new ArrayList<String>();
|
||||
grammar.add("<a>:Test");
|
||||
grammar.add("<b>:Test|Other");
|
||||
GrammarSolver solver = new GrammarSolver(grammar);
|
||||
assertEquals("[<a>, <b>]", solver.getSymbols());
|
||||
}
|
||||
@Test
|
||||
public void testGetSymbolsSorted() {
|
||||
List<String> grammar = new ArrayList<String>();
|
||||
grammar.add("<C>:Test|Other");
|
||||
grammar.add("<A>:Test");
|
||||
grammar.add("<b>:Test|Other");
|
||||
GrammarSolver solver = new GrammarSolver(grammar);
|
||||
assertEquals("[<A>, <C>, <b>]", solver.getSymbols());
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,10 @@
|
|||
<s>:<np> <vp>
|
||||
<np>:<dp> <adjp> <n>|<pn>
|
||||
<pn>:John|Jane|Sally|Spot|Fred|Elmo
|
||||
<adjp>:<adj>|<adj> <adjp>
|
||||
<adj>:big|fat|green|wonderful|faulty|subliminal|pretentious
|
||||
<dp>:the|a
|
||||
<n>:dog|cat|man|university|father|mother|child|television
|
||||
<vp>:<tv> <np>|<iv>
|
||||
<tv>:hit|honored|kissed|helped
|
||||
<iv>:died|collapsed|laughed|wept
|
||||
|
|
@ -0,0 +1,5 @@
|
|||
E: T | E OP T
|
||||
T: x | y | 42 | 0 | 1 | 92 | ( E ) | F1 ( E ) | - T | F2 ( E , E )
|
||||
OP: + | - | * | % | /
|
||||
F1: sin | cos| tan |sqrt | abs
|
||||
F2:max |min | pow
|
||||
Binary file not shown.
|
After Width: | Height: | Size: 339 KiB |
Loading…
Reference in New Issue