Aufgabensammlung FGI

1. Konstruktion endlicher Automaten

Zu den folgenden Sprach-Beschreibungen sind endliche Automaten zu erstellen. Es ist dabei
unerheblich, ob der FA deterministisch ist oder ob er ε-Übergänge beinhaltet.
a) Grafische Form
b) Tabellenform
c) Definitionen der Zustandsmenge Q, der Menge der akzeptierenden Zustände F, des
Anfangszustands q0 und der Übergangsfunktion

1.1. ={a,b,c,d,e}, L = { w | w enthält das Teilwort bad }

1.2. ={a,b,c }, L = { w | w=zzabbaz*, wobei z für ein beliebiges Zeichen des Alphabets steht }
1.3. ={0,1 }, L = { w | w enthält eine gerade Anzahl von Nullen }
1.4. ={0,1 }, L = { w | w enthält eine ungerade Anzahl von Nullen }
1.5. ={0,1 }, L = { w | w enthält eine ungerade Anzahl von 0 oder eine ungerade Anzahl von
Einsen }
1.6. ={0,1 }, L = { w | w besteht aus einer oder mehreren Nullen }
1.7. ={0,1 }, L = { w | w ist leer oder besteht nur aus Nullen }
1.8. ={0,1 }, L = { w | w enthält eine durch 3 teilbare Anzahl von Einsen }
1.9. ={0,1 }, L = { w | w ist als Binärzahl durch 2 teilbar }
1.10. ={0,1 }, L = { w | w ist als Binärzahl durch 3 teilbar }
1.11. ={0,1 }, L = { w | w ist als Binärzahl durch 5 teilbar }
1.12. ={0,1 }, L = { w | w enthält gerade Anzahl von Nullen und gerade Anzahl von Einsen }
1.13. ={0,1 }, L = { w | w endet mit 00 }
1.14. ={0,1 }, L = { w | w enthält irgendwo 000 }
1.15. ={0,1 }, L = { w | w enthält als vorletztes Symbol eine 1 }
1.16. ={a,b,c }, L = { w |w besteht aus keinem, einem oder mehreren a, gefolgt von keinem,
einem oder mehreren b, gefolgt von keinem, einem oder mehreren c }
1.17. L = { w | w besteht aus einer oder mehreren Wiederholungen von 01 oder aus
einer oder mehreren Wiederholungen von 010 }
1.18. ={0,1,2,3 }, L = { w | die letzte Ziffer von w ist vorher bereits in w vorgekommen }
1.19. ={0,1,2,3 }, L = { w | die letzte Ziffer von w ist vorher noch nicht in w vorgekommen }
1.20. ={a,b,c }, L = { w |w enthält mindestens eines der drei Wörter ab, bc, ca }
1.21. ={0,1 }, L = { w | w enthält als erstes und letztes Symbol eine 1 }

1
2. Arbeitsweise endlicher Automaten
Zu den gegebenen Automaten und Eingabewörtern ist die Menge der jeweils aktiven Zustände zu
Beginn und nach jedem Symbol der Eingabe zu bestimmen (bzw. anzugeben, dass gegebenenfalls die
Eingabe abgebrochen wurde).

2.1. Gegeben sei der folgende FA (Σ = {a, b}):

Erstellen Sie die Abfolge der aktiven Zustände für die Eingabewörter
a) aaa
b) abbab
b) aabbbb

2.2. Gegeben sei der folgende FA (Σ = {0, 1}):

Erstellen Sie die Abfolge der aktiven Zustände für die Eingabewörter
a) 0010110001
b) 11011100
b) 01011101110

2
2.3. Gegeben sei der folgende FA (Σ = {a, b}):

Erstellen Sie die Abfolge der aktiven Zustände für die Eingabewörter
a) aaababb
b) bbaabbaa
c) abbabbbb

3
3. Überführung in deterministische endliche Automaten
Folgende endlichen Automaten sind in deterministische endliche Automaten zu überführen. Das
Ergebnis ist in graphischer oder tabellarischer Form anzugeben.

3.1

Σ = {a, b}

3.2 Σ = {0, 1}

0 1 ε
→ p {p, q} p ∅
q {r, s} t ∅
r {p, r} t ∅
* s ∅ ∅ ∅
* t ∅ ∅ ∅

3.3

Σ = {a, b}

4
3.4

Σ = {a, b}

3.5

Σ = {0, 1}

3.6

Σ = {0, 1}

5
3.7 Σ = {a, b, c}

a b c ε
→ p ∅ q r {q, r}
q p r {p, q} ∅
* r ∅ ∅ ∅ ∅

6
4. Minimierung deterministischer endlicher Automaten
Ermitteln Sie zu den folgenden deterministischen endlichen Automaten unter Verwendung des
Table-Filling-Algorithmus die zugehörigen minimalen Automaten.

4.1

Σ = {a, b}

4.2

Σ = {0, 1, 2}

7
4.3

0 1
→ q0 q1 q2
* q1 q3 q4
* q2 q4 q3
q3 q1 q2
* q4 q2 q1

4.4

4.5.

0 1
→ A B C
B B C
C B A
D D E
* E E B

8
4.6

0 1
→ A B A
B A C
C D B
* D D A
E D F
F G E
G F G
H G D

4.7.

0 1
→ A B E
B C F
* C D H
D E H
E F I
* F G B
G H B
H I C
* I A E

9
5. Erstellen regulärer Ausdrücke

Besteht das Alphabet aus höchstens 5 Zeichen, benutzen Sie bitte nur die in der RA-Definition
angegebenen Konstrukte, für die anderen können auch die Erweiterungen für Programmiersprachen
eingesetzt werden.

5.1 Σ = {0,1}, L = { w | vorletztes Symbol in w ist eine Eins }

5.2 Σ = {0,1}, L = { w | viertletztes Symbol in w ist eine Eins }

5.3 Σ = {0,1}, L = { w | w enthält höchstens einmal 00 }

5.4 Σ = {0,1}, L = { w | nach einem 11 darf kein 00 mehr vorkommen }

5.5 Σ = {0,1}, L = { w | w enthält durch drei teilbare Anzahl Nullen }

5.6 Σ = {a,b,c}, L = { w | w enthält mindestens ein a sowie mindestens ein b }

5.7 Σ = {0,1,2,3,4}, L = { w | beliebige Folge aus Nullen und Dreien }

5.8 Σ = ASCII-Zeichen, L = { w | gültiger Variablenname: Buchstabe oder _, gefolgt von

mehreren (auch keinen) weiteren Buchstaben, Ziffern und _ }

5.9 Σ = ASCII-Zeichen, L = { w | Hex-Zahl (0x oder 0X gefolgt von Ziffern oder a-f, A-F) }

5.10 Σ = ASCII-Zeichen, L = { w | Autokennzeichen-ähnlich: ein bis drei Großbuchstaben,

Leerzeichen, Bindestrich, Leerzeichen, null bis drei
Großbuchstaben, Leerzeichen, ein bis vier Ziffern }

5.11 Σ = ASCII-Zeichen, L = { w | Zwei Dezimalzahlen, die durch ein oder mehrere

Leerzeichen voneinander getrennt sind }

5.12 Σ = ASCII-Zeichen, L={ w | w ist ein Java-Schlüsselwort}

Zur Info hinsichtlich der Java Schlüsselworte:

<keyword> ::= abstract | boolean | break | byte | case | catch | char | class |
const | continue | default | do | double | else | extends | final | finally |
float | for | goto | if | implements | import | instanceof | int | interface |
long | native | new | package | private | protected | public | return | short |
static | super | switch | synchronized | this | throw | throws | transient | try
| void | volatile | while

5.13 Σ = ASCII-Zeichen, L={ w | w ist ein Datum im Format TT-MM-JJJJ, keine

Berücksichtigung von Schaltjahren, Jahre von 1900 bis 2049 }

10
6. Überführung regulärer Ausdrücke in endliche Automaten

6.1. (0|1)01
6.2. 00(0|1)*
6.3. (0*|1*)1
6.4. 0(0|1)*|(0|1)*1

11
7. Überführung endlicher Automaten in reguläre Ausdrücke

7.1.

7.2.

12
8. Nachweis der Nichtregularität von Sprachen

Zeigen Sie, dass folgende Sprachen nicht regulär sind:

8.1. Σ = {0, 1}, L = { w | w enthält genauso viele Nullen wie Einsen }

8.2. Σ ={(, )}, L = { w | w ist ein korrekter Klammerausdruck }
8.3. Σ = {0}, L = { w | die Anzahl der Nullen in w ist eine Quadratzahl }
8.4. Σ = {0}, L = { w | die Anzahl der Nullen in w ist keine Quadratzahl }
8.5. Σ = {a, b}, L = { w | w=anb3n, n ≥ 0 }

Stimmen die folgenden Aussagen?

8.6. Jede Teilsprache (Teilmenge) einer regulären Sprache ist regulär.
8.7. Sei L eine beliebige Sprache über {0,1}, k eine feste ganze Zahl. Dann ist die Menge {v | v ist
Suffix eines Wortes w aus L und |v| < k} eine reguläre Sprache.

13
9. Kontextfreie Grammatiken
9.1. Betrachte Sie die folgende kontextfreie Grammatik:
 S → A1B
 A → 0A | ε
 B → 0B | 1B | ε

Geben Sie für die Wörter 00101, 1001 und 00011 jeweils die Links- und die Rechtsableitung
an.
9.2. Entwickeln Sie kontextfreie Grammatiken für die folgenden Sprachen:
 L1 = {w#wR | w∈(0|1)*}
 L2 = {0n1n | n ≥ 1}
 L3 = {0n1n | n ≥ 0}
 L4 = {0n1n2m | n ≥ 1, m ≥ 0}
 L5: Korrekte Klammerausdrücke aus runden Klammern

9.3. Folgende Produktionen sind aus der offiziellen Grammatik der Programmiersprache Java
entnommen. Geben Sie eine Deklaration mit Initialisierung (Variablenname und Datentyp
dürfen Sie sich ausdenken) an, die diesen Produktionen entspricht. Schreiben Sie eine
Ableitung für diese Deklaration auf.
MethodOrFieldDecl → Type Identifier MethodOrFieldRest
Type → Identifier BracketsOpt | Identifier . Identifier1 BracketsOpt |
BasicType
Identifier1 → Identifier | Identifier . Identifier1
Identifier → IDENTIFIER //hier Variablenname einsetzen
MethodOrFieldRest → V ariableDeclaratorRest | MethodDeclaratorRest
BracketsOpt → [] | [] BracketsOpt |

BasicType → byte | short | char | int | long | float | double |boolean

VariableDeclaratorRest → BracketsOpt = VariableInitializer |
BracketsOpt
MethodDeclaratorRest → //hier steht natürlich noch was, aber Methoden
// brauchen wir für diese Aufgabe nicht
VariableInitializer → ArrayInitializer
| Expression
ArrayInitializer → {} |
{ VariableInitializer } |
{ VariableInitializer , VariableInitializer1 }
VariableInitializer1 →VariableInitializer |
 VariableInitializer , VariableInitializer1
Expression: ZAHL //hier steht eigentlich auch was anderes,
// aber dann würde die Aufgabe zu lang…

Startsymbol: MethodOrFieldDecl
Terminalzeichen: {Punkt, Komma, geschweifte Klammer auf, geschweifte Klammer zu,
eckige Klammer auf, eckige Klammer zu, Gleichzeichen, IDENTIFIER, ZAHL, byte, short,
char, int, long, float, double, boolean}
Alle Variablen sind kursiv geschrieben.

14
9.4. verschiedene
Linksableitungen und zwei verschiedene Rechtsableitungen für das Wort aabbcc. Ist die
Grammatik eindeutig? Können Sie erkennen, welche Sprache durch die Grammatik
beschrieben wird? (Tipp: noch ein paar mehr Wörter ableiten.)

9.5.
ist {a,b,c,d}).

9.6. Gegeben sei die folgende DTD Spezifikation:

<!ELEMENT PLAYLIST (PLAYLISTITEM)+>
<!ELEMENT PLAYLISTITEM (ARTIST, SONG, ALBUM)>
<!ELEMENT ARTIST (#PCDATA)>
<!ELEMENT SONG (#PCDATA)>
<!ELEMENT ALBUM (#PCDATA)>

Zu dieser Spezifikation wurde das nachfolgende XML-Dokument geschrieben. Finden Sie

Fehler in diesem Dokument.
<?xml version="1.0" encoding="ISO-8859-1"?>
<!DOCTYPE PLAYLIST SYSTEM "PLAYLIST.dtd">
<PLAYLIST>
<PLAYLISTITEM>
<ARTIST>Pixies</ARTIST>
<SONG>Monkey gone to heaven</SONG>
<ALBUM>Doolittle</ALBUM>
</PLAYLISTITEM>
<PLAYLISTITEM>
Ist die Wiederholung des gleichen Titels falsch?
<ARTIST>Pixies</ARTIST>
<SONG>Monkey gone to heaven</SONG>
<ALBUM>>Doolittle</ALBUM>
</PLAYLISTITEM>
<PLAYLISTITEM>
</PLAYLISTITEM>
</playlist>
<ARTIST>J.Hendrix<ARTIST/>

15
10. Chomsky Normalform und der CYK Algorithmus

10.1. Formen Sie die folgenden Produktionen einer Grammatik in Chomsky-Normalform um

(Startsymbol S, Alphabet {a,b}):
S → ASA | aB
A→S|B
B→b|ɛ

10.2. Formen Sie die folgenden Produktionen einer Grammatik in Chomsky-Normalform um

(Startsymbol S, Alphabet {a,b}):
A → aCD
B → bCD
C→D
C→ε
D→C
S → ABC

10.3. Bestimmen Sie mit Hilfe des CYK-Algorithmus, ob die Worte aaabbbcc und aacc in
derSprache liegen, die durch die folgende Grammatik beschrieben wird
S → AB
A → CD | CF
B → c | EB
C→a
D→b
E→c
F → AD

10.4. Bestimmen Sie mit Hilfe des CYK-Algorithmus, ob das Wort baaba in derSprache liegt, die
durch die folgende Grammatik beschrieben wird
S → AB | BC
A → BA | a
B → CC | b
C → AB | a

10.5. Bestimmen Sie mit Hilfe des CYK-Algorithmus, ob das Wort baab in derSprache liegt, die
durch die folgende Grammatik beschrieben wird
S → AB | a
A → BA | a
B → AB | b

16
11. Kellerautomaten

11.1. Konstruieren Sie einen Nichtdeterministischen Kellerautomaten zur Sprache

L = {w1#w2#w3#wR | w1, w2, w3 ∈ {a,b}* und w ∈ { w1, w2, w3 }}
(Am Anfang stehen drei beliebige Worte aus a und b, am Ende steht eins dieser
Worte umgedreht.)

11.2. Beschreiben Sie die Sprachen, die von folgenden PDA akzeptiert werden

a.

b.

c.

17
12. Turingmaschinen

12.1. Nachfolgend das Bild einer Turingmaschine für die Sprache {anbncn}:

12.2. Entwickeln Sie eine Turing-Maschine, die die folgende Sprache akzeptiert:
 L = {1n+1=1n+1 | n > 0}
 Wörter der Sprache sind z.B. „1+1=11“ , „11+1=111“ oder
„1111111111+1=11111111111“
 + und = gehören hier zum Alphabet und stellen keine Rechenzeichen
dar!

12.3. Entwickeln Sie eine Turing-Maschine für folgende Funktion:

Die Eingabe sei x0y (x und y in unär-Darstellung), die Ausgabe sei 1 oder 0.
Prinzipielles Vorgehen:
 Gleiche eine 1 von x mit einer 1 von y ab und wiederhole diesen Vorgang bis
alle 1 von x oder y bearbeitet sind
 Wenn eine 1 von x nicht bearbeitet wurde, lösche das Band und schreibe
eine 1
 Sonst lösche das Band und schreibe eine 0.

18
Lösungen

1. Konstruktion endlicher Automaten

Man beachte, dass die nachfolgenden Lösungen nicht die einzigen sind. Sie können also durchaus
eine richtige Lösung haben, die sich von der hier angegebenen unterscheidet. Lösungen für die
Aufgabentypen b) und c) hier nur als Muster für Aufgabe 1.

1.1.a)

1.1.b)
a b c d e ε
→ q0 q0 {q0, q1} q0 q0 q0 ∅
q1 q2 ∅ ∅ ∅ ∅ ∅
q2 ∅ ∅ ∅ q3 ∅ ∅
* q3 q3 q3 q3 q3 q3 ∅

1.1.c)
Q = {q0, q1, q2, q3}
F = {q3}
q0 = q0
δ(q0, a) = {q0}, δ(q0, b) = {q0, q1}, δ(q0, c) = {q0}, δ(q0, d) = {q0}, δ(q0, e) = {q0}, δ(q0, ε) = ∅,
δ(q1, a) = {q2}, δ(q1, b) = ∅, δ(q1, c) = ∅, δ(q1, d) = ∅, δ(q1, e) = ∅, δ(q1, ε) = ∅,
δ(q2, a) = ∅, δ(q2, b) = ∅, δ(q2, c) = ∅, δ(q2, d) = {q3}, δ(q2, e) = ∅, δ(q2, ε) = ∅,
δ(q3, a) = {q3}, δ(q3, b) = {q3}, δ(q3, c) = {q3}, δ(q3, d) = {q3}, δ(q3, e) = {q3}, δ(q3, ε) = ∅

19
1.2.a)

1.3.a)

1.4.a)

1.5.a)

20
1.6.a)

1.7.a)

1.8.a)

1.9.a)

1.10.a)
Generell gilt für Binärzahlen: Anfügen einer 0 bedeutet die Zahl zu verdoppeln, Anfügen einer 1
bedeutet Verdopplung und zusätzlich Addition einer 1.
Wir betrachten nun den Rest einer Zahl z bei Division durch 3:
i. Ist dieser Rest 0, so gibt es eine ganze Zahl k, so dass z=3k gilt. Fügt man nun an die
Binärdarstellung von z eine 0 an, so entsteht die Zahl 2z, also 6k. 6k ergibt bei Division

21
 durch 3 wieder den Rest 0.
Fügt man eine 1 an so entsteht 2z+1, also 6k+1. Hier ergibt sich also der Rest 1.
ii. Ist der Rest bei Division von z durch 3 eine 1 (also z=3k+1), so entsteht durch Anfügen
einer Null die Zahl 2(3k+1)=6k+2, lässt also den Rest 2, Anfügen einer 1 ergibt (6k +2) +1
= 3(2k + 1), also nun Rest 0
iii. Ist der Rest bei Division von z durch 3 eine 2 (also z=3k+2) ), so entsteht durch Anfügen
einer Null die Zahl 2(3k+2)=6k+4=3(2k+1)+1, lässt also den Rest 1, Anfügen einer 1 ergibt
(6k +4) +1 = 3(2k + 1)+2, also nun Rest 2
Es bietet sich also an, für den jeweiligen Rest der Division einen Zustand einzuführen:
Zufügen einer 0 Zufügen einer 1
R0 (Rest bei Division durch 3  0) R0 R1
R1 (Rest bei Division durch 3  1) R2 R0
R2 (Rest bei Division durch 3  2) R1 R2

1.11.a)
Dieser FA wird in analoger Weise erstellt wie der aus Aufgabe 1.10.

22
1.12.a)

1.13.a)

1.14.a)

1.15.a)

23
1.16.a)

1.17.a)

1.18.a)

24
1.19.a)

1.20.a)

1.21.a)

25
 2. Arbeitsweise endlicher Automaten

2.1.a
Eingabewort 'aaa':
({q0, q1, q4}, 'aaa')
({q1, q3, q4}, 'aa')
({q1, q2, q3, q4}, 'a')
({q1, q2, q3, q4}, '')
Eingabe akzeptiert

2.1.b
Eingabewort 'abbab':
({q0, q1, q4}, 'abbab')
({q1, q3, q4}, 'bbab')
Eingabe nicht akzeptiert (keine Übergänge für nächstes Symbol aus Eingabe)

2.1.c
Eingabewort 'aabbbb':
({q0, q1, q4}, 'aabbbb')
({q1, q3, q4}, 'abbbb')
({q1, q2, q3, q4}, 'bbbb')
({q1, q2, q3, q4}, 'bbb')
({q1, q2, q3, q4}, 'bb')
({q1, q2, q3, q4}, 'b')
({q1, q2, q3, q4}, '')
Eingabe akzeptiert

2.2.a
Eingabewort '0010110001':
( {q0, q1, q4} , '0010110001' )
( {q1, q4} , '010110001' )
( {q1, q4} , '10110001' )
( {q2, q5, q6} , '0110001' )
( {q3, q4, q6} , '110001' )
( {q3, q5, q6} , '10001' )
( {q3, q5, q6} , '0001' )
( {q2, q4, q6} , '001' )
( {q3, q4, q6} , '01' )
( {q2, q4, q6} , '1' )
( {q1, q5, q6} , '' )
Eingabe akzeptiert.

26
2.2.b
Eingabewort '11011100':
( {q0, q1, q4} , '11011100' )
( {q2, q5, q6} , '1011100' )
( {q1, q5, q6} , '011100' )
( {q1, q4} , '11100' )
( {q2, q5, q6} , '1100' )
( {q1, q5, q6} , '100' )
( {q2, q5, q6} , '00' )
( {q3, q4, q6} , '0' )
( {q2, q4, q6} , '' )
Eingabe akzeptiert.

2.2.c
Eingabewort '01011101110':
( {q0, q1, q4} , '01011101110' )
( {q1, q4} , '1011101110' )
( {q2, q5, q6} , '011101110' )
( {q3, q4, q6} , '11101110' )
( {q3, q5, q6} , '1101110' )
( {q3, q5, q6} , '101110' )
( {q3, q5, q6} , '01110' )
( {q2, q4, q6} , '1110' )
( {q1, q5, q6} , '110' )
( {q2, q5, q6} , '10' )
( {q1, q5, q6} , '0' )
( {q1, q4} , '' )
Eingabe nicht akzeptiert.

2.3.a
Eingabewort 'aaababb':
({q0}, 'aaababb')
({q1}, 'aababb')
({q1}, 'ababb')
({q1}, 'babb')
({q3}, 'abb')
({q1}, 'bb')
({q3}, 'b')
({q4}, '')
Eingabe akzeptiert

27
2.3.b
Eingabewort 'bbaabbaa':
({q0}, 'bbaabbaa')
({q2}, 'baabbaa')
({q2}, 'aabbaa')
({q1}, 'abbaa')
({q1}, 'bbaa')
({q3}, 'baa')
({q4}, 'aa')
({q1}, 'a')
({q1}, '')
Eingabe nicht akzeptiert

2.3.c
Eingabewort 'abbabbbb':
({q0}, 'abbabbbb')
({q1}, 'bbabbbb')
({q3}, 'babbbb')
({q4}, 'abbbb')
({q1}, 'bbbb')
({q3}, 'bbb')
({q4}, 'bb')
({q2}, 'b')
({q2}, '')
Eingabe nicht akzeptiert

28
 3. Überführung in deterministische endliche Automaten
3.1

Folgezu-
Zustand entspricht Symbol q0 q1 q2 q3 q4 Vereinigung ECLOSE
stand
a {} {q1,q3} {} {q1,q3} {q1,q3,q4} s1 (neu)
>* s0 {q0,q1,q4}
b {} {} {} {} {} s2 (neu)
a {q1,q3} {q2} {} {q1,q2,q3} {q1,q2,q3,q4} s3 (neu)
* s1 {q1,q3,q4}
b {} {} {} {} {} s2
a {} {} s2
s2 {}
b {} {} s2
a {q1,q3} {} {q2} {} {q1,q2,q3} {q1,q2,q3,q4} s3
* s3 {q1,q2,q3,q4}
b {} {q1,q2,q3} {} {} {q1,q2,q3} {q1,q2,q3,q4} s3

Daraus resultiert die folgende tabellarische Darstellung des DFA:

a b
>* s0 s1 s2
* s1 s3 s2
s2 s2 s2
* s3 s3 s3

29
3.2

Folgezu-
Zustand entspricht Symbol p q r s t Vereinigung ECLOSE
stand
0 {p,q} {p,q} {p,q} s1 (neu)
> s0 {p}
1 {p} {p} {p} s0
0 {p,q} {r,s} {p,q,r,s} {p,q,r,s} s2 (neu)
s1 {p,q}
1 {p} {t} {p,t} {p,t} s3 (neu)
0 {p,q} {r,s} {p,r} {} {p,q,r,s} {p,q,r,s} s2
* s2 {p,q,r,s}
1 {p} {t} {t} {} {p,t} {p,t} s3
0 {p,q} {} {p,q} {p,q} s1
* s3 {p,t}
1 {p} {} {p} {p} s0

Daraus resultiert die folgende tabellarische Darstellung des DFA:

0 1
> s0 s1 s0
s1 s2 s3
* s2 s2 s3
* s3 s1 s0

30
3.3

Folgezu-
Zustand entspricht Symbol q0 q1 q2 q3 q4 q5 Vereinigung ECLOSE
stand
a {} {q2} {} {q4} {q2,q4} {q2,q3,q4} s1 (neu)
>* s0 {q0,q1,q3,q4}
b {} {} {} {q5} {q5} {q5} s2 (neu)
a {q2} {} {q4} {q2,q4} {q2,q3,q4} s1
* s1 {q2,q3,q4}
b {q2} {} {q5} {q2,q5} {q2,q3,q5} s3 (neu)
a {q4} {q4} {q3,q4} s4 (neu)
s2 {q5}
b {q5} {q5} {q5} s2
a {q2} {} {q4} {q2,q4} {q2,q3,q4} s1
* s3 {q2,q3,q5}
b {q2} {} {q5} {q2,q5} {q2,q3,q5} s3
a {} {q4} {q4} {q3,q4} s4
* s4 {q3,q4}
b {} {q5} {q5} {q5} s2

Daraus resultiert die folgende tabellarische Darstellung des DFA:

a b
>* s0 s1 s2
* s1 s1 s3
s2 s4 s2
* s3 s1 s3
* s4 s4 s2

31
3.4

Folgezu-
Zustand entspricht Symbol q0 q1 q2 q3 q4 Vereinigung ECLOSE
stand
a {} {q2} {q3} {q2,q3} {q2,q3} s1 (neu)
>* s0 {q0,q1,q3}
b {} {q1} {q4} {q1,q4} {q1,q4} s2 (neu)
a {q2} {q3} {q2,q3} {q2,q3} s1
* s1 {q2,q3}
b {} {q4} {q4} {q4} s3 (neu)
a {q2} {} {q2} {q2} s4 (neu)
* s2 {q1,q4}
b {q1} {q4} {q1,q4} {q1,q4} s2
a {} {} {} s5 (neu)
* s3 {q4}
b {q4} {q4} {q4} s3
a {q2} {q2} {q2} s4
* s4 {q2}
b {} {} {} s5
a {} {} s5
s5 {}
b {} {} s5

Daraus resultiert die folgende tabellarische Darstellung des DFA:

a b
>* s0 s1 s2
* s1 s1 s3
* s2 s4 s2
* s3 s5 s3
* s4 s4 s5
s5 s5 s5

32
3.5

Folgezu-
Zustand entspricht Symbol q0 q1 q2 q3 q4 q5 q6 q7 Vereinigung ECLOSE
stand
0 {} {q2} {q5} {q2,q5} {q2,q5} s1 (neu)
> s0 {q0,q1,q4}
1 {} {} {} {} {} s2 (neu)
0 {} {} {} {} s2
s1 {q2,q5}
1 {q3} {q6} {q3,q6} {q1,q3,q6} s3 (neu)
0 {} {} s2
s2 {}
1 {} {} s2
0 {q2} {} {q7} {q2,q7} {q2,q4,q7} s4 (neu)
s3 {q1,q3,q6}
1 {} {} {} {} {} s2
0 {} {q5} {} {q5} {q5} s5 (neu)
* s4 {q2,q4,q7}
1 {q3} {} {} {q3} {q1,q3} s6 (neu)
0 {} {} {} s2
s5 {q5}
1 {q6} {q6} {q6} s7 (neu)
0 {q2} {} {q2} {q2} s8 (neu)
s6 {q1,q3}
1 {} {} {} {} s2
0 {q7} {q7} {q4,q7} s9 (neu)
s7 {q6}
1 {} {} {} s2
0 {} {} {} s2
s8 {q2}
1 {q3} {q3} {q1,q3} s6
0 {q5} {} {q5} {q5} s5
* s9 {q4,q7}
1 {} {} {} {} s2

Daraus resultiert die folgende tabellarische Darstellung des DFA:

0 1
> s0 s1 s2
s1 s2 s3
s2 s2 s2
s3 s4 s2
* s4 s5 s6
s5 s2 s7
s6 s8 s2
s7 s9 s2
s8 s2 s6
* s9 s5 s2

33
3.6

Folgezu-
Zustand entspricht Symbol q0 q1 q2 q3 q4 q5 q6 Vereinigung ECLOSE
stand
0 {} {q1} {q3} {q1,q3} {q1,q3,q6} s1 (neu)
> s0 {q0,q1,q4}
1 {} {q2} {q5} {q2,q5} {q2,q5,q6} s2 (neu)
0 {q1} {q2} {} {q1,q2} {q1,q2,q6} s3 (neu)
* s1 {q1,q3,q6}
1 {q2} {q3} {} {q2,q3} {q2,q3,q6} s4 (neu)
0 {q3} {q4} {} {q3,q4} {q3,q4,q6} s5 (neu)
* s2 {q2,q5,q6}
1 {q1} {q5} {} {q1,q5} {q1,q5,q6} s6 (neu)
0 {q1} {q3} {} {q1,q3} {q1,q3,q6} s1
* s3 {q1,q2,q6}
1 {q2} {q1} {} {q1,q2} {q1,q2,q6} s3
0 {q3} {q2} {} {q2,q3} {q2,q3,q6} s4
* s4 {q2,q3,q6}
1 {q1} {q3} {} {q1,q3} {q1,q3,q6} s1
0 {q2} {q3} {} {q2,q3} {q2,q3,q6} s4
* s5 {q3,q4,q6}
1 {q3} {q5} {} {q3,q5} {q3,q5,q6} s7 (neu)
0 {q1} {q4} {} {q1,q4} {q1,q4} s8 (neu)
* s6 {q1,q5,q6}
1 {q2} {q5} {} {q2,q5} {q2,q5,q6} s2
0 {q2} {q4} {} {q2,q4} {q2,q4,q6} s9 (neu)
* s7 {q3,q5,q6}
1 {q3} {q5} {} {q3,q5} {q3,q5,q6} s7
0 {q1} {q3} {q1,q3} {q1,q3,q6} s1
s8 {q1,q4}
1 {q2} {q5} {q2,q5} {q2,q5,q6} s2
0 {q3} {q3} {} {q3} {q3,q6} s10 (neu)
* s9 {q2,q4,q6}
1 {q1} {q5} {} {q1,q5} {q1,q5,q6} s6
0 {q2} {} {q2} {q2,q6} s11 (neu)
* s10 {q3,q6}
1 {q3} {} {q3} {q3,q6} s10
0 {q3} {} {q3} {q3,q6} s10
* s11 {q2,q6}
1 {q1} {} {q1} {q1} s12 (neu)
0 {q1} {q1} {q1} s12
s12 {q1}
1 {q2} {q2} {q2,q6} s11
Daraus resultiert die folgende tabellarische Darstellung des DFA:
0 1
> s0 s1 s2
* s1 s3 s4
* s10 s11 s10
* s11 s10 s12
s12 s12 s11
* s2 s5 s6
* s3 s1 s3
* s4 s4 s1
* s5 s4 s7
* s6 s8 s2
* s7 s9 s7
s8 s1 s2
* s9 s10 s6

34
3.7

Folge
Zusta entspri Symb Vereinig ECLOS
p q r zu-
nd cht ol ung E
stand
{ {p,q,
a {} {p} {p} s0
} r}
{q { s1
>* s0 {p,q,r} b {r} {q,r} {q,r}
} } (neu)
{r {p, { {p,q,
c {p,q,r} s0
} q} } r}
{ {p,q,
a {p} {p} s0
} r}
{ s2
* s1 {q,r} b {r} {r} {r}
} (neu)
{p, { {p,q,
c {p,q} s0
q} } r}
{ s3
a {} {}
} (neu)
{
* s2 {r} b {} {} s3
}
{
c {} {} s3
}
a {} {} s3
s3 {} b {} {} s3
c {} {} s3

Daraus resultiert die folgende tabellarische Darstellung des DFA:

a b c
>* s0 s0 s1 s0
* s1 s0 s2 s0
* s2 s3 s3 s3
s3 s3 s3 s3

Und in grafischer Darstellung:

35
 4. Minimierung deterministischer endlicher Automaten

4.1

Unerreichbare Zustände im DFA: keine

q1 q2 q3 q4
q0 X(b);4 X(b);1 X;0
q1 X(b);5 X(b);2 X;0
q2 X(b);3 X;0
q3 X;0

Folgende Gruppe(n) äquivalenter Zustände wurde(n) bestimmt:

(q0, q2)

Daraus resultiert die folgende tabellarische Darstellung des minimalen DFA:

Zuordnung der Zustände:
m0 → (q0, q2)
m1 → (q1)
m2 → (q3)
m3 → (q4)

a b
> m0 m1 m0
m1 m1 m2
m2 m1 m3
* m3 m1 m0

36
4.2

Unerreichbare Zustände im DFA: keine

s1 s2 s3 s4 s5
s0 X;0 X;0 X;0 X(1);4
s1 X(0);1 X;0 X;0
s2 X(0);2 X;0 X;0
s3 X;0 X;0
s4 X(1);3

Folgende Gruppe(n) äquivalenter Zustände wurde(n) bestimmt:

(s1, s3)
(s0, s5)

Daraus resultiert die folgende tabellarische Darstellung des minimalen DFA:

Zuordnung der Zustände:
m0 → (s0, s5)
m1 → (s1, s3)
m2 → (s2)
m3 → (s4)

0 1 2
>* m0 m1 m2 m1
m1 m1 m1 m1
m2 m3 m1 m0
* m3 m1 m1 m1

37
4.3

Unerreichbare Zustände im DFA: keine

q1 q2 q3 q4
q0 X;0 X;0 X;0
q1 X(0);1 X;0 X(0);2
q2 X;0 X(1);3
q3 X;0

Folgende Gruppe(n) äquivalenter Zustände wurde(n) bestimmt:

(q0, q3)

Daraus resultiert die folgende tabellarische Darstellung des minimalen DFA:

Zuordnung der Zustände
m0 → (q0, q3)
m1 → (q1)
m2 → (q2)
m3 → (q4)

0 1
> m0 m1 m2
* m1 m0 m3
* m2 m3 m0
* m3 m2 m1

38
4.4

q1 q2 q3 q4 q5 q6 q7 q8 q9
q0 X(1);14 X(0);21 X(0);1 X;0 X(1);15 X(0);22 X(0);2 X(0);23 X;0
q1 X(1);16 X(0);3 X;0 X(1);17 X(0);4 X(1);18 X;0
q2 X(0);5 X;0 X(1);19 X(0);6 X;0
q3 X;0 X(0);7 X(0);8 X(0);9 X;0
q4 X;0 X;0 X;0 X;0
q5 X(1);10 X(0);11 X(1);20 X;0
q6 X(0);12 X;0
q7 X(0);13 X;0
q8 X;0

Folgende Gruppe(n) äquivalenter Zustände wurde(n) bestimmt:

(q4, q9)
(q2, q6, q8)
(q3, q7)
(q1, q5)

Daraus resultiert die folgende tabellarische Darstellung des minimalen DFA:

Zuordnung der Zustände:
m0 → (q0) m1 → (q1, q5) m2 → (q2, q6, q8)
m3 → (q3, q7) m4 → (q4, q9)

0 1
> m0 m1 m2
m1 m2 m3
m2 m2 m2
m3 m4 m2
* m4 m1 m2

39
4.5

Unerreichbare Zustände im DFA: D, E

Damit gibt es keine akzeptierenden Zustände, die erreicht werden können. Der minimale
deterministische Automat kann daher so dargestellt werden:

4.6

Unerreichbare Zustände im DFA: H, F, G, E

B C D
A X(1);3 X(0);1 X;0
B X(0);2 X;0
C X;0

Der DFA ohne die unerreichbaren Zustände ist bereits minimal.

40
4.7

Unerreichbare Zustände im DFA: keine

B C D E F G H I
A X(0);1 X;0 X(0);2 X;0 X(0);3 X;0
B X;0 X(0);4 X;0 X(0);5 X;0
C X;0 X;0 X;0 X;0
D X(0);6 X;0 X(0);7 X;0
E X;0 X(0);8 X;0
F X;0 X;0
G X(0);9 X;0
H X;0

Folgende Gruppe(n) äquivalenter Zustände wurde(n) bestimmt:

(A, D, G)
(B, E, H)
(C, F, I)

Daraus resultiert die folgende tabellarische Darstellung des minimalen DFA:

Zuordnung der Zustände: m0 → (A, D, G) m1 → (B, E, H) m2 → (C, F, I)

0 1
> m0 m1 m1
m1 m2 m2
* m2 m0 m1

41
 5. Erstellen regulärer Ausdrücke

5.1 (0|1)*1(0|1) oder mit Mitteln der programmiersprachlichen Erweiterung

[01]*1[01]

5.2 (0|1)*1(0|1) (0|1) (0|1) oder mit Mitteln der programmiersprachlichen

Erweiterung [01]*1[01]{3}

5.3 (1|ε)(011*)*(0|ε)((011*)*|0|ε) oder mit Mitteln der

programmiersprachlichen Erweiterung
1*(01+)*0?((01+)*|0?)

5.4 (1|ε)(00*1)*(11*0)*(1|ε) oder mit Mitteln der programmiersprachlichen

Erweiterung 1?(0+1)*(1+0)*1?

5.5 (1*01*01*01*)*

5.6 (a|b|c)*(a(a|b|c)*b|b(a|b|c)*a)(a|b|c)*
oder mit Mitteln der programmiersprachlichen Erweiterung
[abc]*(a[abc]*b|b[abc*]a)[abc]*

5.7 (0|3)* oder mit Mitteln der programmiersprachlichen Erweiterung

[03]*

5.8 [a-fA-F_]\w*

5.9 0[xX][0-9a-fA-F]+

5.10 [A-Z]{1,3} \- [A-Z]{,3} [0-9]{1,4}

5.11 (0|[1-9][0-9]*(,[0-9]+)?)[ ]+(0|[1-9][0-9]*)(,[0-9]+)?)

5.12 (abstract|boolean|break|byte|case|catch|char|class|
const|continue|default|do|double|else|extends|final|finally|
float|for|goto|if|implements|import|instanceof|int|interface|
long|native|new|package|private|protected|public|return|short|
static|super|switch|synchronized|this|throw|throws|transient|
try |void|volatile|while)

5.13 ((0[1-9]|[1-2][0-9]|30)\-(0[469]|11)|(0[1-9]|[1-2]
[0-9]|3[01])\-(0[13578]|1[02])|(0[1-9]|1[0-9]|2[0-8])\-02)
\-(19[0-9]{2}|20[0-4][0-9])

42
6. Überführung regulärer Ausdrücke in endliche Automaten

6.1

6.2

6.3

6.4

43
7. Überführung endlicher Automaten in reguläre Ausdrücke

7.1 010(110)*

7.2 (1|0|00)((0|1)0(1|0|00))*

44
8. Nachweis der Nichtregularität von Sprachen

8.1. Σ = {0, 1}, L = { w | w enthält genauso viele Nullen wie Einsen }

Wir nehmen an, die Sprache sei regulär. Wir wählen das Wort z=0n1n, n ist die Pumping
Lemma Zahl. Dann gilt z=uvw, mit |uv| < n und v ≠ε. Dann müssten auch alle Wörter uvkw
für k ≥ 0 in der Sprache liegen. uvkw hat aber je nach k meist mehr Nullen als Einsen, was
aber Wörter aus L nicht zulässig ist.
8.2. Σ ={(, )}, L = { w | w ist ein korrekter Klammerausdruck }
Wir nehmen an, die Sprache sei regulär. Wir wählen das Wort z=(n)n, n ist die Pumping
Lemma Zahl. Dann erfolgt der Beweis wie in Aufgabe 8.1
8.3. Σ = {0}, L = { w | die Anzahl der Nullen in w ist eine Quadratzahl }
Wir nehmen an, die Sprache sei regulär. Pumping-Lemma Zahl sei n. Betrachten das
Eingabewort z = x(n2) ∈ L. Wieder gilt z = uvw mit |v| ≤ n. Mit z1 = uvvw gilt damit:
n2 = |z| = |uvw| < |z1| = |uvvw| ≤ n2+n < n2+2n+1 = (n+1)2
|z1| kann keine Quadratzahl sein! Folglich kann das Pumping-Lemma nicht gelten und die
Annahme, L sei regulär, ist falsch.
8.4. Σ = {0}, L = { w | die Anzahl der Nullen in w ist keine Quadratzahl }
Diese Sprache ist das Komplement der Sprache aus Aufgabe 8.3. Wäre sie regulär, so
müsste auch die Sprache aus 8.3 regulär sein.
8.5. Σ = {a, b}, L = { w | w=anb3n, n ≥ 0 }
Wir nehmen an, die Sprache sei regulär. Wir wählen das Wort z=anb3n, n ist die Pumping
Lemma Zahl. Dann erfolgt der Beweis wie in Aufgabe 8.1, nur dass k so gewählt werden
soll, dass uvk länger ist als 3n.
8.6. Jede Teilsprache (Teilmenge) einer regulären Sprache ist regulär.
Nicht richtig, denn Σ* ist regulär und jede Sprache ist eine Teilmenge von Σ*. Nicht jede
Sprache ist jedoch regulär.
8.7. Sei L eine beliebige Sprache über {0,1}, k eine feste ganze Zahl. Dann ist die Menge {v | v ist
Suffix eines Wortes w aus L und |v| < k} eine reguläre Sprache.
Richtig: da das Alphabet endlich ist, ist Σ0∪Σ1∪…Σk endlich und damit auch jede Teilmenge
davon. Jede endliche Menge von Wörtern ist eine reguläre Sprache.

45
9. Kontextfreie Grammatiken

9.1. Betrachte Sie die folgende kontextfreie Grammatik:

S → A1B
A → 0A | ε
B → 0B | 1B | ε
Geben Sie für die Wörter 00101, 1001 und 00011 jeweils die Links- und die Rechtsableitung
an.

Linksableitungen: S⇒A1B⇒0A1B⇒00A1B⇒001B⇒0010B⇒00101B⇒00101
S⇒A1B⇒1B⇒10B⇒100B⇒1001B⇒1001
S⇒A1B⇒0A1B⇒00A1B⇒000A1B⇒0001B⇒00011B⇒00011
Rechtsableitungen: S⇒A1B⇒A10B⇒A101B⇒A101⇒0A101⇒00A101⇒00101
S⇒A1B⇒A10B⇒A100B⇒A1001B⇒A1001⇒1001
S⇒A1B⇒A11B⇒A11⇒0A11⇒00A11⇒000A11⇒00011
(Optional) Ableitungsbäume:
S

S A 1 B

A 1 B 0
ε B

0 A 0 B 0 B

0 A 1 B 1 B

ε ε ε

A 1 B

0 1 B
A

ε
0 A

0 A

9.2. Entwickeln Sie kontextfreie Grammatiken für die folgenden Sprachen:

L1 = {w#wR | w∈ (0|1)*}
L2 = {0n1n | n ≥ 1}
L3 = {0n1n | n ≥ 0}
L4 = {0n1n2m | n ≥ 1, m ≥ 0}
L5: Korrekte Klammerausdrücke aus runden Klammern

46
G1: S → # | 0S0 | 1S1
G2: S → 0S1 | 01
G3: S → 0S1 | ε
G4: S → AB, A → 0A1 | 01, B → B2 | ε
G5: S → SS | (S) | ε

9.3. Folgende Produktionen sind aus der offiziellen Grammatik der Programmiersprache Java
entnommen. Geben Sie eine Deklaration mit Initialisierung (Variablenname und Datentyp
dürfen Sie sich ausdenken) an, die diesen Produktionen entspricht. Schreiben Sie eine
Ableitung für diese Deklaration auf.
MethodOrFieldDecl → Type Identifier MethodOrFieldRest
Type → Identifier BracketsOpt | Identifier . Identifier1 BracketsOpt |
BasicType
Identifier1 → Identifier | Identifier . Identifier1
Identifier → IDENTIFIER //hier Variablenname einsetzen
MethodOrFieldRest → V ariableDeclaratorRest | MethodDeclaratorRest
BracketsOpt → [] | [] BracketsOpt |

BasicType → byte | short | char | int | long | float | double |boolean

VariableDeclaratorRest → BracketsOpt = VariableInitializer |
BracketsOpt
MethodDeclaratorRest → //hier steht natürlich noch was, aber Methoden
// brauchen wir für diese Aufgabe nicht
VariableInitializer → ArrayInitializer
| Expression
ArrayInitializer → {} |
{ VariableInitializer } |
{ VariableInitializer , VariableInitializer1 }
VariableInitializer1 →VariableInitializer |
 VariableInitializer , VariableInitializer1
Expression: ZAHL //hier steht eigentlich auch was anderes,
// aber dann würde die Aufgabe zu lang…

Startsymbol: MethodOrFieldDecl
Terminalzeichen: {Punkt, Komma, geschweifte Klammer auf, geschweifte
Klammer zu, eckige Klammer auf, eckige Klammer zu, Gleichzeichen,
IDENTIFIER, ZAHL, byte, short, char, int, long, float, double, boolean}
Alle Variablen sind kursiv geschrieben.

Beispiel-Lösung:

Mytype.par2 [][] myvar []

MethodOrFieldDecl => Type Identifier MethodOrFieldRest =>

Identifier . Identifier1 BracketsOpt Identifier MethodOrFieldRest =>
Mytype. Identifier1 BracketsOpt Identifier MethodOrFieldRest =>
Mytype.par2 BracketsOpt Identifier MethodOrFieldRest =>
Mytype.par2 [] BracketsOpt Identifier MethodOrFieldRest =>
Mytype.par2 [][] Identifier MethodOrFieldRest =>
Mytype.par2 [][] myvar MethodOrFieldRest =>
Mytype.par2 [][] myvar V ariableDeclaratorRest =>
Mytype.par2 [][] myvar BracketsOpt =>
Mytype.par2 [][] myvar []

47
9.4. Finden Sie in der folgenden Grammatik (Σ={a,b,c}, Startsymbol S) zwei verschiedene
Linksableitungen und zwei verschiedene Rechtsableitungen für das Wort aabbcc. Ist die
Grammatik eindeutig? Können Sie erkennen, welche Sprache durch die Grammatik
beschrieben wird? (Tipp: noch ein paar mehr Wörter ableiten.)

Sprache:
a’s gefolgt von b’s gefolgt von c’s, wobei entweder gleichviele b‘ und c’s oder gleichviele a’s und
b’s enthalten sind.

Linksableitungen:
S⇒AD⇒aAD⇒aaAD⇒aaD⇒aabDc⇒aabbDcc⇒aabbcc
S⇒EC⇒aEbC⇒aaEbbC⇒aabbC⇒aabbcC⇒aabbccC⇒aabbcc

Rechtsableitungen:
S⇒AD⇒AbDc⇒AbbDcc⇒Abbcc⇒aAbbcc⇒aaAbbcc⇒aabbcc
S⇒EC⇒EcC⇒EccC⇒Ecc⇒aEbcc⇒aaEbbcc⇒aabbcc

Eindeutigkeit: Die Grammatik ist nicht eindeutig (existieren verschiedene Ableitungsbäume für
aabbcc)

9.5. Geben Sie eine kontextfreie Grammatik für die Sprache L = {aibjcjdi | i, j ≥0} an (das Alphabet
ist {a, b, c, d}).

G: S → A | aAd, A → bAc | ε

9.6. Erkennen Sie die Fehler in folgendem XML Dokument (siehe rote Markierungen):
<?xml version="1.0" encoding="ISO-8859-1"?>
<!DOCTYPE PLAYLIST SYSTEM "PLAYLIST.dtd">
<PLAYLIST>
<PLAYLISTITEM>
<ARTIST>Pixies</ARTIST>
<SONG>Monkey gone to heaven</SONG>
<ALBUM>Doolittle</ALBUM>
</PLAYLISTITEM>
<PLAYLISTITEM>
Ist die Wiederholung des gleichen Titels falsch?
<ARTIST>Pixies</ARTIST>
<SONG>Monkey gone to heaven</SONG>
<ALBUM>>Doolittle</ALBUM>
</PLAYLISTITEM>
48
 <PLAYLISTITEM>
</PLAYLISTITEM>
</playlist>
<ARTIST>J.Hendrix<ARTIST/> XML Dokument darf nur ein Root-Element beinhalten

49
10. Chomsky Normalform und der CYK Algorithmus
10.1. Formen Sie die folgenden Produktionen einer Grammatik in Chomsky-Normalform um
(Startsymbol S, Alphabet {a,b}):
S → ASA | aB
A→S|B
B→b|ɛ
a) Alle Variablen sind nützlich
b) Variablen zu den Terminalsymbolen einführen: Xa→a, Xb→b
damit Regeln insgesamt:
S → ASA | XaB
A→S|B
B → Xb | ɛ
Xa→a
Xb→b
c) Zu lange Regeln kürzen:
S → AY | XaB
Y → SA
A→S|B
B → Xb | ɛ
Xa→a
Xb→b
d) ε-Regeln entfernen:
S → AY | XaB | Xa
Y → SA
A→S|B
B → Xb
Xa→a
Xb→b
e) Kettenregeln entfernen:
S → Xa ⇒ S → AY | XaB | a
A → S ⇒ A → AY | XaB | a | B
A → B ⇒ A → AY | XaB | a | Xb
A → Xb ⇒ A → AY | XaB | a | b
B → Xb ⇒ B → b
damit Regeln insgesamt:
S → AY | XaB | a
Y → SA
A → AY | XaB | a | b
B→b
Xa→a
Xb→b
f) Unnütze Variable entfernen:
S → AY | Y | XaB | Xa
Y → SA | S
A → AY | Y | XaB | Xa | b
B→b
Xa→a

50
10.2. Formen Sie die folgenden Produktionen einer Grammatik in Chomsky-Normalform um
(Startsymbol S, Alphabet {a,b}):

S → ABC
A → aCD
B → bCD
C→D|ε
D→C

a) Alle Variablen sind nützlich

b) Variablen zu den Terminalsymbolen einführen: Xa→a, Xb→b
damit Regeln insgesamt:
S → ABC
A → XaCD
B → XbCD
C→D|ε
D→C
Xa→a
Xb→b
c) Zu lange Regeln kürzen:
S → AY1
Y1 → BC
A → XaY2
B → XbY2
Y2 → CD
C→D|ε
D→C
Xa→a
Xb→b
d) ε-Regeln entfernen (C, D, Y2 sind verschwindend):
S → AY1
Y1 → BC | B
A → XaY2 | Xa
B → XbY2 | Xb
Y2 → CD | C | D
C→D
D→C
Xa→a
Xb→b
e) Kettenregeln entfernen:
Y1 → B ⇒ Y1 → BC | XbY2 | Xb
Y1 → Xb ⇒ Y1 → BC | XbY2 | b
A → Xa ⇒ A → XaY2 | a
B → Xb ⇒ B → XbY2 | b
Y2 → D ⇒ Y2 → CD | C
Y2 → C ⇒ Y2 → CD (weil D → C bereits entfernt)
C → D ⇒ C → C (wird entfernt)
D → C (kein Ersetzen mehr möglich)
damit Regeln insgesamt:
S → AY1
51
 Y1 → BC | XbY2 | b
A → XaY2 | a
B → Xb Y2 | b
Y2 → CD
D→C
Xa→a
Xb→b
f) Unnütze Variable entfernen (C, D, Y2, Xb):
S → AY1
Y1 → b
A→a

52
10.3. Bestimmen Sie mit Hilfe des CYK-Algorithmus, ob die Worte aaabbbcc und aacc in der
Sprache liegen, die durch die folgende Grammatik beschrieben wird
S → AB
A → CD | CF
B → c | EB
C→a
D→b
E→c
F → AD

53
10.4. Bestimmen Sie mit Hilfe des CYK-Algorithmus, ob das Wort baaba in derSprache liegt, die
durch die folgende Grammatik beschrieben wird
S → AB | BC
A → BA | a
B → CC | b
C → AB | a

54
10.5. Bestimmen Sie mit Hilfe des CYK-Algorithmus, ob das Wort baab in derSprache liegt, die
durch die folgende Grammatik beschrieben wird
S → AB | a
A → BA | a
B → AB | b

55
11. Kellerautomaten

11.1. Konstruieren Sie einen Nichtdeterministischen Kellerautomaten zur Sprache

L = {w1#w2#w3#wR | w1, w2, w3 ∈ {a,b}* und w ∈ { w1, w2, w3 }}
(Am Anfang stehen drei beliebige Worte aus a und b, am Ende steht eins dieser
Worte umgedreht.)

11.2. Beschreiben Sie die Sprachen, die von folgenden PDA akzeptiert werden

a.

L={anbm | n < m}
b.

L: gleiche Anzahl Nullen wie Einsen im Wort

56
c.

L: a’s gefolgt von b’s und c’s (gleiche Anzahl b und c)

57
12. Turingmaschinen

12.1.
q0 aabbbcc ⇒ x q1 abbbcc ⇒ xa q1 bbbcc ⇒ xay q2 bbcc ⇒ xayb q2 bcc ⇒
xaybb q2 cc ⇒ xayb q3 bzc ⇒ xay q3 bbzc ⇒ xa q3 ybbzc ⇒ x q3 aybbzc ⇒
q3 xaybbzc ⇒ x q0 aybbzc ⇒ xx q1 ybbzc ⇒ xxy q1 bbzc ⇒ xxyy q2 bzc ⇒
xxyyb q2 zc ⇒ xxyybz q2 c ⇒ xxyyb q3 zz ⇒ xxyy q3 bzz ⇒ xxy q3 ybzz ⇒
xx q3 yybzz ⇒ x q3 xyybzz ⇒ xx q0 yybzz ⇒ xxy q4 ybzz ⇒ xxyy q4 bzz ⇒ Halt (nicht
akzeptiert)!

12.2.

12.3.

58