Frage wegen möglichem grouping-hack

pkm

pkm

Bekanntes Mitglied
Ich habe mal eine Regexfrage in Bezug auf reguläre Ausdrücke, welche ausschließlich Additionen / Multiplikationen umfassende Rechenoperationen ganzer Zahlen beschreiben sollen.

Z. B. soll "12*1+2=2" matchen, "12*1+A=2" und "12*1-2=2" nicht.


Code: 
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class Main {



public static void main(String[] args) {

String addition = "12*1+2=2";

Matcher m = Pattern.compile("[0-9]+[+|*][0-9]+([+|*][0-9]+){0,}=[0-9]+").matcher(addition);

if(m.matches()){

System.out.println("It matches.");
     }
   }
}



"[0-9]+[+|*][0-9]+([+|*][0-9]+){0,}=[0-9]+" bedeutet dabei Folgendes:

"Ein oder mehrere Zahlen gefolgt von Plus oder Mal gefolgt von ein oder mehreren Zahlen...

...dies kann ergänzt werden durch: Plus oder Mal gefolgt von ein oder mehreren Zahlen, und das 0 bis n mal."

Jetzt wollte ich das durch Klammern ergänzen, um etwa (2+3) * 7 zu prüfen.

Aber wie soll ich das schaffen? Denn ich weiß nicht, wie ich einem Ausdruck wie

"(\\()[0-9]+[+|*][0-9]+(\\))([+|*](\\()[0-9]+(\\))){0,}=[0-9]+"

die öffnenden und die schließenden Klammern aufeinander abstimmen soll. Damit meine ich: Wenn eine öffnende Klammer bei (2+3) * 7 vorhandne, ist, darf die schließende ja auch nicht fehlen, das muss aufeinander abgestimmt sein.

Kann man da mit irgendeinem grouping arbeiten, also gibt es da einen grouping hack oder ist all dies ein Ding der Unmöglichkeit?
 
Oben ist alles falsch.
pkm hat gesagt.:
welche ausschließlich Additionen / Multiplikationen umfassende Rechenoperationen ganzer Zahlen beschreiben sollen
Zum Vergrößern anklicken....
Die Eingabe habe ich verstanden, waber was soll die Ausgabe sein?

Wenn Klammern hinzukommen, würde man das stacken:
Java: 
        String string = "{while(true){print(arg[5]);}}";
        
        for (char c : string.toCharArray()) {
            int in = "({[)}]".indexOf(c);
            if (in >= 0) {
                if (in <= 2) {
                    al.add(c);
                    System.out.println("add " + c);
                } else {
                    if (al.isEmpty()) {
                        System.out.println("Falsch");
                        break;
                    }
                    if ("({[)}]".indexOf(al.get(al.size() - 1)) + 3 != in) {
                        System.out.println("Falsch");
                        break;
                    }
                    System.out.println("remove " + c);
                    al.remove(al.size() - 1);
                }
            }
        }
        if (!al.isEmpty()) {
            System.out.println("Falsch");
        } else {
            System.out.println("Richtig");
        }

Also soll nur richtig/falsch ausgegeben werden oder auch Berechnungen?
 
Hallo.

Auch wenn es kein Regex ist und auch nicht danach gefragt wurde.

Java: 
public static void main(String[] args) {

    System.out.println(isCalculationValid("2+2*3")); // true
    System.out.println(isCalculationValid("(2+2)*3")); // true
    System.out.println(isCalculationValid("2+A*3")); // false
    System.out.println(isCalculationValid("2+*3")); // false
}

private static boolean isCalculationValid(String calc) {
    ScriptEngineManager eng = new ScriptEngineManager();
    ScriptEngine se = eng.getEngineByName("JavaScript");
    try {
        // java.lang.System.out.print kann auch entfernt werden
        se.eval("java.lang.System.out.print(" + calc + ")");
    } catch (ScriptException e) {
        return false;
    }
    return true;
}

Grüße
 
Ich glaube auch nicht das es mit einen Regulären Ausdruck funktionieren wird. Und wenn ja, dann muss man echt ein crack sein. 🙂

Grüße
 
mrBrown hat gesagt.:
Du hast schon verstanden, dass nach einem Regex gesucht wird?
Zum Vergrößern anklicken....
Was soll dein Verhalten? Benimm dich mal....
Natürlich kann einfache Terme mit RegEx überprüft werden, aber es kommt ja noch eine unvollständige Infix klammerung hinzu, wenn ich das richtig aufgefasst habe.
Und ich denke, dann bist du mit deinem Wissen auch am Ende.
 
Eine verbesserte Version meines Vorschlags 🙂

Java: 
public static void main(String[] args) {

    System.out.println(isCalculationValid("2+2*3")); // true
    System.out.println(isCalculationValid("(2+2)*3")); // true
    System.out.println(isCalculationValid("(1+1)+1*1+(1*1)+(1*(123+1))=12")); // true

    System.out.println(isCalculationValid("2+A*3")); // false
    System.out.println(isCalculationValid("2+*3")); // false
    System.out.println(isCalculationValid("1+1)+1*1+(1*1)+(1*(123+1))")); // false
    System.out.println(isCalculationValid("1+1)+1*1+(1*1)+(1*(123+1))=123=12")); // false
}

private static boolean isCalculationValid(String calc) {

    if (isNotAllowedCharacterPresent(calc)) {
        return false;
    }

    int indexOf = calc.indexOf("=");
    String endOfCalc = null;
    if (indexOf > 0) {
        // =123 z. B
        endOfCalc = calc.substring(indexOf, calc.length());
        // ohne =123
        calc = calc.substring(0, indexOf);
    }

    ScriptEngineManager eng = new ScriptEngineManager();
    ScriptEngine se = eng.getEngineByName("JavaScript");
    Object result = null;

    try {
        result = se.eval(calc);
    } catch (ScriptException e) {
        return false;
    }
    // (\\=\\d) prüft =123
    return result != null && (endOfCalc == null || endOfCalc.matches("(\\=\\d+)"));
}

/**
* Prüft alle einzelene Zeichen ob diese erlaubt sind.
*
* @param calc
* @return wenn ein unerlaubtes Zeichen vorhanden dann False
*/
private static boolean isNotAllowedCharacterPresent(String calc) {
    if (calc == null) {
        return true;
    }

    String regex = "[\\d\\+\\-\\*\\/\\%\\)\\(\\=]";
    for (int i = 0; i < calc.length(); i++) {
        if (!calc.substring(i, i + 1).matches(regex)) {
            return true;
        }
    }
    return false;
}

Grüße
 
Die Existenz der Möglichkeit, Skripte einer Scriptengine zu übergeben, sehe ich als elegante Lösung des meiner Frage zu Grunde liegenden Problems! Vielen herzlichen Dank!
 
pkm hat gesagt.:
Die Existenz der Möglichkeit, Skripte einer Scriptengine zu übergeben, sehe ich als elegante Lösung des meiner Frage zu Grunde liegenden Problems! Vielen herzlichen Dank
Zum Vergrößern anklicken....
Du kannst Terme auch Java übergeben und Java Java parsen lassen....

RegExes sind hier das falsche Mittel, nochmal ich habe >nicht< verstanden was als gewünschte Ausgabe soll.
 
truesoul hat gesagt.:
Leider klappt der Regex nicht 100%. Ist eine offene klammer zu viel match der auch.
Aber man kann sicher die offenen und geschlossenen klammern zählen bevor man mit dem Regex prüft.
Zum Vergrößern anklicken....
Wo hast du eine offene Klammer hingesetzt, dass es trotzdem matched? 😕


pkm hat gesagt.:
Die Existenz der Möglichkeit, Skripte einer Scriptengine zu übergeben, sehe ich als elegante Lösung des meiner Frage zu Grunde liegenden Problems! Vielen herzlichen Dank!
Zum Vergrößern anklicken....
Bist du sicher? In den meisten Fällen ist das das uneleganteste und die können deutlich zu viel...

DerWissende hat gesagt.:
Du kannst Terme auch Java übergeben und Java Java parsen lassen....

RegExes sind hier das falsche Mittel, nochmal ich habe >nicht< verstanden was als gewünschte Ausgabe soll.
Zum Vergrößern anklicken....
Einfach nur, ob es ein gültiger Ausdruck ist, oder nicht.
Und wie du oben siehst klappt das durchaus mit Regex', nur halt nicht mit der Java RegEx-Engine.
 
Zuletzt bearbeitet:
mrBrown hat gesagt.:
Wo hast du eine offene Klammer hingesetzt, dass es trotzdem matched?

Und wie du oben siehst klappt das durchaus mit Regex', nur halt nicht mit der Java RegEx-Engine
Zum Vergrößern anklicken....

Ich habe eine Klammer entfernt (Anfang). Matched
Ich habe eine klammer hinzugefügt (Anfang). Matched
Ich habe z. B ...2+*3... in der Formel geschrieben. Matched

Es klappt also nicht.

🙂

Warum ist mein Beispiel unelegant?
Ich nutze das was mir Java bietet.


Grüße
 
Zuletzt bearbeitet:
Wenn es also nur um die Klammern geht: (das hatte ich noch in der Schublade liegen von einem anderen Thema)
Java: 
    public static void main(String[] args) {
        System.out.println(KlammernIO("{while(true){print(arg[5]);}}"));
        System.out.println(KlammernIO("{while(true){p}rint(arg[5]);}}"));
    }

    static boolean KlammernIO(String string) {
        ArrayList<Character> al = new ArrayList<>(); // ArrayList agiert hier als Stack
        for (char c : string.toCharArray()) {
            int in = "({[)}]".indexOf(c);
            if (in >= 0) {
                if (in <= 2) {
                    al.add(c);
                } else {
                    if (al.isEmpty()) {
                        return false;
                    }
                    if ("({[)}]".indexOf(al.get(al.size() - 1)) + 3 != in) {
                        return false;
                    }
                    al.remove(al.size() - 1);
                }
            }
        }
        if (!al.isEmpty()) {
            return false;
        }
        return true;
    }

Wenn es aber um den kompletten Term mit + und * usw. geht dann müssen die Operanden usw. auch noch gestackt werden (also das, was keine Klammer ist).
 

Aktuelle Jobs

Neue Themen

Ähnliche Themen

Methode Grouping mit Werten ausgeben
Antworten: 2
Hilfe Regular Expression Grouping Value
Antworten: 3
Fieser Hack.
Antworten: 3
Spiele Hack in Java ?
Antworten: 18
Frage wegen Heap-Speicher
Antworten: 2

Zurück
Oben