faecher:informatik:oberstufe:automaten:regulaere_ausdruecke:start []

Diese Seite ist nicht editierbar. Du kannst den Quelltext sehen, jedoch nicht verändern. Kontaktiere den Administrator, wenn du glaubst, dass hier ein Fehler vorliegt.
====== Beschreibung regulärer Sprachen mit regulären Ausdrücken ======

Reguläre Sprachen können außer durch eine Grammatik auch durch sogenannten **reguläre Ausdrücke** beschrieben werden.

===== Grundlegende reguläre Operatoren =====


Reguläre Ausdrücke formuliert man mit regulären Operatoren. Die wichtigsten regulären Operatoren sind die folgenden: 

  * ''a*'' - "a-Stern": a beliebig oft (auch 0 mal) hintereinander
  * ''ab'' - Verkettung: ein a, dann ein b
  * ''a|b'' - Oder: entweder ein a oder ein b
  * Mit runden Klammern ''()'' können Teilausdrücke gruppiert werden

=== Beispiele ===

**(1)**  ''α<sub>1</sub> = c*h*'' beschreibt alle Zeichenketten, die zunächst aus beliebig vielen Buchstaben ''c'' bestehen und anschließend aus beliebig vielen Buchstaben ''h''. (("Erst beliebig viele c's, dann beliebig viele h's" - wobei "beliebig viele auch "keines" bedeuten kann.)). L<sub>1</sub>={ε,c,h,ccch,ccchhh,hhhh,cc,...}.

**(2)** ''α<sub>2</sub> = c*|h*'' beschreibt die alle Zeichenketten, die entweder nur aus ''c'''s oder nur aus ''h'''s bestehen. L<sub>2</sub>={ε,c,h,cc,hh,ccc,hhh,...}.

**(3)** ''α<sub>3</sub> = (c|h)*'' beschreibt die alle Zeichenketten, die aus beliebig vielen ''c'''s und ''h'''s bestehen. L<sub>3</sub>={ε,c,h,hc,ch,ccc,hchh,...}.

----
{{:aufgabe.png?nolink  |}}
=== (A1) ===

Welche Sprachen werden durch die folgenden regulären Ausdrücke beschrieben? Liste eine Beispielmenge von akzeptierten Wörtern auf, aus der hervorgeht, welche Regeln gelten.

**(A)** ''α<sub>4</sub> = 01*0'' ++L=|{00, 010, 0110, 01110, 011110, 0111110, ...}++

**(B)** ''α<sub>5</sub> = (01)*'' ++L=|{ε, 01, 0101, 010101, 01010101, 0101010101,...  }++

**(C)** ''α<sub>6</sub> = 0|(10*)*'' ++L=|{ε, 0, 1, 10, 100, 1000, 11, 101, 10100, 100100, ...  }++

**(D)** ''α<sub>7</sub> = (1(110)*)*'' ++L=|{ε, 1, 1110, 1110110, 11, 11101110, ...  }++

**(E)** ''α<sub>8</sub> = 1(1*|10*)'' ++L=|{1, 11, 111, 1111, 11111, 110, 1100, 11000, ...  }++

**(F)** ''α<sub>9</sub> = 0|1*|10*'' ++L=|{ε, 0, 1, 11, 111, 1111, 10, 100, 1000, 10000, ...  }++

**(G)** ''α<sub>10</sub> = 1*0*(0|1)'' ++L=|{ 0, 1, 10, 11, 110, 111, 11001, 1110001, ... }++






===== Erweiterte reguläre Ausdrücke =====
 
Mit der "Minimalausstattung" von drei Operatoren (ohne die Klammern) lassen sich im Prinzip schon alle regulären
Ausdrücke schreiben. Bequemer, kürzer und übersichtlicher geht es, wenn man weitere Operatoren hinzunimmt, hier ist allerdings zu beachten, dass es unterschiedliche "Dialekte" solcher Erweiterungen gibt. 

Die meisten Programmiersprachen verfügen über Funktionen oder Bibliotheken, um Strings anhand von regulären Ausdrücken zu finden. Meist gibt es auch weitere Funktionen wie Rückbezüge, mit denen sich komplexe Ersetzungen und Ähnliches realisieren lassen.

Typische Erweiterungen umfassen die folgenden Elemente:

  * Eckige Klammern fassen Zeichengruppen zusammen. Der Ausdruck ''[0-9]'' bedeutet "die Ziffern von 0 bis 9", ''[0-9]*'' bedeutet entsprechend "beliebig oft eines der Zeichen von 0-9. Bislang hätten wir dafür ''(0|1|2|3|4|5|6|7|8|9)*'' schreiben müssen.
  * ''[abc]'' – der Buchstabe a, b oder c.
  * ''[a-zA-Z]'' – einer der Buchstaben A bis Z, groß und klein.
  * ''.''((Punkt)) – ein beliebiges Zeichen.
  * ''[^abc]'' – jedes Zeichen außer den Buchstaben a, b und c ((Hier bedeutet das ''^'' gewissermaßen "nicht"))
  * Wenn man ein Zeichen suchen will, das eigentlich eine Spezialbedeutung hat, muss man es escapen, meist mit einem Backslash: ''[\[a-z\]]'' - erst ein [, dann ein Buchstabe a bis z dann ein ].
  * Der Anfang einer Zeile kann durch durch ein ''^'' gematcht werden, das Ende durch ein ''$''.
  * Ein ''*'' bedeutet wie bisher, dass beliebig viele Zeichen der vorherigen Gruppe gesucht werden ''^[aeiou]*n$'' – findet n, an, en, in, on, un, aan, aaan, aen, ein, ... sofern sie in einer Zeile stehen.
  * ''a{2,5}'' - 2 bis 5 Vorkommen des Buchstabens a.
  * ''b+'' - mindestens ein Vorkommen des Buchstabens b ((Unterschied zu ''*'': Beliebig oft, aber **nicht** kein mal)).


----
{{:aufgabe.png?nolink  |}}
=== (A2) ===

Schreibe die Ausdrücke ''[abc]'', ''b+'' und ''a{2,4}'' mit Hilfe der elementaren regulären Operatoren auf.

----
{{:aufgabe.png?nolink  |}}
=== (A3) ===

Bearbeite das Tutorial unter https://regexone.com/, um mit den erweiterten regulären Operatoren vertraut zu werden.



===== Sandkasten bei regex101.com =====

Auf der Seite https://regex101.com/ kannst du reguläre Ausdrücke testen. Außerdem werden die Ausdrücke und Matches erklärt.

{{ :faecher:informatik:oberstufe:automaten:regulaere_ausdruecke:bildschirmfoto_vom_2023-03-06_18-52-21.png |}} 

----
{{:aufgabe.png?nolink  |}}
=== (A4) ===

Öffne die Seite https://regex101.com/ und sorge dafür, dass die Einstellungen wie im Screenshot zusehen angepasst sind((Regex Flavor ''Java 8'', Funktion ''Match'', regex Optionen ''gm''))

Überprüfe jetzt deine Ergebnisse aus Aufgabe 1, indem du den regulären Ausdruck in die Eingabezeile "regular Expression" schreibst und die zu testenden Wörter der regulären Sprache in das Feld "Test String", pro Zeile ein Wort. 
<callout type="warning" icon="true"> 

Achtung: Weil die regulären Ausdrücke nach der Greedy Strategie angewandt werden, musst du deine regulärer Ausdruck inklusive Zeilenanfang (''^'') und Zeilenende (''$'') testen, sonst klappts nicht - siehe Screenshot. Probiere einfach aus, was passiert, wenn du diese beiden Zeichen weglässt. Wenn du Groß und Kleinschreibung nicht unterscheiden möchtest, musst du die Option ''i'' für Case-Insensitive setzen.
</callout>


----
{{:aufgabe.png?nolink  |}}
=== (A5) Übungen ===

Füge die etwa 180000 Worte, die in {{ :faecher:informatik:oberstufe:automaten:regulaere_ausdruecke:worte.zip |dieser Datei}} enthalten sind in das "Test String"-Feld bei regex101.com ein.

Formuliere anschließend reguläre Ausdrücke, um die folgenden Wörter zu finden. Groß- und Kleinschreibung soll nicht berücksichtigt werden - siehe oben für die Bedeutung der Option ''i''.

  - Alle Wörter, die die Zeichenfolge ''mc'' enthalten (zu erwarten: 35 Treffer)
  - Alle Wörter, die mit ''lau'' beginnen und danach noch genau einen weiteren Buchstaben enthalten (12 Treffer)
  - Alle Wörter, die mit ''L'' beginnen und mit ''cht'' enden (31 Treffer)
  - Alle Wörter, die mit einem Vokal enden (36218 Treffer)
  - Alle Wörter, die mit ''d'', ''r'' oder ''t'' beginnen und mit ''a'', ''g'' oder ''l'' enden (1258 Treffer)
  - Alle Wörter, die mindestens zwei ''u'' enthalten (13749 Treffer)
  - Alle Wörter, die ein doppeltes ''u'' (also ''uu'') enthalten (67 Treffer)
  - Alle Wörter, die aus sechs Buchstaben bestehen (6722 Treffer)
  - Alle Wörter, die höchstens fünf Buchstaben lang sind (7018 Treffer)
  - Alle Wörter, die mindestens 15 Buchstaben lang sind (38518 Treffer)
  - Alle Wörter, die aus sechs Buchstaben bestehen und deren dritter Buchstabe ein ''t'' ist (344 Treffer)
  - Alle Wörter, die die Vokale ''a'', ''e'', ''i'', ''o'' und ''u'' in dieser Reihenfolge und genau einmal enthalten. (1 Treffer)
  - Alle Wörter, die ein ''y'' enthalten, aber kein ''a''. (885 Treffer)


----
{{:aufgabe.png?nolink  |}}
=== (A6) Gültige Telefonnummern ===

Es soll erkannt werden, ob ein String das
korrekte Format für eine Telefonnummer hat.

Für uns soll eine korrekte Telefonnummer zunächst aus folgenden Bestandteilen zusammengesetzt sein:

  * Einer Vorwahl, die mit einer 0 beginnt und danach mindestens eine andere Ziffer enthält.
  * Einem der folgenden Zeichen zur Abtrennung der Vorwahl: ''-'', ''/'' oder Leerzeichen
  * Einer mindestens einstelligen Zahl, die nicht mit 0 beginnt.

Erstelle einen regulären Ausdruck, der in der folgenden Liste von Ziffernfolgen alle korrekten Telefonnummern erkennt. 

++++ Liste |
<code telefonnummern.txt>
07071-12345
17071-12345
07071 12345
07071 02345
0721  1654
171-8867524
07473/138652
0049-12345
</code>

++++