Satzarten bestimmen

Hi zusammen,

gerade erst fange ich an Java zu lernen, daher bin ich noch nicht gerade ein guter Programmierer. Als kleines Einsteigerprojekt bin ich gerade dran ein Programm zu schreiben, dass Satzarten unterscheiden kann. Es funktioniert auch schon, allerdings denke ich, dass mein Code nicht gerade gut ist. Daher bin ich dankbar, wenn ich ein paar Tipps bekomme wie ich es besser machen kann. Es fehlen auch noch einge Verben, und ich muss auch noch eine Unterscheidung, die Wunschsätze, hinbekommen.

public class Satzarten {
    
      
     
     public static void main(String[] args) {
    
        Scanner keybord = new Scanner(System.in);
        String satz = keybord.nextLine();
                       
        System.out.print(satzart(satz));
    }
    
     private static  String satzart(String satz){
       
       String satzZeichen = satz.substring(satz.length()-1);
       String[] parts = satz.split("\\s", 3);
       String satzAnfang = parts[0];
       String satzposition2 = parts[1];
        
       String[] wFragen={"wessen", "wer", "wie", "welche", "was", "wem", "wann", "wo", "wohin", "weshalb", "wieso", "warum", "weswegen", "inwiefern", "inwieweit"};
       String[] verb={"geh"};
       
       String satzart = null;
              
        if (satzZeichen.equals("?"))
        
               if (java.util.Arrays.asList( wFragen ).contains( satzAnfang )){
                 satzart = "Ergaenzungsfrage";
                }
                else {
                 satzart = "Ja/Nein Frage";  
                }
        
        else 
        {
             if (java.util.Arrays.asList( verb ).contains( satzposition2 )){  
                satzart = "Aufforderung"; 
             }
             else {
                         
            satzart = "Aussage";
        }
      }
       return satzart; 
       
     }
}
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        System.out.println("Satz eintippen:");
        String satz = br.readLine();
        StringBuilder regex = new StringBuilder();
        for (char c = 33; c <= 47; c++) {
            regex.append(c);
        }
        for (char c = 58; c <= 59; c++) {
            regex.append(c);
        }
        for (char c = 63; c <= 63; c++) {
            regex.append(c);
        }
        Matcher m1 = Pattern.compile("([\\wäöüßÄÖÜ]+)([" + regex + "]*)").matcher(satz);
        ArrayList<String> teile = new ArrayList<String>();
        while (m1.find()) {
            teile.add(m1.group(1));
            if (!m1.group(2).isEmpty()) {
                teile.add(m1.group(2));
            }
        }
        System.out.println("teile = " + teile);

        if (teile.get(teile.size() - 1).equals("?")) {
            if ("wessen wer wie welche was wem wann wo wohin weshalb wieso warum weswegen inwiefern inwieweit".contains(teile.get(0))) {
                System.out.println("Ergaenzungsfrage");
            } else {
                System.out.println("Ja/Nein-Frage");
            }
        } else if (true) {
            System.out.println("Aufforderung");
        } else {
            System.out.println("Aussage");
        }

    }```

2 - 4 liest einen Satz ein,
5 - 14 erstellt einen regulären Ausdruck mit möglichen Satzzeichen (ohne whitespaces),
15 - 22 teilt den Satz auf in alle Wörter und Satzzeichen,
23 - 24 Kontrollausgabe (leere Liste ist an dieser Stelle möglich),
25 - 35 Deine Geschäftslogik an dieser Stelle,
36 - 37 Ende der "main"-Methode.

Ohne ein Wörterbuch und alle Konjugationen kommst du an dieser Stelle nicht weit.

Alternative: ```        ArrayList<String> teile = new ArrayList<String>();
        teile.addAll(Arrays.asList(satz.split(regex)));```

*** Edit ***

Ich hab' Dir das mal in OOP gebracht:

```/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package javaapplication1;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

/**
 * @author ikwudls
 */
public class Saetze {

    private static final String[] FRA = "wessen wer wie welche was wem wann wo wohin weshalb wieso warum weswegen inwiefern inwieweit".split(" ");
    static {
        Arrays.sort(FRA);
    }
    private static final String REG;
    static {
        StringBuilder satzzeichen = new StringBuilder();
        for (char c = 33; c <= 47; c++) {
            satzzeichen.append(c);
        }
        for (char c = 58; c <= 59; c++) {
            satzzeichen.append(c);
        }
        for (char c = 63; c <= 63; c++) {
            satzzeichen.append(c);
        }
        REG = "([\\wäöüßÄÖÜ]+)([" + satzzeichen + "]*)";
    }
    private static final Pattern PAT = Pattern.compile(REG);
    private static final BufferedReader BR = new BufferedReader(new InputStreamReader(System.in));
    
    private final ArrayList<String> satz = new ArrayList<String>();

    public Saetze(String satz) {
        Matcher m = PAT.matcher(satz);
        while (m.find()) {
            for (int i = 1; i <= m.groupCount(); i++) {
                if (!m.group(i).isEmpty()) {
                    this.satz.add(m.group(i));
                }
            }
        }
        if (satz.isEmpty()) {
            throw new IllegalArgumentException("empty: " + satz);
        }
    }

    public boolean istFrage() {
        return satz.get(satz.size() - 1).equals("?");
    }

    public boolean istErgaenzungsfrage() {
        return istFrage() && Arrays.binarySearch(FRA, satz.get(0)) != -1;
    }

    public boolean istJaNeinFrage() {
        return istFrage() && !istErgaenzungsfrage();
    }

    public boolean istAufforderung() {
        throw new UnsupportedOperationException();
    }

    public boolean istAussage() {
        throw new UnsupportedOperationException();
    }

    public boolean istXyz() {
        throw new UnsupportedOperationException();
    }

    public static String gibSatz() {
        System.out.println("Satz eintippen:");
        String satz = null;
        try {
            satz = BR.readLine();
        } catch (IOException ioe) {
            System.out.println("ioe = " + ioe);
        }
        if (satz == null || satz.isEmpty()) {
            satz = ".";
        }
        return satz;
    }

    public static void main(String[] args) {
        Saetze s = new Saetze("Der Hund lief über die Straße, als der Ball kam?");
        System.out.println(s.satz);
        System.out.println("istJaNeinFrage = " + s.istJaNeinFrage());
    }
}```

An dieser Stelle verlassen mich aber meine orthographischen Kenntnisse.

Unabhängig von der Tiefe, in die man da gehen könnte (Grammatik, Groß/Kleinschreibung, Wortlisten, weitere Unterscheidungen von Satzarten) war das im Eröffnungspost IMHO nicht verkehrt. Solche Details, wie dass man statt

String[] wFragen={"wessen", "wer", "wie", "welche", "was", "wem", "wann", "wo", "wohin", "weshalb", "wieso", "warum", "weswegen", "inwiefern", "inwieweit"};
... 
if (java.util.Arrays.asList( wFragen ).contains( satzAnfang )){

gleich schreiben könnte

Collection<String> wFragen= Arrays.asList("wessen", "wer", "wie", "welche", "was", "wem", "wann", "wo", "wohin", "weshalb", "wieso", "warum", "weswegen", "inwiefern", "inwieweit");
... 
if (wFragen.contains( satzAnfang )){

könnte man noch erwähnen, aber sonst… joa.

OK, ich hab noch nie was von Objektorientierung gehört, wie ich merke.

Man könnte einfach eine Klasse Satz haben. Der Satz besteht aus Worten und einem Satzzeichen.

public class Satz{
  List<String> worte;
  String satzZeichen;
}```


Dann könnte man sich überlegen, dass man diesen Satz auf Eigenschaften hin untersucht. Dafür könnte man sich überlegen ein Interface Predicat erstellen.
Dieses erhält einen Satz und liefert zurück ob es zutrifft oder nicht.

public interface Predicat {
boolean trifftZu(Satz satz);
}```

Ein konkretes Predikat könnte dann lauten endetMitFrageZeichen

public class EndetMitFrageZeichen implements Predicat {
  public boolean trifftZu(Satz satz){
    return "?".equals(satz.satzZeichen);
  }
}

Da nun Predikate vorhanden sind kann man sich überlegen auch noch eine Klasse Satzart zu erstellen. Eine Satzart ist eigentlich nur eine Menge aus Predikaten und vielleicht einem Namen der die Satzart beschreibt.

public class Satzart{
  List<Predicat> predicate;
  String name;
  
  public boolean trifftZu(Satz satz){
    for(Predicat p: predicate){
      if(!p.trifftZu(satz)){
        return false;
      }
    }
    return true;
  }
}```

Nun braucht man nur noch alle Satzarten zu definieren und in einer Liste zusammenfassen. Diese geht man dann der Reihe nach durch bis man auf eine Satzart trifft die auf einen Satz zutrifft.


```for(Satzart sArt: satzArten){
  if(sArt.trifftZu(satz)){
    System.out.println(sArt.name);
  }
}```

Vielen Dank fuer die vielen Antworten.

Du hast Dir sehr viel Aufwand gemacht iKnwWhtUDidLast, ich danke Dir. Ich konnte Deinen Code dank Deiner guten Erklaerung problemlos nachvollziehen und habe ihn auch ausprobiert. Fuer einige Testsatze haben Dein Code und meiner die selben Ausgaben gebracht und gleich lang gebraucht (15 Sekunden). Ich gehe davon aus, dass Dein Code qualitativ besser ist als meiner, und Du ihn deshalb aus gutem Grund gepostet hast, daher wuerde ich Dich bitten mir kurz mitzuteilen was ihn besser macht. Nur wenn ich weiss, wo meine Programmierlogik noch ein wenig harkt, kann ich mich verbessern.

Vielen Dank auch an Dich Marco13. Ich hab’s geaendert und geistig notiert, dass es auch einfacher zu schreiben ist.

			 Auch Dir vielen Dank [**Majora**](http://forum.byte-welt.net/members/1510-Majora). Dein Ansatz klingt interessant.

Ohne ein Wörterbuch und alle Konjugationen kommst du an dieser Stelle nicht weit.

Da hast Du wohl recht. Ich habe das am Anfang nicht bedacht. Das ganze mit String Arrays zu machen, waere wohl ziemlich aufwendig. Gibt es da vielleicht ein fertige Bibliothek, die ich irgendwie einbinden koennte?

Ein Ansatz für den letzen Punkt könnte Stemming sein http://de.wikipedia.org/wiki/Stemming . Man versucht also gar nicht, alle Formen
denke, denkst, denken, denken, denkt, denken
dachte, dachtest, dachte, dachten, dachtet, dachten

abzubilden, sondern den umgekeherten Weg: Das auf einen gemeinsamen Wortstamm zurückzuführen. Für das Porter-Stemming gibt’s AFAIK auch ein paar Java-Implementierungen, ggf. mal websuchen.

Hallo und danke.

Ich haette noch eine Frage: Ich moechte Versuchen, dass das Programm eine Antwort ausgibt, dafuer habe ich fuer die Ja/Nein-Frage das hier gebalstelt.

Java Code:

[ol]
[li] [/li]
[li] static String jaNeinFrage(String satzAnfang ){[/li]
[li] [/li]
[li] boolean jaNein = true;[/li]
[li] String jaNeinFrage; [/li]
[li] [/li]
[li] if ( jaNein == true) {[/li]
[li] jaNeinFrage = (“Ja”);[/li]
[li] }[/li]
[li] else {[/li]
[li] jaNeinFrage = (“Nein”);[/li]
[li] } [/li]
[li] [/li]
[li] return jaNeinFrage; [/li]
[li] }[/li][/ol]

Ich wuerde es gerne automatisieren, dass das Programm auf eine Ja/Nein Frage eine Antwort bastelt:
Beispiel: “ist wasser nass?”

Mein jaNein-String sollte nun die Antwort: “ja, wasser ist nass.” ausgeben.

Bei 3 Worten ist das ja auch kein Problem, da in der Hauptklasse der String mittels String[] parts = satz.split("\s", 3) in drei Teile geteilt wird. Doch ich moechte auch gerne andere Ja/Nein Fragen abfischen mit einer unbekannten Anzahl an Woertern wie z.B:
“ist das blaue Haus schoen?” oder “ist Pizza mit Gorgonzola besser lecker?”

Wie kann ich hier vorgehen um den Sting zu unterteilen?

[QUOTE=Abholschein]Ich wuerde es gerne automatisieren, dass das Programm auf eine Ja/Nein Frage eine Antwort bastelt:
Beispiel: “ist wasser nass?”[/QUOTE]
Dazu müsste Dein Programm ersteinmal die Frage “verstehen” und zweitens die Antwort kennen? Woher weiß das Programm, dass Wasser nass ist? Oder noch subjektiver, dass das blaue Haus schön und die Pizza lecker ist?

Wie unterteilen? Allgemein bietet die Klasse String verschiedene Methoden Strings zu unterteilen: substring, split. Letztere verwendest Du ja bereits.

Hallo _Michael und vielen dank fuer Deine schnelle Antwort.

[QUOTE=_Michael;63615]Dazu müsste Dein Programm ersteinmal die Frage “verstehen” und zweitens die Antwort kennen? Woher weiß das Programm, dass Wasser nass ist? Oder noch subjektiver, dass das blaue Haus schön und die Pizza lecker ist?
[/QUOTE]

Es ist ja nur eine kleine Spielerei um ein wenig Programmiererfahrung zu sammeln und laeuft mittels boolean. Natuerlich hast Du recht und das sind Fragen mit denen Java nicht viel anfangen kann und das ganze hat inhaltlich wenig nutzen. Im Kern geht es mir darum, dass das Programm weiss, dass es eine Ja/Nein Frage ist und aus dieser die entsprechende Antwort bastelt, je nach dem ob true oder false mit oder ohne negation.

[QUOTE=_Michael;63615]Wie unterteilen? Allgemein bietet die Klasse String verschiedene Methoden Strings zu unterteilen: substring, split. Letztere verwendest Du ja bereits.
[/QUOTE]

Wie gesagt funktioniert meine Unterteilung im Grundsatz fuer diese Aufgabenstellung ja wunderbar, so wird aus:
ist das so?” ohne Probleme “das ist so”. Wenn ich jedoch mehr als drei Woerter benutze (z.B. “ist das denn wirklich so?”) jedoch logischerweise nicht mehr. Mein Problem ist, und damit wollte ich mit den Beispielsatzen hinaus, dass der Eingabestring eine unbekannte Anzahl an Worten enthaelt.

OK, aber das geht hinsichtlich Komplexität weit über die Anzahl der Wörter im Satz hinaus.
Bei einfachen Frage wie “ist das so?” oder “ist das wirklich so?” muss man ja nur die ersten zwei Worte (Verb und Subjekt) vertauschen. Bei negativier Antwort noch ein “nicht” nach dem Verb einschieben.
Wenn man jetzt Dein zweites Beispiel “ist das denn wirklich so?” Wäre die Antwort ebenfalls “Ja (Nein), das ist (nicht) wirklich so!” Das “denn” würde hier komplett entfallen. Um das zu erkennen bräuchte das Programm schon eine tieferer Kenntnis der Grammatik.
Eine andere Komplexität wäre z.B. “ist er ein Held?” Positiv beantworten wäre hier kein Problem, im negativen Fall müsste man aber statt “nicht” einzufügen aus “ein” ein “kein” machen.
Evtl. lassen sich solche Fälle ja pauschal handhaben: “denn” nach dem Subjektiv wird grundsätzlich gestrichen. Aus “ein(e)” wird bei negativer Antwort “kein(e)”.
Je nach Komplexität der Frage gilt es aber eine Menge Regeln zu beachten…

Kann man (denn) die Komplexität der Fragen irgendwie begrenzen?
So dass eine einfache Änderung der Reihenfolge von Verb und Subjekt zu Subjekt und Verb und ggf. Ergänzung von “nicht” ausreicht.
Warum willst Du ausgerechnet mit so etwas “Programmiererfahrung sammeln”?

Hmja, vielleicht sollte man nochmal betonen, dass das ziemlich kompliziert (und in letzter Konsequenz auch unmöglich) ist. Natürlich kann man den Satz analysieren, Subjekt, Prädikat, Objekt, bestimmte Strukturen und Muster, da wurde (und wird) viel dran geforscht und es gibt einige Ergebnisse. Aber solange wir nicht alle http://de.wikipedia.org/wiki/Lojban reden, wird Sprache immer mehrdeutig bleiben.

Gute Frage. Die Idee kam mir einfach so. Da ist vieles drin, wie If/Else, Listen, Das Umstellen von Eingaben,… Ich verfolge damit keine hoehreren Zielen wenn Du das meinst.

[QUOTE=_Michael;63626]
Bei einfachen Frage wie “ist das so?” oder “ist das wirklich so?” muss man ja nur die ersten zwei Worte (Verb und Subjekt) vertauschen. Bei negativier Antwort noch ein “nicht” nach dem Verb einschieben.[/QUOTE]

Genau. So weit ist das ganze mit dem splitt eines Stings in drei Teile auch noch kein Problem.

[QUOTE=_Michael;63626]
Wenn man jetzt Dein zweites Beispiel “ist das denn wirklich so?” Wäre die Antwort ebenfalls “Ja (Nein), das ist (nicht) wirklich so!” Das “denn” würde hier komplett entfallen. Um das zu erkennen bräuchte das Programm schon eine tieferer Kenntnis der Grammatik.[/QUOTE]

Stimmt. Das Beispiel mit dem “denn” war eher schlecht von mir gewaehlt, da es mit dem was ich aussagen wollte nicht entspircht. Dennoch ist es gut, dass Du mich darauf aufmerksam machst. Denn, ein “denn” kommt in Fragen oft vor. Aber zum Glueck laesst es sich rausloeschen.

[QUOTE=_Michael;63626]
Eine andere Komplexität wäre z.B. “ist er ein Held?” Positiv beantworten wäre hier kein Problem, im negativen Fall müsste man aber statt “nicht” einzufügen aus “ein” ein “kein” machen. Evtl. lassen sich solche Fälle ja pauschal handhaben: “denn” nach dem Subjektiv wird grundsätzlich gestrichen. Aus “ein(e)” wird bei negativer Antwort “kein(e)”.[/QUOTE]

So sehe ich das auch. Nur die Pauchale Hanhabung macht mir schwierigkeiten. String[] parts = satz.split("\s", 3); Teilt den Satz in drei Teile. Hat der Satz aber vier Teile, wie bei dem von Dir angsprochenen “Ist er ein Held?” klappt das nicht.

Mein wichtigstes Ziel ist es daraus etwas zu lernen. Wenn das Programm am Ende nicht viel mit extrem komplexen Fragestellungen klarkommt ist das weder tragisch noch ein Problem. Die Antwort ist ja auch nicht hilfreich, sondern true/false. Es waere nur schoen, wenn er simple Ja/Nein-Fragen “beantworten” kann, unabhaenig davon ob die Frage “Ist es weit?” oder “Ist es bis zu dem heutigen Ausflugsziel weit?” lautet.

Bei solchen Fragen ist eine Begrenzung des splits auf drei nicht unbedingt notwendig und könnte ja einfach allgemein satz.split("\\s") gehalten werden. Wenn die Frage aber immer aus nur einem Verb und einem Subjekt besteht, ist die „Dreiteilung“ doch völlig ausreichend.
Die Anwort setzt sich ja dann in der Indexreihenfolge 1, 0, (ggf. ein nicht), 2 ohne Fragezeichen (und ggf. ohne denn) zusammen.

*** Edit ***

Wobei im Fall von „Ist es bis zu dem heutigen Ausflugsziel weit?“ die Schwierigkeit darin besteht zu erkennen, dass das „ist“ hier reflexiv ist und „weit“ noch zum Verb gehört.
Man sieht, das ist ein Fass ohne (zumindest bis jetzt erkennbaren) Boden.

*** Edit ***

Noch ein Nachtrag :wink:
Einfacher wäre eine verkürzte Antwort nur mit Verb und Subjekt ohne Tausch der Reihenfolge
„Ja, ist es“ oder „Nein, ist es nicht“

Willst du … … nicht alle Fälle berücksichtigen? (Was willst du?)
Willst du nicht … … alle Fälle berücksichtigen? (Was willst du nicht?)
Willst du … nicht alle … Fälle berücksichtigen? (Willst du alle berücksichtigen, oder nicht alle?)
Da sich schon die meisten Menschen um solche Feinheiten einen Dreck zu scheren scheinen, braucht man sie in einem Programm vielleicht gar nicht zu berücksichtigen, aber … man sollte sie IMHO im Hinterkopf haben :wink:

Das was du da vorhast ist im Bereich Text Mining angesiedelt und der ist schon ziemlich komplex. Was ich dir dafür empfehlen kann, ist der TreeTagger (http://www.ims.uni-stuttgart.de/forschung/ressourcen/werkzeuge/treetagger.html) der da schon viel Vorarbeit leistet. Damit hast du schonmal zu einem ziemlich hohen Prozentsatz die Richtige Bezeichnung für ein Wort, also ob Nominativ, Personalpronomen, Adverb etc. Aber dann geht es natürlich noch deutlich weiter. Trotzdem kannst du da schon die “Hauptwörter” mit rausfinden. Zum TreeTagger gehört ein Chunker den du mit den passenden Listen füttern musst. Hier ganz gut beschrieben: http://www.neumann.biz/data_munging/tree_tagger

Mittlerweile habe ich mich mal an die Antwort auf Ja/Nein Fragen gemacht. Zum einen hat das ganze wahrscheinlich einigen schlechten Code, daher wuerde ich mich freuen, wenn mir jemand sagen koennte, wo es noch harkt.

Dazu ist das Programm auch nur wenig ausgereift und kann lediglich Saetze mit folgender Reihenfolge umstellen: Verb + Angabe + Nomen. Selbst Artikel (ein Hund) und Ausdruecke (deutscher Fussballmeister) kann es noch nicht umstellen. Ihr habt mich ja gewarnt, dass da einiges auf mich zukommt. Ueber Tipps, egal welcher Art wuerde ich mich sehr freuen.

Die String Arrays mit den verben sind nur professorisch, bevor ich mich in einen Tagge einarbeite, will ich erstmal die Grundlagen gut genug hinbekommen und das Programm grundsaetzlich laufen lassen.

public class JaNein_Frage {
    
     private static String antwort (String test1) {
    
        String test2 = test1.replaceAll("[\\\\.,-/?]", "");
        String[] test3 = test2.split("\\s");
        String satzEnde = (test3[test3.length-1]);
        String satzBeginn = test3[0];
        
        String satzMitteTemp = test2.replaceAll((satzBeginn) , "");
        String satzMitte = satzMitteTemp.replaceAll((satzEnde) , "");
        
        Collection<String> konjungiertesVerb= Arrays.asList("liebt", "wird", "hat", "gehen" );
        
        String antwort;
        
        if (konjungiertesVerb.contains(test3[0])){
                antwort = ("ja," + satzMitte + satzBeginn + " " + satzEnde +".");
       }
        else
            antwort = ("hier ist noch nix");
        
        return antwort;
    
        }        
  public static void main (String [] args){
        
        String test1 = "liebt Flos Frau kekse?"; 
        System.out.println(antwort(test1)); 
             
  }

Ganz so ausgereift ist mein Versuch dann leider doch noch nicht. Auf Fragen wie: Ist Erdbeereis Eis? Antwortet es: Ja, erdbeer ist eis.

String[] test3 = test2.split("\\s");
        String satzEnde = (test3[test3.length-1]);
        String satzBeginn = test3[0];
        
        String satzMitteTemp = test2.replaceFirst((satzBeginn) , "");
        String satzMitte = satzMitteTemp.replace((satzEnde) , "");

Das würde mich sehr wundern. Dann beherrscht das Programm jetzt auch Silbentrennung und lässt einzelne Silben weg?
Wenn Ist in der Collection (die würde ich statisch ausserhalb der Methode deklarieren) aufgenommen wurde, sollte es doch soweit passen.
Dann würde auf Ist Erdbeereis Eis? mit Ja, Erbeereis Ist Eis. geantwortet. Problematisch wäre aber immer noch sowas wie Ist Erdbeereis ein Milcheis?

Allgemein würde ich auf Variablenbezeichner test1, 2, 3… verzichten (selbst zum Testen) - ggf. auch auf temporäre Variablen mit einem Scope von zwei Zeilen.
z.B:

	frage = frage.replaceAll("[\\\\.,-/?]", "");
	String[] woerter = frage.split("\\s");
	String satzEnde = (woerter[woerter.length - 1]);
	String satzBeginn = woerter[0];```
Die Satzmitte könnte man auch so erzeugen:
`String satzMitte = frage.replaceAll(satzBeginn, "").replaceAll(satzEnde, "");` oder `String satzMitte = frage.replaceAll(satzBeginn + "|" + satzEnde, "");`

Hallo _Michael,

vielen Dank fuer Deine Muehe die Du Dir mit mir machst.

Das würde mich sehr wundern. Dann beherrscht das Programm jetzt auch Silbentrennung und lässt einzelne Silben weg?

Du hast zwar recht, dass auf die Frage: Ist Erdbeereis Eis? die Antwort Ja, Erbeereis Ist Eis. kommt. Fragt man jedoch ist erdbeereis eis? folgt die Antwort Ja, erbeer ist eis…

Deine restlichen Anregungen und Codeverbesserungen habe ich uebernommen. Vielen Dank.

Gibt es es soetwas wie ReplaceLast?