Parser - Versionsgeschichte

Akaibel am 10. April 2024 um 06:58 Uhr

2024-04-10T06:58:01Z

← Nächstältere Version		Version vom 10. April 2024, 06:58 Uhr
Zeile 3:		Zeile 3:
	[[Kategorie:Informatik-Abitur]]		[[Kategorie:Informatik-Abitur]]
	[[Kategorie:Informatik]]		[[Kategorie:Informatik]]
	~~<font color='red'>'''nur relevant für den Leistungskurs!'''</font>~~
	=Fachbegriffe=		=Fachbegriffe=

Akaibel: /* Implementierung mit else if */

2022-01-23T18:10:50Z

Implementierung mit else if

← Nächstältere Version		Version vom 23. Januar 2022, 18:10 Uhr
Zeile 111:		Zeile 111:
	'''Die Implementierung mit <code>else if</code> ist vor allem für Klausuren geeignet, weil man sich so keine neue Syntax merken muss!'''		'''Die Implementierung mit <code>else if</code> ist vor allem für Klausuren geeignet, weil man sich so keine neue Syntax merken muss!'''

	<code>		<code>public boolean parse(String pWort){

	public boolean parse(String pWort){
	int zustand = 0;		int zustand = 0;
	for(int i=0; i<pWort.length(); i++){		for(int i=0; i<pWort.length(); i++){
Zeile 139:		Zeile 137:
	//zurueckgeben, ob der Zustand 3 erreicht wurde.		//zurueckgeben, ob der Zustand 3 erreicht wurde.
	return (zustand == 3);		return (zustand == 3);
	}		}</code>

	</code>

Akaibel: /* Implementierung mit switch-case */

2022-01-23T18:10:32Z

Implementierung mit switch-case

← Nächstältere Version		Version vom 23. Januar 2022, 18:10 Uhr
Zeile 42:		Zeile 42:
	<u>Hinweis:</u> Die Zustände werden duch '''Zahlen''' (<code>int</code>) abgebildet, die "Buchstaben" des zu prüfenden Wortes dagegen sind <code>char</code>, d.h. z.B. <code>'0'</code>		<u>Hinweis:</u> Die Zustände werden duch '''Zahlen''' (<code>int</code>) abgebildet, die "Buchstaben" des zu prüfenden Wortes dagegen sind <code>char</code>, d.h. z.B. <code>'0'</code>

	<code>		<code>import gui.GUI;
	import gui.GUI;

	public class KGBAutomat {		public class KGBAutomat {
Zeile 106:		Zeile 105:
	new GUI(new KGBAutomat());		new GUI(new KGBAutomat());
	}		}
	}		}</code>
	</code>

	=Implementierung mit <code>else if</code>=		=Implementierung mit <code>else if</code>=

Akaibel: /* Implementierung mit switch-case */

2020-03-31T12:48:54Z

Implementierung mit switch-case

← Nächstältere Version		Version vom 31. März 2020, 12:48 Uhr
Zeile 37:		Zeile 37:
	Die Implementierung mit switch-case bildet den Automaten ab.		Die Implementierung mit switch-case bildet den Automaten ab.

	'''Diese Implementierungsvariante ist nur bedingt klausurgeeignet.'''		'''Diese Implementierungsvariante ist nur bedingt klausurgeeignet.'''<br/>
			'''Für Klausuren nimmt man besser die Variante mit <code>else if</code>.'''

	~~'''Für Klausuren nimmt man besser die Variante mit <code>else if</code>.'''~~		<u>Hinweis:</u> Die Zustände werden duch '''Zahlen''' (<code>int</code>) abgebildet, die "Buchstaben" des zu prüfenden Wortes dagegen sind <code>char</code>, d.h. z.B. <code>'0'</code>
	<u>Hinweis:</u>Die Zustände werden duch '''Zahlen''' (<code>int</code>) abgebildet, die "Buchstaben" des zu prüfenden Wortes dagegen sind <code>char</code>, d.h. z.B. <code>'0'</code> !

	<code>		<code>
Zeile 108:		Zeile 108:
	}		}
	</code>		</code>

	=Implementierung mit <code>else if</code>=		=Implementierung mit <code>else if</code>=

Akaibel: /* Implementierung mit switch-case */

2020-03-31T12:46:47Z

Implementierung mit switch-case

@@ Zeile 31: / Zeile 31: @@
 Der KGB-Automat erkennt Wörter, die nur aus den Ziffern 0,...,9 bestehen und die irgendwo die Zahlenkette "007" enhalten.
 =Implementierung mit switch-case=
 Die Implementierung mit switch-case bildet den Automaten ab.
-Die Zustände werden duch Zahlen (<code>int</code>) abgebildet.
+'''Diese Implementierungsvariante ist nur bedingt klausurgeeignet.'''
 <code>
    import gui.GUI;
@@ Zeile 101: / Zeile 107: @@
+   }
+  }
 </code>

Akaibel am 29. März 2020 um 14:36 Uhr

2020-03-29T14:36:47Z

← Nächstältere Version		Version vom 29. März 2020, 14:36 Uhr
Zeile 3:		Zeile 3:
	[[Kategorie:Informatik-Abitur]]		[[Kategorie:Informatik-Abitur]]
	[[Kategorie:Informatik]]		[[Kategorie:Informatik]]
			<font color='red'>'''nur relevant für den Leistungskurs!'''</font>
	=Fachbegriffe=		=Fachbegriffe=

Akaibel: /* Begriffsklärung: Scanner, Parser, Interpreter */

2019-06-23T13:50:52Z

Begriffsklärung: Scanner, Parser, Interpreter

← Nächstältere Version		Version vom 23. Juni 2019, 13:50 Uhr
Zeile 4:		Zeile 4:
	[[Kategorie:Informatik]]		[[Kategorie:Informatik]]

			=Fachbegriffe=

			Scanner, Parser, Interpreter, Zustand, Wort, Buchstabe, switch-case
	=Begriffsklärung: Scanner, Parser, Interpreter=		=Begriffsklärung: Scanner, Parser, Interpreter=

	Ein '''Scanner''' zu einem Alphabet überprüft, ob ein Wort ausschließlich aus Buchstaben des Alphabets besteht.		Ein '''Scanner''' zu einem Alphabet überprüft, ob ein Wort ausschließlich aus Buchstaben des Alphabets besteht.

Akaibel: /* Implementierung mit switch-case */

2018-11-05T14:29:09Z

Implementierung mit switch-case

← Nächstältere Version		Version vom 5. November 2018, 14:29 Uhr
Zeile 35:		Zeile 35:
	Die Zustände werden duch Zahlen (<code>int</code>) abgebildet.		Die Zustände werden duch Zahlen (<code>int</code>) abgebildet.
	<code>		<code>
	import gui.GUI;		import gui.GUI;

	public class KGBAutomat {		public class KGBAutomat {
Zeile 42:		Zeile 42:

	'''public boolean imAlphabet(char pZeichen){'''		'''public boolean imAlphabet(char pZeichen){'''
	for(char zeichen: alphabet){		for(int i=0; i<alphabet.length; i++){
			char zeichen = alphabet[i];
	if(zeichen == pZeichen){		if(zeichen == pZeichen){
	return true;		return true;
Zeile 50:		Zeile 51:
	}		}

	// ueberprueft ~~das Wort nur akzeptierte~~ Buchstaben ~~enthaelt~~		// ueberprueft, ob pWort aus Buchstaben des Alphabets besteht
	'''public boolean scan(String pWort){'''		'''public boolean scan(String pWort){'''
	for(char zeichen: pWort.~~toCharArray~~()){		for(int i=0; i<pWort.length(); i++){
			char zeichen = pWort.charAt(i);
	if(!imAlphabet(zeichen)){		if(!imAlphabet(zeichen)){
	return false;		return false;
Zeile 59:		Zeile 61:
	return true;		return true;
	}		}


	~~// ueberprueft, ob das Wort vom Automaten akzeptiert wird.~~
	'''public boolean parse(String pWort){'''		'''public boolean parse(String pWort){'''
	//erst auf das Alphabet ueberpruefen		//erst auf das Alphabet ueberpruefen
Zeile 67:		Zeile 69:
	}		}
	int zustand = 0;		int zustand = 0;
	for(char zeichen: pWort.~~toCharArray~~()){		for(int i=0; i<pWort.length(); i++){
			char zeichen = pWort.charAt(i);
	switch(zustand){		switch(zustand){
	case 0: switch(zeichen){		case 0: switch(zeichen){
Zeile 91:		Zeile 94:
	return (zustand == 3);		return (zustand == 3);
	}		}

	public static void main(String[] args) {		public static void main(String[] args) {
	new GUI(new KGBAutomat());		new GUI(new KGBAutomat());

Akaibel: /* Implementierung mit switch-case */

2018-11-05T14:20:20Z

Implementierung mit switch-case

← Nächstältere Version		Version vom 5. November 2018, 14:20 Uhr
Zeile 33:		Zeile 33:
	Die Implementierung mit switch-case bildet den Automaten ab.		Die Implementierung mit switch-case bildet den Automaten ab.

			Die Zustände werden duch Zahlen (<code>int</code>) abgebildet.
	<code>		<code>

	import gui.GUI;		import gui.GUI;

	~~'''~~public class KGBAutomat {~~'''~~		public class KGBAutomat {

	~~'''~~private char[] alphabet~~'''~~ = {'0', '1', '2','3','4','5','6','7','8','9'};		private char[] alphabet = {'0', '1', '2','3','4','5','6','7','8','9'};

	'''public boolean imAlphabet(char pZeichen){'''		'''public boolean imAlphabet(char pZeichen){'''
	for(char zeichen: alphabet){		for(char zeichen: alphabet){
	if(zeichen == pZeichen){		if(zeichen == pZeichen){
	return true;		return true;
	}		}
	}		}
	return false;		return false;
	}		}

	'''public boolean scan(String pWort){'''		// ueberprueft das Wort nur akzeptierte Buchstaben enthaelt
	for(char zeichen: pWort.toCharArray()){		'''public boolean scan(String pWort){'''
	if(!imAlphabet(zeichen)){		for(char zeichen: pWort.toCharArray()){
	return false;		if(!imAlphabet(zeichen)){
	}		return false;
	}		}
	return true;		}
	}		return true;
			}

	'''public boolean parse(String pWort){'''		// ueberprueft, ob das Wort vom Automaten akzeptiert wird.
	//erst auf das Alphabet ueberpruefen		'''public boolean parse(String pWort){'''
	if(scan(pWort) == false){		//erst auf das Alphabet ueberpruefen
	return false;		if(scan(pWort) == false){
	}		return false;
	~~char~~ zustand = ~~'S'~~;		}
	for(char zeichen: pWort.toCharArray()){		int zustand = 0;
	switch(zustand){		for(char zeichen: pWort.toCharArray()){
	case ~~'S'~~: switch(zeichen){		switch(zustand){
	case '0': zustand = ~~'A'~~; continue;		case 0: switch(zeichen){
	default: zustand = ~~'S'~~; continue;		case '0': zustand = 1; continue;
	}		default: zustand = 0; continue;
			}
	case ~~'A'~~: switch(zeichen){
	case '0': zustand = ~~'B'~~; continue;		case 1: switch(zeichen){
	default: zustand = ~~'S'~~; continue;		case '0': zustand = 2; continue;
	}		default: zustand = 0; continue;
			}
	case ~~'B'~~: switch(zeichen){
	case '0': zustand = ~~'B'~~; continue;		case 2: switch(zeichen){
	case '7': zustand = ~~'C'~~; continue;		case '0': zustand = 2; continue;
	default: zustand = ~~'S'~~; continue;		case '7': zustand = 3; continue;
	}		default: zustand = 0; continue;
	case ~~'C'~~: switch(zeichen){		}
	default: zustand = ~~'C'~~; continue;		case 3: switch(zeichen){
	}		default: zustand = 3; continue;
	}		}
	}		}
	return (zustand == ~~'C'~~);		}
	}		return (zustand == 3);
			}
	public static void main(String[] args) {
	new GUI(new KGBAutomat());		public static void main(String[] args) {
	}		new GUI(new KGBAutomat());
			}
	}		}
	</code>		</code>

Akaibel: /* Funktionsweise des Parsers */

2017-11-24T20:18:25Z

Funktionsweise des Parsers

← Nächstältere Version		Version vom 24. November 2017, 20:18 Uhr
Zeile 18:		Zeile 18:
	=Funktionsweise des Parsers=		=Funktionsweise des Parsers=

	'''Ein Parser simuliert den zu der Grammatik gehörenden ~~Deterministischer Endlicher Automat\|~~Automaten'''.		'''Ein Parser simuliert den zu der Grammatik gehörenden Automaten'''.

	* Im folgenden wird der Parser für einen '''[[Deterministischer Endlicher Automat\|Deterministischen Endlichen Automaten]]''' beschrieben.		* Im folgenden wird der Parser für einen '''[[Deterministischer Endlicher Automat\|Deterministischen Endlichen Automaten]]''' beschrieben.