die entstehung dieses automats

zunächst ein mal die frage: wie ist sind diese automaten zu stande gekommen: ich habe ein python3 skript zu grund gelegt. die erste version geht so: die erste version ist diese hier

# (c) david vajda
# 08/27/2026
# python3, zustaende, vier zustaende 
# ... graph: schaltwerk, einfach 

import random
random.seed ()

V=[1,2,3,4]
V1=[1,2,3,4]
V2=[1,2,3,4]

print ("# (c) david vajda")
print ("# 08/27/2026")
print ("# python3, zustaende, vier zustaende") 
print ("# ... graph: schaltwerk, einfach")

i=3
while i >= 1:
	j1 = random.randint (0,i-1)
	j2 = random.randint (0,i-1)
	if i+1 in V1:
		yes1 = True
	else:
		yes1 = False 
	if i+1 in V2:
		yes2 = True
	else:
		yes2 = False
	if yes1:
		V1.remove (i+1)
	if yes2:
		V2.remove (i+1)
	v1 = V1 [j1]
	v2 = V2 [j2]
	V1.pop (j1);
	V2.pop (j2);
	if yes1:
		V1.append (i+1)
	if yes2:
		V2.append (i+1)
	
	print (i+1, " ", v1, " ", v2, " ") 	
	i = i - 1

v1 = V1.pop (0);
v2 = V2.pop (0);
print (i+1, " ", v1, " ", v2, " ")
erzeugt unter anderem diese ausgabe:
# (c) david vajda
# 08/27/2026
# python3, zustaende, vier zustaende
# ... graph: schaltwerk, einfach
4   3   2  
3   1   4  
2   4   1  
1   2   3

die vorgängerversion vom bisher letzten, der wohl offensichtlich seinen dienst tut ist die

# (c) david vajda
# 08/27/2026
# python3, zustaende, vier zustaende 
# ... graph: schaltwerk, einfach 

import random
random.seed ()

V=[1,2,3,4]
V1=[1,2,3,4]
V2=[1,2,3,4]

print ("# (c) david vajda")
print ("# 08/27/2026")
print ("# python3, zustaende, vier zustaende") 
print ("# ... graph: schaltwerk, einfach")

i=3
while i >= 1:
	j1 = random.randint (0,i-1)
	j2 = random.randint (0,i-1)
	if i+1 in V1:
		yes1 = True
	else:
		yes1 = False 
	if i+1 in V2:
		yes2 = True
	else:
		yes2 = False
	if yes1:
		V1.remove (i+1)
	if yes2:
		V2.remove (i+1)
	v1 = V1 [j1]
	if v1 in V2:
		yes11 = True
	else:
		yes11 = False
	if yes11:
		V2.remove (v1)
	v2 = V2 [j2]
	V1.pop (j1);
	V2.pop (j2);
	if (v1 != v2) and yes11:
		V2.append (v1)
	if yes1:
		V1.append (i+1)
	if yes2:
		V2.append (i+1)
	
	print (i+1, " ", v1, " ", v2, " ") 	
	i = i - 1

v1 = V1.pop (0);
v2 = V2.pop (0);
print (i+1, " ", v1, " ", v2, " ")
diese version enthält einen fehler und die ausgabe beim automaten wurden nicht berücksichtigt.

# (c) david vajda
# 08/27/2026
# python3, zustaende, vier zustaende 
# ... graph: schaltwerk, einfach 

import random
random.seed ()

V=[1,2,3,4]
V1=[1,2,3,4]
V2=[1,2,3,4]

print ("# (c) david vajda")
print ("# 08/27/2026")
print ("# python3, zustaende, vier zustaende") 
print ("# ... graph: schaltwerk, einfach")

i=3
while i >= 1:
	j1 = random.randint (0,i-1)
	j2 = random.randint (0,i-1)
	if i+1 in V1:
		yes1 = True
	else:
		yes1 = False 
	if i+1 in V2:
		yes2 = True
	else:
		yes2 = False
	if yes1:
		V1.remove (i+1)
	if yes2:
		V2.remove (i+1)
	v1 = V1 [j1]
	if v1 in V2:
		yes11 = True
	else:
		yes11 = False
	if yes11 and (i > 1):
		V2.remove (v1)
		j2 = random.randint (0,i-2)
	v2 = V2 [j2]
	V1.pop (j1);
	V2.pop (j2);
	if (v1 != v2) and yes11:
		V2.append (v1)
	if yes1:
		V1.append (i+1)
	if yes2:
		V2.append (i+1)
	
	print (i+1, " (", v1, ",", random.randint(0,1), ") (", v2, ",", random.randint(0,1), ")") 	
	i = i - 1

v1 = V1.pop (0);
v2 = V2.pop (0);
print (i+1, " (", v1, ",", random.randint(0,1), ") (", v2, ",", random.randint(0,1), ")")

dieser automat erzeugt zum beispiel folgende ausgabe:

davidvajda@localhost ~ % python3 graphautomat08272026C.py
# (c) david vajda
# 08/27/2026
# python3, zustaende, vier zustaende
# ... graph: schaltwerk, einfach
4  ( 2 , 0 ) ( 3 , 0 )
3  ( 1 , 1 ) ( 2 , 0 )
2  ( 4 , 0 ) ( 4 , 1 )
1  ( 3 , 0 ) ( 1 , 1 )
davidvajda@localhost ~ % python3 graphautomat08272026C.py
# (c) david vajda
# 08/27/2026
# python3, zustaende, vier zustaende
# ... graph: schaltwerk, einfach
4  ( 1 , 1 ) ( 3 , 1 )
3  ( 2 , 1 ) ( 1 , 1 )
2  ( 4 , 0 ) ( 4 , 0 )
1  ( 3 , 1 ) ( 2 , 1 )
davidvajda@localhost ~ % python3 graphautomat08272026C.py
# (c) david vajda
# 08/27/2026
# python3, zustaende, vier zustaende
# ... graph: schaltwerk, einfach
4  ( 2 , 1 ) ( 1 , 0 )
3  ( 4 , 0 ) ( 2 , 0 )
2  ( 1 , 0 ) ( 4 , 1 )
1  ( 3 , 1 ) ( 3 , 1 )
davidvajda@localhost ~ % python3 graphautomat08272026C.py
# (c) david vajda
# 08/27/2026
# python3, zustaende, vier zustaende
# ... graph: schaltwerk, einfach
4  ( 3 , 1 ) ( 1 , 0 )
3  ( 2 , 0 ) ( 4 , 0 )
2  ( 1 , 1 ) ( 3 , 0 )
1  ( 4 , 0 ) ( 2 , 0 )
davidvajda@localhost ~ % python3 graphautomat08272026C.py
# (c) david vajda
# 08/27/2026
# python3, zustaende, vier zustaende
# ... graph: schaltwerk, einfach
4  ( 3 , 0 ) ( 2 , 1 )
3  ( 1 , 1 ) ( 4 , 0 )
2  ( 4 , 0 ) ( 1 , 0 )
1  ( 2 , 0 ) ( 3 , 0 )
davidvajda@localhost ~ % python3 graphautomat08272026C.py
# (c) david vajda
# 08/27/2026
# python3, zustaende, vier zustaende
# ... graph: schaltwerk, einfach
4  ( 1 , 0 ) ( 3 , 0 )
3  ( 4 , 0 ) ( 2 , 1 )
2  ( 3 , 0 ) ( 1 , 0 )
1  ( 2 , 1 ) ( 4 , 0 )
davidvajda@localhost ~ % python3 graphautomat08272026C.py
# (c) david vajda
# 08/27/2026
# python3, zustaende, vier zustaende
# ... graph: schaltwerk, einfach
4  ( 1 , 0 ) ( 2 , 1 )
3  ( 4 , 0 ) ( 1 , 1 )
2  ( 3 , 1 ) ( 4 , 1 )
1  ( 2 , 1 ) ( 3 , 1 )
davidvajda@localhost ~ % python3 graphautomat08272026C.py
# (c) david vajda
# 08/27/2026
# python3, zustaende, vier zustaende
# ... graph: schaltwerk, einfach
4  ( 2 , 0 ) ( 3 , 1 )
3  ( 1 , 1 ) ( 2 , 1 )
2  ( 4 , 1 ) ( 4 , 0 )
1  ( 3 , 1 ) ( 1 , 1 )
davidvajda@localhost ~ % python3 graphautomat08272026C.py
# (c) david vajda
# 08/27/2026
# python3, zustaende, vier zustaende
# ... graph: schaltwerk, einfach
4  ( 1 , 1 ) ( 2 , 0 )
3  ( 4 , 0 ) ( 1 , 0 )
2  ( 3 , 0 ) ( 4 , 0 )
1  ( 2 , 0 ) ( 3 , 0 )
davidvajda@localhost ~ % python3 graphautomat08272026C.py
# (c) david vajda
# 08/27/2026
# python3, zustaende, vier zustaende
# ... graph: schaltwerk, einfach
4  ( 1 , 0 ) ( 2 , 0 )
3  ( 4 , 0 ) ( 1 , 1 )
2  ( 3 , 1 ) ( 4 , 1 )
1  ( 2 , 0 ) ( 3 , 1 )
davidvajda@localhost ~ % python3 graphautomat08272026C.py
# (c) david vajda
# 08/27/2026
# python3, zustaende, vier zustaende
# ... graph: schaltwerk, einfach
4  ( 1 , 1 ) ( 2 , 0 )
3  ( 4 , 1 ) ( 1 , 0 )
2  ( 3 , 1 ) ( 4 , 1 )
1  ( 2 , 1 ) ( 3 , 1 )
davidvajda@localhost ~ % python3 graphautomat08272026C.py
# (c) david vajda
# 08/27/2026
# python3, zustaende, vier zustaende
# ... graph: schaltwerk, einfach
4  ( 2 , 0 ) ( 1 , 0 )
3  ( 1 , 0 ) ( 4 , 0 )
2  ( 4 , 1 ) ( 3 , 1 )
1  ( 3 , 0 ) ( 2 , 1 )
davidvajda@localhost ~ % python3 graphautomat08272026C.py
# (c) david vajda
# 08/27/2026
# python3, zustaende, vier zustaende
# ... graph: schaltwerk, einfach
4  ( 1 , 0 ) ( 3 , 1 )
3  ( 2 , 0 ) ( 1 , 1 )
2  ( 4 , 1 ) ( 4 , 1 )
1  ( 3 , 0 ) ( 2 , 1 )
davidvajda@localhost ~ % python3 graphautomat08272026C.py
# (c) david vajda
# 08/27/2026
# python3, zustaende, vier zustaende
# ... graph: schaltwerk, einfach
4  ( 1 , 0 ) ( 3 , 1 )
3  ( 2 , 1 ) ( 1 , 0 )
2  ( 4 , 0 ) ( 4 , 0 )
1  ( 3 , 0 ) ( 2 , 1 )
davidvajda@localhost ~ % python3 graphautomat08272026C.py
# (c) david vajda
# 08/27/2026
# python3, zustaende, vier zustaende
# ... graph: schaltwerk, einfach
4  ( 2 , 0 ) ( 3 , 0 )
3  ( 1 , 0 ) ( 2 , 0 )
2  ( 4 , 0 ) ( 4 , 0 )
1  ( 3 , 0 ) ( 1 , 1 )
davidvajda@localhost ~ % python3 graphautomat08272026C.py
# (c) david vajda
# 08/27/2026
# python3, zustaende, vier zustaende
# ... graph: schaltwerk, einfach
4  ( 1 , 0 ) ( 2 , 0 )
3  ( 2 , 0 ) ( 1 , 0 )
2  ( 4 , 1 ) ( 4 , 0 )
1  ( 3 , 1 ) ( 3 , 0 )
davidvajda@localhost ~ % python3 graphautomat08272026C.py
# (c) david vajda
# 08/27/2026
# python3, zustaende, vier zustaende
# ... graph: schaltwerk, einfach
4  ( 2 , 0 ) ( 3 , 1 )
3  ( 1 , 0 ) ( 2 , 0 )
2  ( 4 , 1 ) ( 4 , 0 )
1  ( 3 , 1 ) ( 1 , 1 )
davidvajda@localhost ~ % python3 graphautomat08272026C.py
# (c) david vajda
# 08/27/2026
# python3, zustaende, vier zustaende
# ... graph: schaltwerk, einfach
4  ( 3 , 1 ) ( 1 , 1 )
3  ( 1 , 1 ) ( 4 , 1 )
2  ( 4 , 1 ) ( 3 , 0 )
1  ( 2 , 1 ) ( 2 , 0 )
davidvajda@localhost ~ % python3 graphautomat08272026C.py
# (c) david vajda
# 08/27/2026
# python3, zustaende, vier zustaende
# ... graph: schaltwerk, einfach
4  ( 3 , 1 ) ( 2 , 0 )
3  ( 2 , 0 ) ( 1 , 0 )
2  ( 1 , 0 ) ( 4 , 1 )
1  ( 4 , 1 ) ( 3 , 1 )
davidvajda@localhost ~ % python3 graphautomat08272026C.py
# (c) david vajda
# 08/27/2026
# python3, zustaende, vier zustaende
# ... graph: schaltwerk, einfach
4  ( 3 , 1 ) ( 2 , 1 )
3  ( 2 , 1 ) ( 1 , 1 )
2  ( 1 , 0 ) ( 4 , 1 )
1  ( 4 , 1 ) ( 3 , 1 )
davidvajda@localhost ~ % python3 graphautomat08272026C.py
# (c) david vajda
# 08/27/2026
# python3, zustaende, vier zustaende
# ... graph: schaltwerk, einfach
4  ( 2 , 0 ) ( 3 , 0 )
3  ( 1 , 0 ) ( 2 , 0 )
2  ( 4 , 0 ) ( 4 , 1 )
1  ( 3 , 1 ) ( 1 , 0 )
davidvajda@localhost ~ % python3 graphautomat08272026C.py
# (c) david vajda
# 08/27/2026
# python3, zustaende, vier zustaende
# ... graph: schaltwerk, einfach
4  ( 2 , 0 ) ( 1 , 1 )
3  ( 4 , 1 ) ( 2 , 0 )
2  ( 1 , 1 ) ( 4 , 1 )
1  ( 3 , 1 ) ( 3 , 1 )
davidvajda@localhost ~ % 
was haben wir eigentlich getan. in der fernuni-hagen hatte ich bei wohl noch weitere. für computersysteme 1.
und prüfung abgenommen, cornelia dallinger, computersysteme 1/2. hier werden, in computersysteme 1, die zustandsgraphen die automaten beschreiben zum thema (ausdruck). in algorithmischer mathematik wird die graphentheorie zum inhalt gemacht.

als ich auf die prüfung computersysteme 1/2 lernte, simulierte ich so mehr schlecht als recht automaten, um es zu üben, um so die prüfung mit einer 3.7 zu bestehen. ich weise sowohl auf die bestandene prüfung hin. zwar sind das benotete prüfungen was an der fernuni-hagen nicht die einzigen sind, sondern für den ba. sind sie mehr oder weniger pflicht und nur studenten mit abitur sind zu gelassen, ob sie sich nun den B.A. holen oder nicht. die unbenoteten prüfungen sind nicht immer einfach, nur: in diesem falle ist computersysteme 1/2 so wollte ich schon sagen, wohl das kalkül der technischen informatik überhaupt. die informatik besteht wohl aus drei säulen: technische, praktische und theoretische. ich denke aber die technische ist am ende die entscheidenste (a) - trotz allem - ist ansichtssache, aus meiner sicht. nicht nur: es gibt vielleicht verschiedene formen technische informatik zu prüfen, ich denke die einzig gültige ist am ende computersysteme 1/2. es ist eher das gesamte kalkül. wenn man an den automaten denkt, indem der computer mit mikroprogrammspeicherwerk, das programm in einer nicht veränderten version, deswegen doppelt so gross, wegen der verzweigung, wie in den eingescanten per hand geschriebenen dokumenten steht: dann ist technische informatik.... ein sehr starkes thema. ich möchte mich kurz fassen.

ich bin zu frieden. ich selber gedenke noch ein paar prüfungen zu tun, Bachelor hole ich mir eher nicht. etwas das ich versuchen werde ist wohl: algorithmische mathematik

und hier werden eben graphen beschrieben. das ist so oder so nicht irrelevant. aus folgendem grund:

in algorithmischer mathematik werden graphen vorgestellt. dabei

  1. tiefensuche
  2. breitensuche
  3. eulertour

die eulertour ist sehr interessant, gucken wir in meine homepage. sie bezieht sich auf graphen, die keine bäume sind. tiefen und breitensuche finden einen baum. in jedem graphen, sie verbinden, besonders mit stapel und schlangen, algorithmisch alle möglichen knoten im graph.

über das üben dieser habe ich gelernt die eulertour in python3 um zu setzen. wie hier, mit einer art, schlange oder stapel, jedenfalls elemente herausnehmen, erreichen wir bei einem graphen unkompliziert, dass mehr oder weniger: elemente mehr als nötig kanten zu nachbarn habe, dafür knoten ausgelassen werden, unzusammenhängende graphen, laut algorithmischer mathematik.

ok: ich möchte an dieser stelle auf unterschiede und gemeinsamkeiten zu meinen bisherigen übungen verweisen.

zunächst bevor ich diese graphentheorie kannte, hatte ich bei den nachbarn das übliche problem. am ende habe ich mehr oder weniger zufallszahlen genommen, durch umsortieren solange, bis es passt. das ist keine besonders gute lösung in der graphentheorie selber, aber nicht untersucht, (beispiel: permutation - umbennenung von knoten, wobei der name eines knotens generell keine rolle spielt - und ich weise darauf hin - da ich arabisch ebenso übe - und auch hieroglyphen hier auch frei schreiben will, aber beschlossen habe nicht mehr handschriftlich zu schreiben, werde ich vielleicht nicht unbedingt aber vielleicht auch diesen graphen hier mit arabischen ziffern ausstatten, z.B. Hieroglyphen, stuhl und tisch? oder eben binärkodiert).

ich möchte auf den unterschied der darstellung hinweisen, bezüglich des „Informatischen``inhalts. bzw. der darstellung in der technischen informatik.

hier sind automaten, das wurde bei meinen bisherigen übungen zunächst vernachlässigt, ich weise auf unterschiede und gemeinsamkeiten hin

  1. unär
  2. binär
kodiert. unär bedeutet, zunächst habe ich computersysteme 1/2 auswendig gelernt
von null beginnend, un"ar kodiert, konsekutiv nummeriert

wichtig ist, dass gegenbeispiel IP-Addresse

es taucht oft die verwirrung auf, jedenfalls bei mir damals am technischem gymnasium: gibt es, wenn man diese verwirrung zu wort bringt, IP-Addressen der form

1011 1101.0011 1010.0000 0000.0000 0000
nein es gibt nur:
...
1111 1111.1111 11111.1111 0000.0000 0000
...
1111 1111.0000 0000.0000 0000.0000 0000
1111 1110.0000 0000.0000 0000.0000 0000
1111 1100.0000 0000.0000 0000.0000 0000
..
0000 0000.0000 0000.0000 0000.0000 0000
das heisst, die msb 1er bit werden voll aufgefüllt. ein passendes beispiel von codes ist 2 aus 5. hier gibt es 2 einer bit in 5. dabei rueckt das lsb immer eines vor, bis die immer nach rechts (lsb) weiter vorrueckende grenze erreicht ist. inzwischen rueckt das msb 1er bit vor. darauf hin das lsb 1er bit zu der grenze die darauf nach rechts vorrueckt, waehrend das msb 1er bit wieder auf den anfang zurueck geht.

das entspricht so einem vorgang, als beispiel einer schiften, oder ip-addresse, aber eben zerfaellt die sache hier.

ein anderes beispiel ist die unäre kodierung. striche an die wand machen, beim aller einfachsten zaehlen, bedeutet ip-addresse. denken wir an: dekodierer, ich weise darauf hin, es gibt:
  1. kodierer
  2. dekodierer
  3. multiplexer
  4. demultiplexer
ein dekodierer liesse sich noch einigermassen mit einem demultiplexer erreichen, wuerde ich aus dem kopf sagen. ich weise aber auf eindeutigen unterschiede hin.

ein dekodierer ist ein kodierer.

ein multiplexer ist quasi ein element, was serialisiert - als multiplexed. (rs232 - v.24) - es legt ein 8 bit breites byte mit einem takt - zeitlich auf eine leitung. das gegenteil ist der demultiplexer. ein dekodierer ist immer noch ein kodierer (DIN 44300/183) (siehe auch: DIN 40700, DIN 40900) ist ein schaltnetz, das die zeichen eines zeichenvorrats in die zeichen eines andereren zeichenvorrats umsetzt (Computersysteme 1/2). ok: blos: ein zeichen in der informatik ist binär kodiert (siehe BCD: ausser am Sichtgeraet: siehe BCD und Abakus, warum: die perlen im Abakus, sind in einer zeile das was eine ziffer, arabisch und indisch ist (oder chinesisch), und die binärkodierung am LCD HD 44780, kann eben Chinesisch, arabisch, hebraeisch, inka, maja, azteken, brahmanische schriften, latein und so weiter sein). ok: BCD, entspricht trotzdem einer möglichen anderer kodierung der Arabischen bzw. indischen ziffern.

ok: ein dekodierer wiederum ist ein kodierer. das heisst, der zielzeichenvorrat ist von der wortbreite wohl meist ein weniger kleiner oder manchmal vielleicht ein weniger groesser, oder gleich, eher gleich oder kleiner, wie die in der quelle. ausgangsmenge. wie auch immer. der dekodierer ist ein kodierer. und zwar: einer bei dem für jedes zeichen in der ausgangsmenge immer nur eine leitung gleichzeitig an ist.

ok: man kann also hier sehen: unär kodierung entspricht jetzt eher dem, das bit wandert, wie geschiftet.

typischer befehl: SLL, SLR - shift logical left/right. wenn ein bit im quelloperanden, 1 ist dann prima. ok:

andere unterschiede:
  1. würde ich von der binären kodierung ausgehen, was laut computersysteme 1/2 möglich ist, dann: gibt es einen vorteil, die bitbreite ( $lg(ceil(n))$ - oder floor. da ich hier romane schreibe wie also auf dem papier, sage ich hier ehrlich was sache ist. es gibt den 2er, 10er und $e$ logarithmus, das erkläre ich hier nicht. der 10er logarithmus ist wohl ld und der 2er logarithmus wohl: lg wobei ich nachschauen könnte, jetzt aber verzichte, eine andere schreibweise und die ist immer möglich: ($log_2$), also die basis unten angeben, das ist das üblichste, ich glaube, das d steht fuer dezimal. und ich glaube, bei dem Dezibel wird $ld\left(\dfrac{P_{in}}{P_{out}}\right)$ benutzt, eingangs und ausgangsleistung, laesst sich wohl auch umdrehen, jedenfalls, dezibel, im gegensatz, zum bel und ich glaube da steht, ld. 10er. so: ansonsten basis unten angeben. wo ceil und wo floor liegt weiss ich nie.

    jedenfalls: man muss aufrunden und den 2er logarithmus auf die anzahl der knoten anlegen, und wenn ich das habe. dann erhaelte ich die bitbreite. ok:

    etwas, das die sache nun klassisch verändern würde ist folgendes: brauche ich beim binären einen addierer? habe ich damit alles falsch gemacht?

    1. ich sage: ja und nein, nein deswegen weil es schaltet, trotzdem krotten falsch, warum?
    2. weil wir in computersysteme 1 und 2 gelernt haben: übergangsschaltnetz und ausgangsschaltnetz.
    3. die zustände selber sollten einfach fluppen, ok: hier ist es alles andere als krotten falsch, warum? weil ich mit addieren durch die graphentheorie nicht weit komme, eben dann sind graphen nicht einfach durch permutation eigentlich der gleiche, sondern wenn ihre kanten sich massgeblich unterscheiden. ok: addition hilft hier nichts
    4. die aeussere darstellung ist aufgabe des uebergangsschaltnetz. und leider trotzdem falsch.
    5. warum? eben deswegen nehme ich hier: unär und eben deswegen: mealy und moore und ich nehme unär
    6. denn: ein unäres schaltwerk von den zuständen einfach durch schiften. über das übergangsschaltnetz was nun kein addierer ist, einfach dann mit der eingabe die naechsten zustand erzeugen. falsch ist: mealy erfordert: bei der ausgabe wird die eingabe mitgenommen
    7. doch damit ist die sache nicht falsch. denn erstens ist der addierer ein schaltnetz und zweitens: auch beim unären entstehen hier variationen...
ok: wo weit so gut, nur:

es gibt noch hinsichtlich der tabelle alternative darstellungen. was in der mathematik üblich wäre.

das habe ich mir im smartphone auf facebook gemerkt:

a war so noch ein Fehler, der ist behoben das war klar, der ist so noch behoben plus, dass ich jetzt die Kanten habe

Das schreib ich dir noch rein in das PDF, was ich mache, wenn wir eine Null oder eins zu dem Zustand haben bei mealy kann man sozusagen die Ausgabe als Wort begreifen.

Daraus ein Baum machen, aber nur bedingt, weil das ist dann ein pattern  Matching

Was ich damit endlich beschreiben kann, was nichts mit KMP zu tun hat, sondern halten Automat

Das Problem bei dem Baum ist ja ich kann jetzt von einem Knoten aus dem Baum beschreiben für das Ausgabe Wort Y zum Beispiel weil ich aber zurückkehren gibt es beliebig Wiederholung und es macht er sozusagen also ein mögliches Wort oder mehrere Wörter und es macht ja pattern  Matching aus

Schreibe ich ins PDF rein wie gesagt aber auch noch ein Fehler

Den hab ich behoben bloß der Unterschied ist

Am was bei Algorithmen in C steht

Robert sedgewick
Heißt das der sozusagen der Compiler für die formale Sprache an der Stelle, die sich auch in bakus naur Form für arithmetische Ausdrücke geeignet ist das nur dazu da diesen Automaten herzustellen, hat mit KMP trotzdem nichts zu tun und hier kommt jetzt die richtige Version, ohne den Fehler zu machen, aber auch mit ein und null Ausgabe und dann mache ich das ins PDF rein und dann kommt aber noch schalte wie gesagt dazu entweder mit kaneda oder gleich nur in Latex
ich bin dahinter gekommen, dass: und das ist mir wichtig, dass eigentlich: ein mikroprogrammsteuerwerk genauso harter speicher wie bei der havard architektur sein könnte wie: diese selber, aber einen doppelten speicher braucht, wegen der möglichen verzweigung oder die addresse ist im wort (konstante, immidiate) im wort fuer das operationswerk vorhanden, oder andere version: weil es nicht immer nur bedingungen gibt, ein kleiner speicher hinten angehaengt.

ok. das ist die eine erkenntnis, wie ich sie in den papieren habe, die hier anhaenge. das andere ist aber: das bezog sich nicht darauf.