Quantorenfunktionen von natürlicher Sprache in eine formale Darstellung und zurück umwandeln?

Hallo ich brauche Hilfe bei einer Aufgabe:

Es sollen Quantorenfunktionen von natürlicher Sprache in eine formale Darstellung und zurück umgewandelt werden. Dabei entspricht
  • Ax = for all x
  • Ex = there is a x so that
  • NAx = not for all x
  • NEx = there is no x so that
x steht immer für eine Variable, Variablennamen können sein: x, y, z, u, v, w, ... Am Ende steht immer ein Prädikat P. NP steht für dessen Negierung.


Schreiben Sie eine Funktion
public static String formalize (String expr)
die expr von der natürlichen Darstellung in die formale Darstellung verwandelt und das Ergebnis zurückgibt, sowie
public static String naturalize (String expr)
die expr von der formalen Darstellung in die natürliche Darstellung verwandelt. Sie können dazu alle Methoden der Klasse String verwenden, vor allem replace, substring und indexOf.
Beispiel
Die Befehle
String expr = formalize ("not for all x there is a y so that for all z there is no w so that not P");
System.out.println (expr);
System.out.println (naturalize (expr));
sollen folgende Ausgabe erzeugen:
NAxEyAzNEwNP
not for all x there is a y so that for all z there is no w so that not P
Schreiben Sie auch eine main-Funktion, die die Funktionen testet.

Meine Frage: Wie mach ich das mit der Variable x bzw y z w P?

Bzw kann mir jmd ein Beispiel geben wie so ein Code aussehen soll?
 
Schöne Aufgaben, dafür sind Regex perfekt!
Mit String-Methoden würde ich wohl folgendes machen: indexof nach "for all ", dann hat du schon den Index auf die Variable (Index plus Länge vom Suchstring), testen, ob dort noch was kommt, es kann ein Eingabeformatfehler sein. Du kannst einen zweiten String aufbauen, in dem du das Ergebnis reinschreibst.
Die anderen im Prinzip genauso.
 
Also Du kannst doch einfach nach den festen Begriffen suchen und diese ersetzen. Die Variablen sind dann einfach ein beliebiges Zeichen (von mir aus einer bestimmten Menge).

Als erstes scheint es hier um eine einfache Ersetzung der Ausdrücke von links nach rechts zu geben, so dass man den String entsprechend durchgehen kann.
Also bei naturalize prüfst Du:
- fängt der String mit A an? Dann ersetze es mit "for all" + folgender Buchstabe + " "
- fängt der String mit E an? Dann ersetze es mit "there is a " + folgender Buchstabe + " so that "
- ...
- ist es nichts von Allem, dann war es eine fehlerhafte Zeichenkette.
Und dann den restlichen String betrachten, bis man am Ende ist.

Bei formalize geht es genau den anderen Weg.

Das Ganze lässt sich auch per regulärem Ausdruck lösen. Beim Suchen muss man die Variable in eine Gruppe nehmen um dann im Replace String dann auch die Gruppe zu nutzen.

Wer es ganz speziell möchte, könnte dies auch als Compiler betrachten. Dann würde man das einfach einmal parsen und dann im Folgenden "übersetzen", was ich aber hier mehr als "Mit Kanonen auf Spatzen schießen" bezeichnen würde.
 
also ich hab das jetzt mal so gemacht:

public static void main (String[] args){
String expr = "not for all x there is a y so that for all z there is no w so that not P";

String formalize = expr.replace("not for all", "NA") .replace("there is a", "E")
.replace("for all","A") .replace ("there is no", "NE")
.replace("so that", "") .replace ("not","N") .replace(" ","");



System.out.print(formalize);

}

nur ich weiß nicht ganz wie ich das dann als Methode / Funktion schreibe
 
Also die Methode könntest du einfach so schreiben, dass exp per Parameter kommt und statt das Ergebnis zuzuweisen hättest Du dann ein Return.

ABER: Du fängst keine Fehler ab. Wenn da etwas ungültiges gegeben wird, gibst du ein Ergebnis aus. Das ist so aus meiner Sicht nicht unbedingt korrekt.
 
Java:
public class Bsp04{
   
   public static void main (String[] args){
   
     
     
      String expr = formalize("not for all x there is a y so that for all z there is no w so that not P");
           
      System.out.println(expr);
      System.out.println(naturalize(expr));  
   }
   
   public static String formalize (String expr){
     
      String formalize = expr .replace("not for all","NA").replace("there is no","NE").replace("for all", "A") .replace("there is a","E")
                              .replace("so that","") .replace("not","N").replace(" ","");
     
      return formalize;
   }
   
   public static String naturalize (String expr){
     
     
      while(expr.indexOf("NE")!=-1){
         int pos = expr.indexOf("NE");
         expr = expr.substring(0,pos) + " there is no "
         +expr.substring(pos+2,pos+3)+" so that "
         +expr.substring(pos+3);
      }            
      while(expr.indexOf("E")!=-1){
         // NAxEyAzNEwNP
         int pos = expr.indexOf("E");
         expr = expr.substring(0,pos) + " there is a "
         +expr.substring(pos+1,pos+2)+" so that "
         +expr.substring(pos+2);
         
      }
      expr = expr.replace("NA","not for all ").replace("A","for all ").replace("N","not ");
     
      return expr;
   }
}
jetzt ist mein problem, dass das programm bei manchen kombinationen zu viele bzw zu wenig leerzeichen macht?
 
Zuletzt bearbeitet von einem Moderator:
Also wir haben noch andere Probleme gesehen, aber wenn Dich an Deiner Lösung nur doppelte Leerzeichen stören:
A) Du kannst analysieren, wo du wann Leerzeichen einfügst um das zu vermeiden.
B) Du kannst doppelte Leerzeichen durch ein Leerzeichen ersetzen.
 
Passende Stellenanzeigen aus deiner Region:

Oben