# Deterministischer endlicher Automat



## wintermutant (7. Jan 2017)

Hallo Leute,
ich habe muss einen DEA programmieren, dieser soll überprüfen ob ein vorgegebenes Eingabewort korrekt ist und dann ein Ergebnis ausgibt.
Die Eingabe und Ausgabe soll mit Klasse JoptionPane stattfinden.
Die Eingabezeichen sind [ O , - , 4 , i ]
Der gesamte Programmablauf soll in der Methode public static void main entahlten sein.
ich habe schon mal so angefangen, weiß aber nicht ob ich auf dem richtigen Weg bin:

```
import javax.swing.JOptionPane;
public static void main(String[] args){
String w = JOptionPane.showInputDialog("Eingabewort(4 Zeichen)");
char[] s = w.toCharArray();

int z = 0;
for (int i = 0;i>4;i++){
switch (z) {
case 0 : if (s[i]=='O')
z = 3;
else if (s[i]=='-')
z =2;
else if ((s[i]=='4')
z= 2;
else if (s[i]=='i')
z=0;
case 1......
```


----------



## Flown (7. Jan 2017)

Code bitte immer in code tags setzen:[code=java]//JAVA CODE HIER [/code]


----------



## knilch (8. Jan 2017)

Hi,
Zu deinem Ansatz:

```
for (int i = 0;i>4;i++){
...
}
```
Dies ist so nicht brauchbar. Schau mal in der Dokumentation nach, wie das mit for-loop umgesetzt wird.

Generell würde ich das mal so angehen:
1. Prüfung ob der Benutzer den String richtig eingegeben hat: Das heisst, ist die Länge von String richtig? 4 Zeichen? Sind die Charater im String nur die zugelassenen? 'O', '-', '4' oder 'i'
Wenn der String dann ok ist, kann dann geprüft werden, ob der String mit Z3 terminiert.

Der Startwert ist nach Aufgabe 1
Da sich der Zustand ändert, je nachdem was für ein charakter-Wert vorhanden ist, musst du für jeden Charater vom String die Prüfung durchführen:
- ist charater ein 'O', '-', '4' oder 'i'
- für diese 4 Fälle wird dann mit einem Switch-statement der Zustand verändert.
Wenn am Ende der Zustand 3 (Z3) erreicht wird, so ist der eingegbene String im Alphabet enthalten, sonst nicht.
Hier mal ein Ansatz:

```
public class Dea {

   /*
    * Definition Deterministischer endlicher Automat
    * Zustaende:        [Z0, Z1, Z2, Z3, Z4]
    * Startzustand:   Z1
    * Endzustände:       [Z3]
    * Eingabezeichen:   [O, -, 4, i]
    * (Zustand,Zeichen) -> Folgezustand;...
    * (Z0,O)->Z3; (Z0,-)->Z2; (Z0,4)-> Z2; (Z0,i)->Z0;
    * (Z1,O)->Z2; (Z1,-)->Z0; (Z1,4)-> Z1; (Z1,i)->Z4;
    * (Z2,O)->Z2; (Z2,-)->Z3; (Z2,4)-> Z2; (Z2,i)->Z4;
    * (Z3,O)->Z3; (Z3,-)->Z3; (Z3,4)-> Z3; (Z3,i)->Z3;
    * (Z4,O)->Z0; (Z4,-)->Z4; (Z4,4)-> Z4; (Z4,i)->Z3;
    * Eingabeworte (4 Zeichen): [iOOO, iOi4, OOOiO, 4O-4, O-O-, 4iO4]
    * Der Automat arbeitet der Reihe nach die Buchstaben eines Wortes ab und wechselt abhängig vom Buchstaben den Zustand.
    * Dies geschieht so lange, bis das Restwort leer ist.
    * Ist der Automat dann in einem Endzustand (es muss genau einen Startzustand geben, kann aber mehrere Endzustände geben), gehört das Wort zu der Sprache.
    */

   private static final char INPUT_CHAR_O = 'O';
   private static final char INPUT_CHAR = '-';
   private static final char INPUT_CHAR_4 = '4';
   private static final char INPUT_CHAR_i = 'i';

   public static void main(String[] args){
       String [] entryValues = new String[] {"iOOO", "iOi4", "OOiO", "4O-4", "O-O-", "4iO4"};
       for (String string : entryValues) {
           if(isEntryValid(string)) {
               perfomAction(string);
           }
       }

   }

   /**
    * Method to check if all characters are valid
    * @param entryValues
    * @return
    */
   private static boolean isEntryValid(String string) {
       if(string == null) {
           System.out.println("Variable string ist \"null\"");
           return false;
       }
       if(string.length() < 4) {
           System.out.println("Fehler: \"" + string + "\" ist keine gueltige Eingabe!");
           System.out.println("Min 4 Zeichen duerfen eingegeben werden!");
           return false;
       }
       if(string.length() > 4) {
           System.out.println("Fehler: \"" + string + "\" ist keine gueltige Eingabe!");
           System.out.println("Max 4 Zeichen duerfen eingegeben werden!");
           return false;
       }

       for(char c : string.toCharArray()) {
           if(c != INPUT_CHAR_O && c != INPUT_CHAR && c != INPUT_CHAR_4 && c != INPUT_CHAR_i) {
               System.out.println("Fehler: \"" + string + "\" ist keine gueltige Eingabe!");
               System.out.println("Erlaubt sind nur folgende Zeichen: " + INPUT_CHAR_O + ", " + INPUT_CHAR + ", " + INPUT_CHAR_4 + " oder " + INPUT_CHAR_i);
               return false;
           }
       }
       return true;
   }


   private static void perfomAction(String string) {
       char[] chars = string.toCharArray();
       int zustand = 1;

       for(char c : chars) {
           if(c == INPUT_CHAR_O) {
               switch (zustand) {
               case 0:
                   zustand = 3;
                   break;
               case 1:
                   zustand = 2;
                   break;
               case 2:
                   zustand = 2;
                   break;
               case 3:
                   zustand = 3;
                   break;
               case 4:
                   zustand = 0;
                   break;
               }
           }
           else if(c == INPUT_CHAR) {
               switch (zustand) {
               case 0:
                   zustand = 2;
                   break;
               case 1:
                   zustand = 0;
                   break;
               case 2:
                   zustand = 3;
                   break;
               case 3:
                   zustand = 3;
                   break;
               case 4:
                   zustand = 4;
                   break;
               }
           }
           else if(c == INPUT_CHAR_4) {
               switch (zustand) {
               case 0:
                   zustand = 2;
                   break;
               case 1:
                   zustand = 1;
                   break;
               case 2:
                   zustand = 2;
                   break;
               case 3:
                   zustand = 3;
                   break;
               case 4:
                   zustand = 4;
                   break;
               }
           }
           else if(c == INPUT_CHAR_i) {
               switch (zustand) {
               case 0:
                   zustand = 0;
                   break;
               case 1:
                   zustand = 4;
                   break;
               case 2:
                   zustand = 4;
                   break;
               case 3:
                   zustand = 3;
                   break;
               case 4:
                   zustand = 3;
                   break;
               }
           }
       }
       System.out.println("Endzustand: " + zustand + "");
       if(zustand == 3)
           System.out.println("Das Word: \"" + string + "\" ist gueltig!");
       else
           System.out.println("Das Word: \"" + string + "\" ist nicht gueltig!");
   }
}
```


----------



## wintermutant (8. Jan 2017)

Hi knilch,
danke für deine hilfe.
Ich habe aber weiterhin das problem, dass ich die eingabewörter mit hilfe von JOptionPane erledigen muss und die Asugabe des ergebnisses ebenfalls(wie auf dem Bild). Leider kriege ich immer die fehlermeldung:
"Exception in thread "main" java.lang.Error: Unaufgelöste Kompilierungsprobleme"


----------



## knilch (9. Jan 2017)

Hi,
Mein Ansatz ist eine Methode. Es sollte nicht so schwer sein, das ganze dann in eine Methode zu packen und dann noch ein JOptionPane dazufügen zu müssen.


wintermutant hat gesagt.:


> Leider kriege ich immer die fehlermeldung:
> "Exception in thread "main" java.lang.Error: Unaufgelöste Kompilierungsprobleme"


Ohne Stacktrace können wir nur mutmassen, wo das Problem liegt.. (evtl. fehlt irgendwo eine import-Definition?)


----------

