kennt sich jemand mit endlichen automaten aus?

H

Heyoka955

Gast
wir haben im fach cl ein blatt aufbekommen und ich habe das in der Vorlesung nul verstanden, und ich brauche hilfe bei Automaten vorallem.

also aufgabe 1
 

Anhänge

  • homework-fsa.pdf
    92,2 KB · Aufrufe: 29
X

Xyz1

Gast
Hier mal Aufgabe 1 (1. 2. 3.), ohne nicht akzeptierenden Zustand:

11653

Bei Fehlern einfach laut "Hier!" rufen. :D
 

httpdigest

Top Contributor
Bei Fehlern einfach laut "Hier!" rufen. :D
Hier! :)

Ich würde argumentieren, dass dein erster Automat für "w enthält genau ein a" falsch ist. Er landet auch für das Wort w="aaa" im akzeptierenden Endzustand q1. Du hast zwar geschrieben "ohne nicht akzeptierenden Zustand", aber den braucht man definitiv, bzw brauchst du einfach mehr Zustände, um von q1 mit einem weiteren 'a' wieder wegzukommen zu einem Zustand, den man nicht mehr verlassen kann.

Dein zweiter Automat ist auch falsch, da hier nicht gelten muss, dass "jedes 'a' in w folgt unmittelbar auf ein 'b'". Dein Automat akzeptiert ja auch w="baaaa" (in diesem Wort folgt eben nicht jedes 'a' unmittelbar auf ein 'b').

Der dritte Automat ist ebenfalls falsch, da er w="b" sowie w="bb" und auch w="ababa" nicht erkennt.
 
H

Heyoka955

Gast
Hier! :)

Ich würde argumentieren, dass dein erster Automat für "w enthält genau ein a" falsch ist. Er landet auch für das Wort w="aaa" im akzeptierenden Endzustand q1. Du hast zwar geschrieben "ohne nicht akzeptierenden Zustand", aber den braucht man definitiv, bzw brauchst du einfach mehr Zustände, um von q1 mit einem weiteren 'a' wieder wegzukommen zu einem Zustand, den man nicht mehr verlassen kann.

Dein zweiter Automat ist auch falsch, da hier nicht gelten muss, dass "jedes 'a' in w folgt unmittelbar auf ein 'b'". Dein Automat akzeptiert ja auch w="baaaa" (in diesem Wort folgt eben nicht jedes 'a' unmittelbar auf ein 'b').

Der dritte Automat ist ebenfalls falsch, da er w="b" sowie w="bb" und auch w="ababa" nicht erkennt.
ich hane echt keine Ahnung von dem Thema, hoffe dass der prof das morgen erklärt in theoretische Informatik ansonsten bye !!!
ich habe chiermosky Hierarchie alles verstanden.
 
H

Heyoka955

Gast
kannst du mir vllt erklären was die aufgabe verlangt?



The depth of an integer n is defined to be how many multiples of n it is necessary to compute before all 10 digits have appeared at least once in some multiple.


example:

let see n=42

Multiple value digits comment
42*1 42 2,4
42*2 84 8 4 existed
42*3 126 1,6 2 existed
42*4 168 - all existed
42*5 210 0 2,1 existed
42*6 252 5 2 existed
42*7 294 9 2,4 existed
42*8 336 3 6 existed
42*9 378 7 3,8 existed

Looking at the above table under digits column you can find all the digits from 0 to 9, Hence it required 9 multiples of 42 to get all the digits. So the depth of 42 is 9. Write a function named computeDepth which computes the depth of its integer argument.Only positive numbers greater than zero will be passed as an input.
 
X

Xyz1

Gast
"w enthält genau ein a"
Scheiße, ich habe das "genau ein" überlesen... Dann muss bei "a, b" das "a, " gestrichen werden.

Dein zweiter Automat ist auch falsch,
Das musst du genau lesen ;) "b über a" bedeutet hier, a v.l.n.r. und b v.r.n.l. ... Das heißt, ein zusätzliches a in q2 wäre unzulässig/ nicht akzeptierend - und damit wärs richtig.

Der dritte Automat ist ebenfalls falsch,
Ja das stimmt... Obwohl ich mir viel Mühe bei gegeben habe, müssen da überall noch b-Kringel dran...

Gut das man nochmal darüber diskutiert... Aber auch DEAs mit impliziten, nicht akzeptierenden Endzuständen können formal korrekt sein... wenn man schreibfaul ist. :D

@Heyoka955 Die anderen/ übrigen Aufgaben leiten sich eigentlich daraus ab, wenn man erstmal den Anfang hat...
 
H

Heyoka955

Gast
Scheiße, ich habe das "genau ein" überlesen... Dann muss bei "a, b" das "a, " gestrichen werden.


Das musst du genau lesen ;) "b über a" bedeutet hier, a v.l.n.r. und b v.r.n.l. ... Das heißt, ein zusätzliches a in q2 wäre unzulässig/ nicht akzeptierend - und damit wärs richtig.


Ja das stimmt... Obwohl ich mir viel Mühe bei gegeben habe, müssen da überall noch b-Kringel dran...

Gut das man nochmal darüber diskutiert... Aber auch DEAs mit impliziten, nicht akzeptierenden Endzuständen können formal korrekt sein... wenn man schreibfaul ist. :D

@Heyoka955 Die anderen/ übrigen Aufgaben leiten sich eigentlich daraus ab, wenn man erstmal den Anfang hat...
ich setzet mich mit kollegen da ran und machen die dann.
 

mihe7

Top Contributor
Die Bedingung, dass ein Wort w genau ein "a" enthält bedeutet ja nichts anderes, als dass
1. das Wort mit beliebig vielen (auch 0) "b" beginnen darf,
2. auf den (ggf. leeren) Wortanfang ein "a" folgen muss und
3. anschließend beliebig viele weitere "b" folgen dürfen

ad 1.: das lässt sich mit einem Startzustand, nennen wir ihn mal q0, realisieren, der durch ein "b" auf sich selbst überführt wird. Diesen Zustand kann man sich als "habe bisher noch kein 'a' gesehen"-Zustand vorstellen. Dieser Zustand darf nicht zugleich Endzustand sein, da noch kein "a" im Wort vorhanden ist.

ad 2.: wurde im Startzustand kein "b" sondern ein "a" gelesen, geht der Automat in einen neuen Zustand, nennen wir ihn mal q1, über. Das ist der Zustand "habe bereits ein 'a' gesehen". Das muss ein Endzustand sein, denn die Voraussetzung, dass das Wort ein a enthält, ist dort erfüllt.

ad 3.: hat man bereits ein "a" gelesen (Automat ist im Zustand q1), können beliebig viele weitere "b" folgen. Das erreicht man wie unter 1, indem man den Zustand auf sich selbst überführt.

Für einen Automaten A=(Q, s, S, F, d) mit der Zustandsmenge Q:={q0, q1}, dem Startzustand s:={q0}, dem Eingabealphabet S:={a,b}, dem Endzustand F:={q1} kann dann die Übergangsfunktion d: Q x S -> Q wie folgt angegeben werden: d:={(q0, b, q0), (q0, a, q1), (q1, b, q1)}

Den Rest kannst Du selber machen.
 
X

Xyz1

Gast
Danke @mihe7 für diese "vollumfängliche" Erklärung von Dir. Zusammen mit der "bildlichen" Darstellung hätte er damit für Aufgabe 1 1. die volle Punktzahl, denke ich (wo will man noch etwas hinzufügen? usw).

Die andere Sache ist die... dass er in der Vorlesung (angeblich) gar nichts versteht... ? Warum nicht? Woran liegt das? Was müsste sich ändern? usw usf.
 

mihe7

Top Contributor
Die andere Sache ist die... dass er in der Vorlesung (angeblich) gar nichts versteht... ? Warum nicht? Woran liegt das? Was müsste sich ändern? usw usf.
Ja, darum habe ich das mal sehr ausführlich gemacht und auch nur für die erste (= einfachste) der Aufgaben :) Warum er in der Vorlesung nichts verstanden hat, weiß ich nicht. Die Funktionsweise von Automaten ist ja nun wirklich nicht so schwer zu verstehen. Ich hoffe halt für ihn, dass er aus der Erklärung was mitnehmen kann, bekomme aber Zweifel, wenn ich lese "und machen die dann."
 
X

Xyz1

Gast
So kommen wir nicht weiter. :( "und mache die dann" kann auch einfach nur so dahingeschrieben sein... Ich lege mich jetzt schlafen, habe schon die Befürchtung, dass noch um 3 Uhr wieder Beiträge geschrieben werden heute/morgen... Bis dann. :D
 
H

Heyoka955

Gast
Ja, darum habe ich das mal sehr ausführlich gemacht und auch nur für die erste (= einfachste) der Aufgaben :) Warum er in der Vorlesung nichts verstanden hat, weiß ich nicht. Die Funktionsweise von Automaten ist ja nun wirklich nicht so schwer zu verstehen. Ich hoffe halt für ihn, dass er aus der Erklärung was mitnehmen kann, bekomme aber Zweifel, wenn ich lese "und machen die dann."
so ? zu 1 und 2
 

Anhänge

  • theo.png
    theo.png
    1,1 MB · Aufrufe: 62

mihe7

Top Contributor
Nein. Bei Aufgabe 1 fehlt mind. eine Kante, bei Aufgabe 2 hast Du Kanten ohne Beschriftung und bei Aufgabe 3 keinen Endzustand.
 
X

Xyz1

Gast
@httpdigest So falsch war meins gar nicht... sogar verdammt nah an richtig...

null bedeutet nicht akzeptierender Endzustand, true akzeptiert, false nicht akzeptiert und (f) steht an Endzuständen dran:
Java:
    List<Uebergang> a = List.of(
            new Uebergang("q0", "b", "q0", false),
            new Uebergang("q0", "a", "q1", true),
            new Uebergang("q1", "b", "q1", true));
    test(a);

    List<Uebergang> b = List.of(
            new Uebergang("q0", "b", "q1", true),
            new Uebergang("q1", "b", "q1", true),
            new Uebergang("q1", "a", "q2", true),
            new Uebergang("q2", "b", "q1", true));
    test(b);

    List<Uebergang> c = List.of(
            new Uebergang("q0", "b", "q0", true),
            new Uebergang("q0", "a", "q1", false),
            new Uebergang("q1", "b", "q1", false),
            new Uebergang("q1", "a", "q2", false),
            new Uebergang("q2", "b", "q2", false),
            new Uebergang("q2", "a", "q3", true),
            new Uebergang("q3", "b", "q0", true),
            new Uebergang("q3", "a", "q1", false));
    test(c);

Code:
Testing [(q0,b,q0), (q0,a,q1(f)), (q1,b,q1(f))]:
aaaa => null
aaab => null
aaba => null
aabb => null
abaa => null
abab => null
abba => null
abbb => true
baaa => null
baab => null
baba => null
babb => true
bbaa => null
bbab => true
bbba => true
bbbb => false
Testing [(q0,b,q1(f)), (q1,b,q1(f)), (q1,a,q2(f)), (q2,b,q1(f))]:
aaaa => null
aaab => null
aaba => null
aabb => null
abaa => null
abab => null
abba => null
abbb => null
baaa => null
baab => null
baba => true
babb => true
bbaa => null
bbab => true
bbba => true
bbbb => true
Testing [(q0,b,q0(f)), (q0,a,q1), (q1,b,q1), (q1,a,q2), (q2,b,q2), (q2,a,q3(f)), (q3,b,q0(f)), (q3,a,q1)]:
aaaa => false
aaab => true
aaba => true
aabb => false
abaa => true
abab => false
abba => false
abbb => false
baaa => true
baab => false
baba => false
babb => false
bbaa => false
bbab => false
bbba => false
bbbb => true

Damit ist Aufgabe 1 jetzt gelöst.
 
H

Heyoka955

Gast
@httpdigest So falsch war meins gar nicht... sogar verdammt nah an richtig...

null bedeutet nicht akzeptierender Endzustand, true akzeptiert, false nicht akzeptiert und (f) steht an Endzuständen dran:
Java:
    List<Uebergang> a = List.of(
            new Uebergang("q0", "b", "q0", false),
            new Uebergang("q0", "a", "q1", true),
            new Uebergang("q1", "b", "q1", true));
    test(a);

    List<Uebergang> b = List.of(
            new Uebergang("q0", "b", "q1", true),
            new Uebergang("q1", "b", "q1", true),
            new Uebergang("q1", "a", "q2", true),
            new Uebergang("q2", "b", "q1", true));
    test(b);

    List<Uebergang> c = List.of(
            new Uebergang("q0", "b", "q0", true),
            new Uebergang("q0", "a", "q1", false),
            new Uebergang("q1", "b", "q1", false),
            new Uebergang("q1", "a", "q2", false),
            new Uebergang("q2", "b", "q2", false),
            new Uebergang("q2", "a", "q3", true),
            new Uebergang("q3", "b", "q0", true),
            new Uebergang("q3", "a", "q1", false));
    test(c);

Code:
Testing [(q0,b,q0), (q0,a,q1(f)), (q1,b,q1(f))]:
aaaa => null
aaab => null
aaba => null
aabb => null
abaa => null
abab => null
abba => null
abbb => true
baaa => null
baab => null
baba => null
babb => true
bbaa => null
bbab => true
bbba => true
bbbb => false
Testing [(q0,b,q1(f)), (q1,b,q1(f)), (q1,a,q2(f)), (q2,b,q1(f))]:
aaaa => null
aaab => null
aaba => null
aabb => null
abaa => null
abab => null
abba => null
abbb => null
baaa => null
baab => null
baba => true
babb => true
bbaa => null
bbab => true
bbba => true
bbbb => true
Testing [(q0,b,q0(f)), (q0,a,q1), (q1,b,q1), (q1,a,q2), (q2,b,q2), (q2,a,q3(f)), (q3,b,q0(f)), (q3,a,q1)]:
aaaa => false
aaab => true
aaba => true
aabb => false
abaa => true
abab => false
abba => false
abbb => false
baaa => true
baab => false
baba => false
babb => false
bbaa => false
bbab => false
bbba => false
bbbb => true

Damit ist Aufgabe 1 jetzt gelöst.
hab ich das richtig oder wie ?
 

mihe7

Top Contributor
@Heyoka955 sag mal, das kannst Du doch jetzt nicht ernst meinen. Der Graph ist in Kommentar #18 komplett definiert und Du schaffst es nicht, ein Bild dazu zu malen. Das kann doch nicht so schwer sein, eine Übergangsfunktion, die gerade mal drei Kanten eines Graphen angibt, korrekt auf ein Bild zu übertragen.
 
H

Heyoka955

Gast
@Heyoka955 sag mal, das kannst Du doch jetzt nicht ernst meinen. Der Graph ist in Kommentar #18 komplett definiert und Du schaffst es nicht, ein Bild dazu zu malen. Das kann doch nicht so schwer sein, eine Übergangsfunktion, die gerade mal drei Kanten eines Graphen angibt, korrekt auf ein Bild zu übertragen.
Ich habe mir den Code nicht genau angeschaut weil ich auf eine antowrt wollte uns Feedback dazu.
 
X

Xyz1

Gast
@Heyoka955 Ich verstehe ja dass das für Dich alles neu ist usw., allerdings steht die Lösung quasi schon in Kommentar #3 und in Kommentar #27 ... Das heißt, diese könntest Du einfach nehmen.
Und ja ich kenne auch Vorlesungen bei denen man einfach nichts verstehen kann. Dann musst Du Dir dieses Wissen irgendwie anders zulegen. Wie läuft es denn mit den anderen und mit denen Du lernen und Zettel lösen wolltest? ... (Aber Lektüre kaufen ist erst einmal nur gut für den Geldbeutel des jeweiligen Autor. :D )
Wahrscheinlich kommen jetzt 1.000 Gegenfragen, deswegen sach ich schon einmal dass ich morgen erst wieder ins Forum schauen kann. Bis dann!
 

MoxxiManagarm

Top Contributor
List<Uebergang> c = List.of( new Uebergang("q0", "b", "q0", true), new Uebergang("q0", "a", "q1", false), new Uebergang("q1", "b", "q1", false), new Uebergang("q1", "a", "q2", false), new Uebergang("q2", "b", "q2", false), new Uebergang("q2", "a", "q3", true), new Uebergang("q3", "b", "q0", true), new Uebergang("q3", "a", "q1", false)); test(c);
Ich verstehe noch nicht wie du auf 4 Zustände kommst. Die Aufgabe heißt doch "die Anzahl a’s in w ist ein Vielfaches von 3". Demnach gibt es die Zustände "|a| % 3 = 0" (q0), "|a| % 3 = 1" (q1) und "|a| % 3 = 2" (q2), wobei alleine q0 akzeptierend ist.

Also:
Code:
----> q0* --a--> q1 --a--> q2
      ^----------a----------`

(habe b in dem Graphen herausgelassen, bitte zu jedem Zustand eine selbstreferenzierende Kante denken)
 
H

Heyoka955

Gast
I
@Heyoka955 Ich verstehe ja dass das für Dich alles neu ist usw., allerdings steht die Lösung quasi schon in Kommentar #3 und in Kommentar #27 ... Das heißt, diese könntest Du einfach nehmen.
Und ja ich kenne auch Vorlesungen bei denen man einfach nichts verstehen kann. Dann musst Du Dir dieses Wissen irgendwie anders zulegen. Wie läuft es denn mit den anderen und mit denen Du lernen und Zettel lösen wolltest? ... (Aber Lektüre kaufen ist erst einmal nur gut für den Geldbeutel des jeweiligen Autor. :D )
Wahrscheinlich kommen jetzt 1.000 Gegenfragen, deswegen sach ich schon einmal dass ich morgen erst wieder ins Forum schauen kann. Bis dann!
ich bin nicht zur Uni gegangen, wollte die Aufgabe selbst lösen.
Habe Videos angeschaut und intuitiv gearbeitet.
 

MoxxiManagarm

Top Contributor
ich bin nicht zur Uni gegangen, wollte die Aufgabe selbst lösen.
Habe Videos angeschaut und intuitiv gearbeitet.
Dann lass dir was raten, von jemanden der auch nie auf der Uni war und sich alles quasi selbst beigebracht hat:
Überlege dir Bezeichnungen für die Zustände, Beispiel bezogen auf Aufgabe 1:

w enthält genau ein a
q0: enthält (noch) kein a
q1: enthält genau ein a

jedes a in w folgt unmittelbar auf ein b
q0: hatte kein vorhergehendes Event
q1: letztes Event war ein b
q2: letztes Event war ein a

die Anzahl a’s in w ist ein Vielfaches von 3
q0: Anzahl a % 3 = 0
q1: Anzahl a % 3 = 1
q2: Anzahl a % 3 = 2

Mit diesen Bezeichnungen fällt es einfacher dir logisch zu überlegen welche Events von welchem Zustand aus überhaupt existieren (gültig sind) und zu welchem Zustand sie führen.
 
X

Xyz1

Gast
Ich verstehe noch nicht wie du auf 4 Zustände kommst
Stimmt, der "Graph" zu A 1 3. ist bei mir nicht minimal, sondern hat einen Zustand mehr.

Java:
    List<Uebergang> c = List.of(
            new Uebergang("q0", "b", "q0", true),
            new Uebergang("q0", "a", "q1", false),
            new Uebergang("q1", "b", "q1", false),
            new Uebergang("q1", "a", "q2", false),
            new Uebergang("q2", "b", "q2", false),
            new Uebergang("q2", "a", "q0", true));
    test(c);

Ergebnis: same
 

MoxxiManagarm

Top Contributor
Die kantenbasierte Implementierung von @Tobias-nrw ist eine Möglichkeit. Ich selbst finde die Event-basierte Variante anschaulicher. Daher hier auch einmal ein Beispiel für Aufgabe 1.1:

Java:
public class StateMachine {
    public enum State1 {
        Q0(false), // no 'a' event happened
        Q1(true); // exact 1 'a' event happened
        
        private boolean accepting;
        
        private State1(boolean accepting) {
            this.accepting = accepting;
        }
        
        public boolean isAccepting() {
            return accepting;
        }
        
        public State1 onA() {
            switch(this) {
                case Q0: return Q1;
            }
            
            return null;
        }
        
        public State1 onB() {
            switch(this) {
                case Q0: return Q0;
                case Q1: return Q1;
            }
            
            return null;
        }
    }
    
    public static boolean test(String events) {
        State1 state = State1.Q0; // initial
        
        for(int i = 0; i < events.length(); i++) {
            switch(events.charAt(i)) {
                case 'a': state = state.onA(); break;
                case 'b': state = state.onB(); break;
                default: return false; // unhandled event occured
            }
            
            if(state == null) return false;
        }
        
        return state.isAccepting();
    }
    
    public static void main(String args[]) {
        System.out.println(test("")); // false
        System.out.println(test("a")); // true
        System.out.println(test("b")); // false
        System.out.println(test("bb")); // false
        System.out.println(test("bab")); // true
        System.out.println(test("ba")); // true
        System.out.println(test("aa")); // false
    }
}
 
X

Xyz1

Gast
@MoxxiManagarm Wie ich es implementiert habe ist doch meine Sache...

Aber ich möchte Dir trotzdem einen kleinen Tipp geben ;)
Java:
for (int i = 0; i < 16; i++) {
    String w = String.format("%04d", Integer.parseInt(Integer.toBinaryString(i))).replace('0', 'a').replace('1', 'b');

}

Bis dann. :)
 

MoxxiManagarm

Top Contributor
@MoxxiManagarm Wie ich es implementiert habe ist doch meine Sache...
Habe doch nichts anderes gesagt. Ich wollte die andere Variante nur ergänzen weil ich sie selbst anschaulicher finde und hoffe es hilft ihm endlich den Schalter umzulegen.

Aber ich möchte Dir trotzdem einen kleinen Tipp geben ;)
Wenn man so viele Testfälle haben will dann klar.
 
Zuletzt bearbeitet:

MoxxiManagarm

Top Contributor
Weißt du wie die b geht ?
Das haben wir doch bereits deutlich gemacht. Du hast 3 Zustände.
q0: Noch kein Event a oder b stattgefunden
q1: Event b zuvor stattgefunden
q2: Event a zuvor stattgefunden

Stell dir zu jedem Zustand die Frage, darf Event a bzw. b stattfinden? Wenn ja, welcher Zustand folgt daraus?

Beispiel:
Du bist am Anfang der Eventkette (Initial State = q0).
Q: Darf dann Event a stattfinden mit der Aufgabenstellung, dass Event b unmittelbar vor Event a eingetreten sein muss
A: Nein darf es nicht --> du hast keine ausgehende Kante von q0 mit der Bezeichnung a.
Q: Darf dann Event b stattfinden?
A: Ja, der Folgezustand ist folgerichtig "Event b hat stattgefunden", also q1 --> du hast eine Kante b von q0 nach q1

Das sind in der Zahl 3x2=6 Fragestellungen, beantworte Sie für dich und mal sie auf.
 
Zuletzt bearbeitet:

MoxxiManagarm

Top Contributor
Vielleicht hilft dir ja auch eine Verbildlichung. Nehmen wir eine Küche.

Initial State q0 = Du bist in der Küche mit einem leeren Küchentisch
Event b = du kochst etwas, q1 = es steht Essen auf dem Tisch
Event a = du isst alles was auf dem Tisch steht, q2 = die Teller auf dem Tisch sind nun leer

Logischer Weise kannst du nur was warmes Essen, wenn du zuvor etwas gekocht hast. b muss also stattgefunden haben.
q0: Kannst du etwas essen, wenn du gerade erst in die Küche gekommen bist?
q0: Kannst du etwas kochen, wenn du gerade erst in die Küche gekommen bist?
q1: Du hast gerade gekocht, kannst du nun essen?
q1: Du hast gerade gekocht, kannst du noch mehr kochen?
q2: Du hast gerade alles aufgegessen. Kannst du noch mehr essen?
q2: Du hast gerade alles aufgegessen. Kannst du wieder was kochen?
 
H

Heyoka955

Gast
Vielleicht hilft dir ja auch eine Verbildlichung. Nehmen wir eine Küche.

Initial State q0 = Du bist in der Küche mit einem leeren Küchentisch
Event b = du kochst etwas, q1 = es steht Essen auf dem Tisch
Event a = du isst alles was auf dem Tisch steht, q2 = die Teller auf dem Tisch sind nun leer

Logischer Weise kannst du nur was warmes Essen, wenn du zuvor etwas gekocht hast. b muss also stattgefunden haben.
q0: Kannst du etwas essen, wenn du gerade erst in die Küche gekommen bist?
q0: Kannst du etwas kochen, wenn du gerade erst in die Küche gekommen bist?
q1: Du hast gerade gekocht, kannst du nun essen?
q1: Du hast gerade gekocht, kannst du noch mehr kochen?
q2: Du hast gerade alles aufgegessen. Kannst du noch mehr essen?
q2: Du hast gerade alles aufgegessen. Kannst du wieder was kochen?
 

Anhänge

  • image.jpg
    image.jpg
    1,3 MB · Aufrufe: 51

MoxxiManagarm

Top Contributor
Der Graph den du gerade gezeigt hast, der gehört zu 1.3 nicht zu 1.2

Edit: Das Küchenbeispiel was du zitiert hast gehört aber zu 1.2
 
Zuletzt bearbeitet:

Neue Themen


Oben