Listen erstellen in Aneamal

 <a><b> t
 <c><d> t
 <e><f> t
 <g><h> t
 <i><j> t

Die Zeilen werden durch die Klammern in der ersten Reihe definiert, die
Spalten durch die Klammern in der zweiten Reihe. So bilden

  <a><b> t, <i><j> t, t_{i, j}

die äusseren Eckpunkte der Liste.

	b	d	f	h	j
a	t
c		t
e			t
g				t
i					t

Die Schnittpunkte zweier Klammern, zB <a> \cap <b> = t_{a, b}, werden
mit dem Inhalt gefüllt, der direkt daneben steht, in meinem Fall t. Es
bildet sich eine Diagonale von links oben nach rechts unten (x, -y). Die
nun frei gebliebenen Felder werden gefüllt, in dem die entsprechenden
Klammern angegeben werden, zB

<g> \cap <j> = t_{g, j}, <c> \cap <h> = t_{c, h}, <i> \cap <f> = t_{i, f}, <e> \cap <j> = t_{e, j}

Das sieht dann als 'Befehl' wie folgt aus.

 <a><b> t
 <c><d> t
 <e><f> t
 <g><h> t
 <i><j> t
 <g><j> t_(g, j)
 <c><h> t_(c, h)
 <i><f> t_(i, f)
 <e><j> t_(e, j)

Dargestellt wird es dann so.

	b	d	f	h	j
a	t
c		t		t(c, h)
e			t		t(e, j)
g				t	t(g, j)
i			t(i, f)		t

Mit diesem Wissen im Hinterkopf, ist es ziemlich leicht, ansehliche Dateien
in Aneamal zu schreiben. Für die Zordnung wichtig ist der Inhalt der Klammern.
So kann man das auch wild durcheinander gewürfelt machen und die Liste so
schreiben, dass die Tabelle Zeile um Zeile wächst.

 <a><b> t
 <a><d> t
 <a><f> t
 <a><h> t
 <a><j> t

Was dann so dargestellt wird.

	b	d	f	h	j
a	t	t	t	t	t

Die nächste Zeile, beginnend mit <c>, wird dann darunter geschrieben.

 <a><b> t
 <a><d> t
 ...
 <c><j> t
 <c><i> t
 <c><h> t
 <c><f> t
 <c><d> t
 <c><b> t

Und ausgegeben wird dann die folgende Liste.

	b	d	f	h	j
a	t	t	t	t	t
c	t	t	t	t	t

Das hat damit zu tun, dass in der ersten Reihe in den Klammern, die gleichen Namen sind, a = a, c = c, und damit eine Zuordnung zur gleichen Zeile möglich wird. Man kann sagen dass der Spalteninhalt der in der zweiten Reihe steht, Element
der Zeile a ist, oder eine Zeile unten, von c.

\{b, d, f, h, i, j,\} \in a + b

Nun wird klar, dass das auch so geht, dass die Tabelle auf der x-Achse in die Breite wachsen kann, indem Spalten hinzugefügt werden. Der 'Befehl' sieht dann
so aus.

 <a><b> t
 <a><d> t
 ...
 <a><j> t
 <a><l> t
 <a><n> t
 <a><p> t
 <a><r> t

Und wird dann wie folgt dargestellt.

	b	d	f	h	j	l	n	p	r
a	t	t	t	t	t	t	t	t	t

Das Ganze hat eine Menge mit Logik und Mengenlehre zu tun. Solange eine eindeutige Zuordnung zu einer bestehenden Zeile oder Spalte
möglich ist, wächst diese nur an der definierten Stelle; werden neue Werte für Zeilen || Spalten vergeben, wächst die Tabelle an dieser neuen
Stelle.

Man kann sagen, dass, soll die Tabelle auf der x-Achse \land y-Achse wachsen, die Werte, val \notin <val_x><val_y> sein dürfen. Sie dürfen nicht auf der x-Achse (Spalten) oder y-Achse (Zeilen) bereits vorkommen. Dann wird eine neue Zeile \land neue Spalte angefügt. Ist <val_{neu}> \in x-Achse \land <val_{neu}> \notin y-Achse, wird es der entsprechenden Spalte zugeordnet und die y-Achse um diesen Wert erweitert. Entsprechend gilt für ein Zuwachs auf der x-Achse, <val_{neu}> \in y-Achse \land <val_{neu}> \notin x-Achse, dann wird auf der x-Achse eine neue Spalte angefügt. Gilt <val_{neu}> \in x-Achse \land \in y-Achse, liegt der Wert bereits vor, bzw. die Zeile und Spalte wurde schon vor.

Allerdings ist man als Mensch keine Maschine, die Schritt für Schritt Befehle abarbeitet und dabei kaum Fehler macht, und Logik ist dem Mensch nicht wirklich in die Wiege gelegt, sodass dann schnell Fehler
unterlaufen können und eine lange Suche mit sich bringt. Daher lieber mit etwas System an die Sache und eine Struktur rein bringen, dann wird es was mit einer lesbaren Liste.

Kommentieren