Avans/FormeleMethoden
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

why

Browse Source
This commit is contained in:
Yorick Rommers
2017-06-10 00:20:30 +02:00
parent 1f7f0de4f4
commit abaf607a47
2 changed files with 309 additions and 25 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/com/imegumii/Main.java
+5 -1
View File
@@ -1,5 +1,6 @@
package com.imegumii;
import jdk.nashorn.internal.runtime.Source;
import jdk.nashorn.internal.runtime.regexp.joni.Regex;
import java.util.TreeSet;
@@ -414,6 +415,7 @@ public class Main {
String s3 = "(a|b)+a";
String s4 = "a+((ab)*b|ab|(b)*bb)+(abba|baab)+";
String s5 = "((ab)*b(a|b)|ab|(b)*bb)+";
RegExp reg = new RegExp();
// System.out.println(reg.toRegExp("a*|b+").getTaal(5));
@@ -438,7 +440,9 @@ public class Main {
// reg.parseString(s);
// reg.parseString(s2);
// System.out.println(reg.parseString(s4).getTaal(3));
System.out.println(aantalOperators(reg.parseString(s4), 1));
// System.out.println(aantalOperators(reg.parseString(s2),1));
// System.out.println(aantalOperators(reg.parseString(s4), 1));
System.out.println(aantalOperators(reg.parseString(s5), 1));
// System.out.println(reg.parseString(s3).getTaal(100)); // werkte!
}
src/com/imegumii/RegExp.java
+304 -24
View File
@@ -1,6 +1,7 @@
package com.imegumii;
import javafx.scene.Parent;
import jdk.nashorn.internal.runtime.regexp.joni.Regex;
import java.util.*;
@@ -49,24 +50,24 @@ public class RegExp {
int counter = 0;
boolean cutOff = false;
int lastIndex = 0;
for (int i = 0; i < s.length(); i++) {
char current = s.charAt(i);
if (current == '(') {
if (cutOff) {
// System.out.println("Substring van HAKKE is " + s.substring(lastIndex, i));
parantheses.add(s.substring(lastIndex, i));
lastIndex = i;
cutOff = false;
}
counter++;
}
if (current == ')') {
counter--;
}
if (counter == 0) {
cutOff = true;
}
}
// for (int i = 0; i < s.length(); i++) {
// char current = s.charAt(i);
// if (current == '(') {
// if (cutOff) {
//// System.out.println("Substring van HAKKE is " + s.substring(lastIndex, i));
// parantheses.add(s.substring(lastIndex, i));
// lastIndex = i;
// cutOff = false;
// }
// counter++;
// }
// if (current == ')') {
// counter--;
// }
// if (counter == 0) {
// cutOff = true;
// }
// }
// System.out.println("Substring van HAKKE is " + s.substring(lastIndex, s.length()));
parantheses.add(s.substring(lastIndex, s.length()));
@@ -137,9 +138,9 @@ public class RegExp {
System.out.println(startRegExp.getTaal(maxOps));
RegExp retval = new RegExp();
ArrayList<String> strings = new ArrayList<>();
ArrayList<RegExp> toOf = new ArrayList<>();
ArrayList<String> strings = new ArrayList<>();
StringBuilder currentString = new StringBuilder();
for (int i = 0; i < start.length(); i++) {
char current = start.charAt(i);
@@ -231,10 +232,6 @@ public class RegExp {
return retval;
}
public RegExp removeUselessOperators(RegExp r) {
return null;
}
public RegExp parseString(String s) {
StringBuilder noSpacesString = new StringBuilder();
@@ -244,8 +241,291 @@ public class RegExp {
}
}
return splitOffInParenthesesGroups(noSpacesString.toString());
return naarRegExp(noSpacesString.toString());
}
public boolean hasEvenAmountOfParantheses(String s) {
int counter = 0;
for (int i = 0; i < s.length(); i++) {
char c = s.charAt(i);
if (c == '(') {
counter++;
}
if (c == ')') {
counter--;
}
}
return counter == 0;
}
public RegExpGroup splitsOpBasisVanHaakjes(String s) {
System.out.println("SplitsOpBasisVanHaakjes de string " + s);
ArrayList<String> haakjesList = new ArrayList<>();
ArrayList<RegExpGroup> regExpGroup = new ArrayList<>();
int counter = 0;
boolean cutOff = false;
int lastIndex = 0;
int leftLocation = -1;
int rightLocation = -1;
for (int i = 0; i < s.length(); i++) {
char current = s.charAt(i);
// We can look for |'s if we only have root parantheses
if (current == '(') {
if (cutOff) {
String sub = s.substring(lastIndex, i);
haakjesList.add(sub);
if (leftLocation != -1 && rightLocation != -1) {
regExpGroup.add(new RegExpGroup(Operator.PUNT,
new RegExpGroup(Operator.PUNT, s.substring(leftLocation + 1, rightLocation)),
new RegExpGroup(Operator.PUNT, s.substring(rightLocation + 1, i))
));
} else {
regExpGroup.add(new RegExpGroup(Operator.PUNT,
new RegExpGroup(Operator.PUNT, s.substring(lastIndex, i)),
null
));
}
lastIndex = i;
cutOff = false;
leftLocation = -1;
rightLocation = -1;
}
if (counter == 0) {
leftLocation = i;
}
counter++;
}
if (current == ')') {
counter--;
if (counter == 0) {
rightLocation = i;
}
}
if (counter == 0) {
cutOff = true;
}
}
haakjesList.add(s.substring(lastIndex, s.length()));
if (leftLocation != -1 && rightLocation != -1) {
regExpGroup.add(new RegExpGroup(Operator.PUNT,
new RegExpGroup(Operator.PUNT, s.substring(leftLocation + 1, rightLocation)),
new RegExpGroup(Operator.PUNT, s.substring(rightLocation + 1, s.length())
)));
} else {
regExpGroup.add(new RegExpGroup(Operator.PUNT,
new RegExpGroup(Operator.PUNT, s.substring(lastIndex, s.length())),
null
));
}
// System.out.println("Haakjesset");
// System.out.println(haakjesList);
// System.exit(1);
// regExpGroup.forEach(System.out::println);
ArrayList<RegExpGroup> test = new ArrayList<>();
for (RegExpGroup expGroup : regExpGroup) {
if (expGroup.left != null && expGroup.left.regex != null && expGroup.left.regex.contains("(")) { // if not done removing parantheses.
expGroup.left = splitsOpBasisVanHaakjes(expGroup.left.regex);
}
if (expGroup.right != null && expGroup.right.regex != null && expGroup.right.regex.contains("(")) {
expGroup.right = splitsOpBasisVanHaakjes(expGroup.right.regex);
}
test.add(expGroup);
}
RegExpGroup prev = null;
for (RegExpGroup regExpGroup1 : test) {
if (test.size() > 1) {
if (prev == null) {
prev = regExpGroup1;
continue;
}
if (prev.right == null) {
// we don't need to make a new one, we can just add it right.
prev.right = regExpGroup1;
} else {
prev = new RegExpGroup(Operator.PUNT, prev, regExpGroup1);
}
} else {
prev = regExpGroup1;
}
}
// System.out.println("TEST");
//// System.out.println(prev);
// prev.traverse();
return prev;
}
public RegExp loopDoorSegment(String s) {
for (int i = 0; i < s.length(); i++) {
System.out.println(s.charAt(i));
}
return null;
}
public RegExp loopRecursiefDoorString(String s, RegExp r) {
System.out.println("Loop door " + s);
RegExp retval = null;
int count = 0;
int begin = 0;
int eind = 0;
boolean cut = false;
boolean cutting = false;
StringBuilder sb = new StringBuilder();
for (int i = 0; i < s.length(); i++) {
char c = s.charAt(i);
if (c == '(') {
if (count == 0) {
begin = i + 1;
cutting = true;
}
count++;
}
if (c == ')') {
if (count == 1) { // if last count
eind = i;
cut = true;
cutting = false;
}
count--;
}
if (cut) {
String sub = s.substring(begin, eind);
String links = s.substring(0, begin - 1);
String rechts = s.substring(eind + 1, s.length());
System.out.println("L");
System.out.println(links);
System.out.println("M");
System.out.println(sub);
System.out.println("R");
System.out.println(rechts);
System.out.println("----");
// if (links.contains("(")) {
// loopRecursiefDoorString(links, r);
// }
// if (sub.contains("(")) {
// loopRecursiefDoorString(sub, r);
// }
// if (rechts.contains("(")) {
// loopRecursiefDoorString(rechts, r);
// }
retval = loopRecursiefDoorString(sub, r);
cut = false;
}
}
System.out.println("RETURN");
return retval;
}
public RegExp naarRegExp(String s) {
// String s is zonder spaces
RegExp retval = new RegExp();
// Als eerste moet de string in groupen gedeeld worden op basis van haakjes.
// bijv. "a+((ab)*b|ab|(b)*bb)+(abba|baab)+" naar ["a+", [ [["ab"], "*b"], ["ab"], [["b"], "*bb"], "+" ], [ ["abba", "baab"], "+"] ]
// Dit moet dan naar dit worden omgezet:
// a.plus().punt( (ab.ster().punt(b).of(ab).of(b.ster().punt(bb)).plus()) ).punt( abba.punt().baab.plus() )
// splitsOpBasisVanHaakjes(s);
System.out.println("We lopen door " + s);
RegExp r = loopRecursiefDoorString(s, new RegExp());
System.out.println(r.getTaal(20));
System.out.println("---");
// System.out.println("PRINTSTART");
//// r.traverse();
// System.out.println("PRINTEND");
// System.out.println("TEST");
// System.out.println(stringNaarRegExp("a|bb", new RegExp("b")).getTaal(10));
// System.out.println("----");
return retval;
}
public RegExp stringNaarRegExp(String s, RegExp initieel) {
ArrayList<RegExp> toDot = new ArrayList<>();
RegExp retval = new RegExp();
toDot.add(initieel);
for (int i = 0; i < s.length(); i++) {
char current = s.charAt(i);
RegExp prev;
switch(current) {
case '*':
prev = toDot.get(toDot.size() -1);
toDot.add(prev.ster());
toDot.remove(prev);
// System.out.println("STER");
break;
case '+':
prev = toDot.get(toDot.size() -1);
toDot.add(prev.plus());
toDot.remove(prev);
// System.out.println("PLUS");
break;
case '|':
default:
toDot.add(new RegExp("" + current));
// System.out.println("NEW CHAR");
break;
}
}
for (RegExp regExp : toDot) {
retval = retval.punt(regExp);
}
return retval;
}
private class RegExpGroup {
public Operator op;
public RegExpGroup left;
public RegExpGroup right;
public String regex = null;
public RegExpGroup(Operator op, String substring) {
this.op = op;
regex = substring;
}
public RegExpGroup(Operator op, RegExpGroup left, RegExpGroup right) {
this.op = op;
this.left = left;
this.right = right;
}
public boolean isOf() {
return this.op == Operator.OF;
}
public void traverse() {
System.out.println(this.regex);
if (this.left != null) {
// System.out.println("LEFT");
this.left.traverse();
}
if (this.right != null) {
// System.out.println("RIGHT");
this.right.traverse();
}
}
@Override
public String toString() {
return "(" + left + " -- " + regex + " -- " + right + ")";
}
}
public RegExp plus()