I am working on a Chomsky Normal Form(CNF) dynamic programming assignment which consists of
two parts(I,II): (I). having the user enter a grammar and (checking, accepting) if it is in
valid CNF form or (checking, rejecting) if it is invalid CNF form, and then (II). having the
user enter a string in order to produce a 2D array that displays the derivation of the string.
The table must be displayed whether the string is a member of the grammar or is not a member.
The following is a desired sample output to help put this into context. Right now I am able get all the way through to asking and receiving user input for the string, but at the point where the derivation table to print out, I get 5 NPEs thrown : (
****start of sample output*
Input your context free grammar in CNF: <- /**start of part (I). */
S:AB,A:BB,B:BA,A:a,B:b
================ Your Grammar ================
S -> AB
A -> BB
B -> BA
A -> a
B -> b
============================================== <- /**end of part(I). */
Please enter a string to produce a table: <-/*start of part(II)./
abaaaa
========== Your CNF Production Table =========
| A | S | S | S | S | S |
| | B | B | B | B | B |
| | | A | | | |
| | | | A | | |
| | | | | A | |
| | | | | | A | <-/** end of part(II).*/
*******end of sample output****
Please forgive the overall length of the code, but I figured I had to post all three of my classes in case anyone who reads this tried and compile.
start of GenerateRules.java
import java.util.Arrays;
import java.util.Scanner;
public class GenerateRules
{
ProduceTable dyTab;
public final String NT1 = "A";
public final String NT2 = "B";
public final String NT3 = "C";
public final String terminal1 = "a";
public final String terminal2 = "b";
public final String terminal3 = "c";
//to store each rule and not overrwrite
//and infinitely loop per the initial
//problem on 7/31/2012's original submission
private String startingRule;
private String secondRule;
private String thirdRule;
private String fourthRule;
private String fifthRule;
private String grammarRules;
private String[] rulesArray;
private String[] alphaArray;
private String[][] rulesTable;
private String ruleSeparator = ",";
private String ruleDenoter = ">";
private String start = "S";
private String blank = " ";
private String epsilon = "e";
public GenerateRules()
{
readStartingCNFRule();
readSecondCNFRule();
readThirdCNFRule();
readFourthCNFRule();
readFifthCNFRule();
forgeGrammar();
//readGrammarInput();
}
protected void readStartingCNFRule()
{
Scanner in = new Scanner(System.in);
//null condition for UI's first(starting) CNF rule
String rules_input = null;
//if rules are valid CNF form or not, default case
//set to null
boolean is_validRules = false;
//condition to hold since input is volatile
while (!is_validRules)
{
try
{
//user prompt for entering starting CNF rule
System.out.println("enter starting CNF rule in " +
" regex format: S>AB, or S> e,");
rules_input = in.nextLine();
//so compiler knows to split each rule by ',' indicator
String[] rules = rules_input.split(",");
//iterate through the length of the rule
for (int i = 0; i < rules.length; i++)
{
String parts[] = rules[i].split(">");
//provided format for delineating LHS from RHS
String format = String.format("Rule: '%s', Yield: " +
"'%s'", parts[0], parts[1]);
System.out.println(format);
//conditions for ACCEPTING the starting rule
if(rules_input.startsWith(start)&&rules_input.substring(1).equals(ruleDenoter)
&&rules_input.substring(2).contains(NT1)||rules_input.substring(2).contains(NT2)
||rules_input.substring(2).contains(blank)&&rules_input.substring(3).contains(NT1)
||rules_input.substring(3).contains(NT2)||rules_input.substring(3).contains(epsilon)
&&rules_input.substring(4).contains(ruleSeparator))
{
System.out.println("success! S>AA, S>AB, S>BA, S>BB, or S> e, are" +
" ALL acceptable regexes for starting rule");
//stores the input of starting rule for upcoming use
startingRule = new String(rules_input);
is_validRules = true;
}
//conditions for REJECTING the starting rule
else if(!rules_input.startsWith(start)&&!rules_input.substring(1).equals(ruleDenoter)
&&!rules_input.substring(2).contains(NT1)||!rules_input.substring(2).contains(NT2)
&&!rules_input.substring(3).contains(NT1)||!rules_input.substring(3).contains(NT2)
||!rules_input.substring(3).contains(blank)&&rules_input.substring(4).contains(ruleSeparator))
{
System.out.println("starting rule MUST match regex" +
"of form S>AA, S>AB, S>BA, S>BB, or S> e, . Please re-enter.");
is_validRules = false;
rules_input = in.nextLine();
}
}//end of for-loop
}//end of try-loop
catch (Exception ex)
{
System.out.println(ex.getMessage());
}
}//end of while-loop
}//end of readStartingCNFRule method
protected void readSecondCNFRule()
{
Scanner in = new Scanner(System.in);
String rules_input = null;
//if rules are valid CNF form or not, default case
//set to null
boolean is_validRules = false;
//condition to hold since input is volatile
while (!is_validRules)
{
try
{
//user prompt for entering 2nd CNF rule
System.out.println("enter 2nd CNF rule in regex " +
"A>AA, or B>BB,");
rules_input = in.nextLine();
//so compiler knows to split each rule by ',' indicator
String[] rules = rules_input.split(",");
//iterate through the length of the rule
for (int i = 0; i < rules.length; i++)
{
String parts[] = rules[i].split(">");
//provided format for delineating LHS from RHS
String format = String.format("Rule: '%s', Yield: " +
"'%s'", parts[0], parts[1]);
System.out.println(format);
//conditions for ACCEPTING the second rule
if(rules_input.startsWith(NT1)||rules_input.startsWith(NT2)&&rules_input.substring(1).equals(ruleDenoter)
&&rules_input.substring(2).contains(NT1)||rules_input.substring(2).contains(NT2)
&&rules_input.substring(3).contains(NT1)||rules_input.substring(3).contains(NT2)
&&rules_input.substring(4).contains(ruleSeparator))
{
System.out.println("success! A>AA, A>AB, B>BB, or B>BA are " +
"ALL acceptable regex for 2nd rule ");
//stores the input of 2nd CNF rule for upcoming use
secondRule = new String(rules_input);
is_validRules = true;
}
//conditions for REJECTING the 2nd CNF production
else if(!rules_input.startsWith(NT1)||!rules_input.startsWith(NT2)&&!rules_input.substring(1).equals(ruleDenoter)
&&!rules_input.substring(2).contains(NT1)||!rules_input.substring(2).contains(NT2)
&&!rules_input.substring(3).contains(NT1)||!rules_input.substring(3).contains(NT2)
&&!rules_input.substring(4).contains(ruleSeparator))
{
System.out.println("2nd CNF rule MUST match regex" +
"of either A>AA, A>AB, B>BB, or B>BA. Please re-enter.");
is_validRules = false;
rules_input = in.nextLine();
}
}//end of for-loop
}//end of try-loop
catch (Exception ex)
{
System.out.println(ex.getMessage());
}
}//end of while-loop
}//end of readSecondCNFRule method
protected void readThirdCNFRule()
{
Scanner in = new Scanner(System.in);
String rules_input = null;
//if rules are valid CNF form or not, default case
//set to null
boolean is_validRules = false;
//condition to hold since input is volatile
while (!is_validRules)
{
try
{
//user prompt for entering 3rd CNF rule
System.out.println("enter 3rd CNF rule in regex " +
"A>AA, or B>BB,");
rules_input = in.nextLine();
//so compiler knows to split each rule by ',' indicator
String[] rules = rules_input.split(",");
//iterate through the length of the rule
for (int i = 0; i < rules.length; i++)
{
String parts[] = rules[i].split(">");
//provided format for delineating LHS from RHS
String format = String.format("Rule: '%s', Yield: " +
"'%s'", parts[0], parts[1]);
System.out.println(format);
//conditions for ACCEPTING the 3rd rule
if(rules_input.startsWith(NT1)||rules_input.startsWith(NT2)&&rules_input.substring(1).equals(ruleDenoter)
&&rules_input.substring(2).contains(NT1)||rules_input.substring(2).contains(NT2)
&&rules_input.substring(3).contains(NT1)||rules_input.substring(3).contains(NT2)
&&rules_input.substring(4).contains(ruleSeparator))
{
System.out.println("success! A>AA, A>AB, B>BB, or B>BA are " +
"ALL acceptable regexes for 3rd rule ");
//stores the input of 3rd CNF rule for upcoming use
thirdRule = new String(rules_input);
is_validRules = true;
}
//conditions for REJECTING the 3rd CNF production
else if(!rules_input.startsWith(NT1)||!rules_input.startsWith(NT2)&&!rules_input.substring(1).equals(ruleDenoter)
&&!rules_input.substring(2).contains(NT1)||!rules_input.substring(2).contains(NT2)
&&!rules_input.substring(3).contains(NT1)||!rules_input.substring(3).contains(NT2)
&&!rules_input.substring(4).contains(ruleSeparator))
{
System.out.println("3rd CNF rule MUST match regex" +
"of either A>AA, A>AB, B>BB, or B>BA. Please re-enter.");
is_validRules = false;
rules_input = in.nextLine();
}
}//end of for-loop
}//end of try-loop
catch (Exception ex)
{
System.out.println(ex.getMessage());
}
}//end of while-loop
}//end of readThirdCNFRule method
protected void readFourthCNFRule()
{
Scanner in = new Scanner(System.in);
String rules_input = null;
//if rules are valid CNF form or not, default case
//set to null
boolean is_validRules = false;
//condition to hold since input is volatile
while (!is_validRules)
{
try
{
//user prompt for entering 4th CNF rule
System.out.println("enter 4th CNF rule in regex " +
"A>a, or B>b,");
rules_input = in.nextLine();
//so compiler knows to split each rule by ',' indicator
String[] rules = rules_input.split(",");
//iterate through the length of the rule
for (int i = 0; i < rules.length; i++)
{
String parts[] = rules[i].split(">");
//provided format for delineating LHS from RHS
String format = String.format("Rule: '%s', Yield: " +
"'%s'", parts[0], parts[1]);
System.out.println(format);
//conditions for ACCEPTING the 4th rule
if(rules_input.startsWith(NT1)||rules_input.startsWith(NT2)&&rules_input.substring(1).equals(ruleDenoter)
&&rules_input.substring(2).contains(terminal1)||rules_input.substring(2).contains(terminal2)
&&rules_input.substring(3).contains(ruleSeparator))
{
System.out.println("success! A>a, or B>b are " +
"ALL acceptable regexes for 4th rule ");
//stores the input of 4th CNF rule for upcoming use
fourthRule = new String(rules_input);
is_validRules = true;
}
//conditions for REJECTING the 4th CNF rule
else if(!rules_input.startsWith(NT1)||!rules_input.startsWith(NT2)&&!rules_input.substring(1).equals(ruleDenoter)
&&!rules_input.substring(2).contains(terminal1)||!rules_input.substring(2).contains(terminal2)
&&!rules_input.substring(3).contains(ruleSeparator))
{
System.out.println("4th CNF rule MUST match regex" +
"of either A>a, or B>b, . Please re-enter.");
is_validRules = false;
rules_input = in.nextLine();
}
}//end of for-loop
}//end of try-loop
catch (Exception ex)
{
System.out.println(ex.getMessage());
}
}//end of while-loop
}//end of readFourthCNFRule method
protected void readFifthCNFRule()
{
Scanner in = new Scanner(System.in);
String rules_input = null;
//if rules are valid CNF form or not, default case
//set to null
boolean is_validRules = false;
//condition to hold since input is volatile
while (!is_validRules)
{
try
{
//user prompt for entering 5th CNF rule
System.out.println("enter 5th CNF rule in regex " +
"A>a, or B>b,");
rules_input = in.nextLine();
//so compiler knows to split each rule by ',' indicator
String[] rules = rules_input.split(",");
//iterate through the length of the rule
for (int i = 0; i < rules.length; i++)
{
String parts[] = rules[i].split(">");
//provided format for delineating LHS from RHS
String format = String.format("Rule: '%s', Yield: " +
"'%s'", parts[0], parts[1]);
System.out.println(format);
//conditions for ACCEPTING the 5th rule
if(rules_input.startsWith(NT1)||rules_input.startsWith(NT2)&&rules_input.substring(1).equals(ruleDenoter)
&&rules_input.substring(2).contains(terminal1)||rules_input.substring(2).contains(terminal2)
&&rules_input.substring(3).contains(ruleSeparator))
{
System.out.println("success! A>a, or B>b are " +
"ALL acceptable regexes for 5th rule ");
//stores the input of 5th CNF rule for upcoming use
fifthRule = new String(rules_input);
is_validRules = true;
}
//conditions for REJECTING the 5th CNF rule
else if(!rules_input.startsWith(NT1)||!rules_input.startsWith(NT2)&&!rules_input.substring(1).equals(ruleDenoter)
&&!rules_input.substring(2).contains(terminal1)||!rules_input.substring(2).contains(terminal2)
&&!rules_input.substring(3).contains(ruleSeparator))
{
System.out.println("5th CNF rule MUST match regex" +
"of either A>a, or B>b, . Please re-enter.");
is_validRules = false;
rules_input = in.nextLine();
}
}//end of for-loop
}//end of try-loop
catch (Exception ex)
{
System.out.println(ex.getMessage());
}
}//end of while-loop
}//end of readFifthCNFRule method
/**
* my protected void forgeGrammar() method
* description: aggregates all CNF rules into one
* string and removes the commas before converting
* the rules(grammar) into a 2D array. then, takes
* ui from user (alphaString) so can pass by reference
* to ProduceTable.java
* @param - no-arg
* @return - n/a
*/
protected void forgeGrammar()
{
//this verifies that all 5 rules displayed in the console are valid
grammarRules = new String(startingRule + secondRule + thirdRule + fourthRule + fifthRule);
rulesArray = new String[grammarRules.length()];
//remove the commas from the grammar
rulesArray = grammarRules.split("[,]");
//convert the grammar to a 2D String array
rulesTable = new String[rulesArray.length][5];
for (int i = 0; i < rulesTable.length; i++)
{
String[] rulesMatrix = rulesArray[i].split(blank);
for(int j = 0; j < rulesMatrix.length; j++)
{
rulesTable[i][j] = rulesMatrix[j];
}
}
for(int i = 0; i < rulesTable.length; i++)
{
/**intermittent print out, compilation checkpoint*/
System.out.println(Arrays.toString(rulesTable[i]));
}
//new Scanner instance to receive the alpha string
Scanner in = new Scanner(System.in);
String alpha_input = null;
//the printout prompt for user to enter the grammar
//string
System.out.println("enter a string please using only " +
"terminals a or b with no whitespaces");
alpha_input = in.nextLine();
//initialize alphaArray
alphaArray = new String[alpha_input.length()];
//check for valid string entry
for(int i = 0; i < alpha_input.length(); i++)
{
String temp = Character.toString(alpha_input.charAt(i));
if(alphaStringTest(temp))
{
alphaArray[i] = temp;
}
else
{
System.out.println("alpha string must contain only" +
"a or b . please re-enter.");
alpha_input = in.nextLine();
}
}
dyTab = new ProduceTable(rulesTable, alphaArray);
}//end of forgeGrammar method
/**
* my public Boolean alphaStringTest method
* @param String ui - the input string to test
* (pass by 'reference')
* @return - (Boolean) whether user input
*/
public Boolean alphaStringTest(String ui)
{
String a = "a";
String b = "b";
if(ui.equals(a)||ui.equals(b))
{
return true;
}
return false;
}//end of alphaStringTest method
//end of GenerateRules.java
}
end of GenerateRules.java
Next, is the ProduceTable class:
start of ProduceTable.java
public class ProduceTable
{
private String[][] dynamicTable;
private String[][] rulesTable;
private String[] alphaArray;
/**
* my ProduceTable class constructor
* @param rt - pass by reference from GR.java (line 573)
* @param alph - pass by reference from GR.java (line 573)
*/
public ProduceTable(String[][] rt, String[] alph)
{
//'re'-initializing the rulesTable and the
//ui alpha string
rulesTable = new String[rt.length][rt[0].length];
for(int i = 0; i <rt.length; i++)
{
for(int j = 0; j <rt[0].length; j++)
{
rulesTable[i][j] = rt[i][j];
}
}
try
{
alphaArray = new String[alph.length];
System.arraycopy(alph, 0, alphaArray, 0, alph.length);
}
catch(Exception ex)
{
System.out.println("null input string" + ex);
}
run716();
}//end of class constructor
/**
* my public void run716 method
* description: algo which implements the proof idea of a context-free grammar
* in CNF (G) generating the context-free lang. L . in other words,
* this algo generates a table for L(G) and lets the user know if their alphaString
* is/is not a member of L(G).
* @param - no -arg
* @return - n/a
*
*/
public void run716()
{
//the dynamic table created as a new string[][] with the
//length of the String[] alphaArray, as previously received,
//as its defaulted input
dynamicTable = new String[alphaArray.length][alphaArray.length];
//call to external method to prevent the word 'null' from printing
//out in dynamicTable and instead insert blank spaces.
trim();
//2,3.iterate through each variable A (we are examining
//each substring of length 1
for(int i =0; i < alphaArray.length; i++)
{
//4.test if A-->b is
//a valid rule at b = wi (where wi.length = 1)
for(int a=0;a<rulesTable[0].length;a++)
{
// boolean condition for wi = 1
if(alphaArray[i].equals(rulesTable[1][a]))
{
//5. if A-->b is a rule, place A in the table
dynamicTable[i][i] = rulesTable [0][a];
}
}
}
//6. for l = 2 to n where l = length of substring
//this is for iterating upon substrings of min. len. 2
for(int l=1; l<alphaArray.length;l++)
{
//7. i = starting position of substring, i.e. for i = 1
//to n - l + 1
for(int i=0; i<rulesTable.length-l; i++)
{
//8. let j = i + l - 1, (technically, the -1 is covered
//in (7, above), where i is iterated until < rulesTable.length - 1,
//i.e., wherein j = end position of substring. Hence, j = i + l.
int j = i+l;
//9. for k = i to j - 1, k < j , where k is the
//'split' position 'declaration' BEFORE the
//A-->BC rule form cases are examined
for(int k=i; k<j ;k++)
{
//where substring_marker is used as the
//split marker for each rule A-->BC
for(int substring_marker=0; substring_marker<rulesTable[0].length; substring_marker++)
{
//conditions for where the substring length
//is greater than or equal to 2, pivoting from
//the second row onward
if(rulesTable[1][substring_marker].length() >= 2)
{
//allows a printout for a blank above the diagonal;
//i.e., a blank occurs in the table iff the 2 terminals
//below it cannot be produced in any one step by any
//available rule in the grammar
if(!dynamicTable[i][k].equals(" ") && !dynamicTable
[k+1][j].equals(" "))
{
//10 for each rule A--> BC, if table(i,k)
//contains B and table(k+1,j) contains
//C, put A in table(i,j),
if(dynamicTable[i][k].equals(rulesTable[1][substring_marker].substring(0,1))
&&dynamicTable[k+1][j].equals(rulesTable[1][substring_marker].substring(1,2)))
{
//11.if table(i,k) contains B and table(k+1,j)
//contains C, put A in table(i,j)
dynamicTable[i][j]= rulesTable[0][substring_marker];
}
}
}
}
}
}
}
print7162D();
grammarMember();
}//end of run716 method
/**
* my public static void printAlgo2d()
* description: provides some printout formatting
* for the table to make it more grid-like and
* readable
* @param - no-arg
* @return - none
*/
public void print7162D()
{
//row iterator for alphaString
for(int k=0;k<dynamicTable.length;k++)
{
//col iterator for alphaString
for(int j=0; j<dynamicTable[0].length; j++)
{
//prints out vertical line to create a 'grid'-like
//structure for the table, help with readability,
//and delineate between variables
System.out.print(dynamicTable[k][j] + "|");
}
//prints out a space between each row
System.out.println();
//prints horizontal line-dash to help with
//readability and aesthetic structure between rows
System.out.println("-----");
}
}//end of print7162D
/**
* my public void trim() method
* description: compensates for variation in ui
* alphaString input length, supplanting the word
* 'null' with blank whitespace
* @param - no-arg
* @return - n/a
*/
public void trim()
{
for(int k=0;k<dynamicTable.length;k++)
{
for(int j=0; j<dynamicTable[0].length; j++)
{
dynamicTable[k][j]= " ";
}
}
}
/**
* my public void grammarMember method
* description: provides the printout for the table
* @param - no-arg
* @return - n/a
*/
public void grammarMember()
{
if (dynamicTable[0][alphaArray.length - 1].indexOf("S") == -1)
{
System.out.println("alphaString is not a member of L(G)");
}
else
{
System.out.println("alphaString is a member of L(G)");
}
}//end of grammarMember method
//end of ProduceTable.java
}
end of ProduceTable.java
and finally, a quick little TestHarness class to throw it all together
TestHarness.java
public class TestHarness
{
public static void main(String args[])
{
String[][] p = null;
GenerateRules grrr = new GenerateRules ();
grrr.readStartingCNFRule();
grrr.readSecondCNFRule();
grrr.readThirdCNFRule();
grrr.readFourthCNFRule();
grrr.readFifthCNFRule();
grrr.forgeGrammar();
ProduceTable pt = new ProduceTable(p, args);
pt.run716();
pt.print7162D();
pt.grammarMember();
pt.trim();
}
}
If you happen to be so kind as to compile this, here is a quick demo of how to enter the grammar in my program:
enter starting CNF rule in regex format: S>AB, or S> e,
S>AB,
Rule: 'S', Yield: 'AB'
yes! S>AA, S>AB, S>BA, S>BB, or S> e, are valid 1st regexes
enter 2nd CNF rule in regex A>AA, or B>BB,
A>AA,
Rule: 'A', Yield: 'AA'
success! A>AA, A>AB, B>BB, or B>BA are ALL valid 2nd regexes
enter 3rd CNF rule in regex A>AA, or B>BB,
B>BB,
Rule: 'B', Yield: 'BB'
yes! A>AA, A>AB, B>BB, or B>BA are ALL valid 3rd regexes
enter 4th CNF rule in regex A>a, or B>b,
A>a,
Rule: 'A', Yield: 'a'
success! A>a, or B>b are ALL valid regexes for 4th rule
enter 5th CNF rule in regex A>a, or B>b,
B>b,
Rule: 'B', Yield: 'b'
success! A>a, or B>b are ALL acceptable regexes for 5th rule
==========Your Grammar:======
Rule: 'S', Yield: 'AB'
Rule: 'A', Yield: 'AA'
Rule: 'B', Yield: 'BB'
Rule: 'A', Yield: 'a'
Rule: 'B', Yield: 'b'
if anyone has any advice, it would be greatly appreciated. thank you. the 5 NPEs are generated immedately after hitting return to input the grammar string
The problem arises in this line in ProduceTable.java:
I’m not sure what those loops do exactly, didn’t have time to read all of that. What I assume though is that it should be something like
I would start by checking whether the counters are all set up as intended and whether the array indices are correct.
Also, it’s not 5 NullPointerExceptions you see, it’s the stack trace of 1 NPE.