Fortgeschrittene Listenoperationen - Cinderella Dokumentation
Description: The user's guide to the Interactive Geometry Software Cinderella

Zum Inhalt

# Fortgeschrittene Listenoperationen

Es gibt mehrere Operatoren, die eine Liste als Argument nehmen und eine andere davon abgeleitete Liste zurückgeben. Dieser Abschnitt behandelt solche Operatoren. Diese Operatoren bilden sehr mächtige Werkzeuge für hochwertige Berechnungen. Für Beispiele zur Verwendung und Anwendung dieser Operatoren in einem realistischen Kontext empfehlen wir dringend, den Beispielabschnitt für CindyScript zu lesen.

### Paare und Tripel

#### Paare erstellen: `pairs(<list>)`

Beschreibung: Dieser Operator erzeugt eine Liste, die alle zweistelligen Unterlisten einer Liste enthält. Dies sind alle Paare von Elementen der `<list>`. Dieser Operator ist besonders nützlich zum Erstellen aller Segmente, die von einer Menge von Punkten bestimmt werden.

Code | Ergebnis
--- | ---
`pairs([1, 2, 3, 4])` | `[[1, 2], [1, 3], [1, 4], [2, 3], [2, 4], [3, 4]]`

#### Erstellen einer Kette: `consecutive(<list>)`

Beschreibung: Dieser Operator erzeugt eine Liste, die alle Paare aufeinanderfolgender Elemente des Arguments `<list>` enthält.

Code | Ergebnis
--- | ---
`consecutive([1, 2, 3, 4, 5])` | `[[1, 2], [2, 3], [3, 4], [4, 5]]`

#### Erstellen eines Zyklus: `cycle(<list>)`

Beschreibung: Dieser Operator erzeugt eine Liste, die alle Paare aufeinanderfolgender Elemente des Arguments `<list>` enthält. Darüber hinaus wird das Paar bestehend aus dem letzten und dem ersten Element hinzugefügt.

Code | Ergebnis
--- | ---
`cycle([1, 2, 3, 4, 5])` | `[[1, 2], [2, 3], [3, 4], [4, 5], [5, 1]]`

#### Tripel erstellen: `triples(<list>)`

Beschreibung: Dieser Operator erzeugt eine Liste, die alle dreistelligen Unterlisten einer Liste enthält. Dies sind alle Tripel von Elementen der `<list>`.

Code | Ergebnis
--- | ---
`triples([1, 2, 3, 4])` | `[[1,2,3], [1,2,4], [1,3,4], [2,3,4]]`

#### Direktes Produkt zweier Listen erstellen: `directproduct(<list1>,<list2>)`

Beschreibung: Dieser Operator erzeugt eine Liste, die das direkte Produkt zweier gegebener Listen darstellt. Das direkte Produkt besteht aus allen Paaren, deren erstes Element aus `<list1>` stammt und deren zweites Element aus `<list2>` stammt.

Code | Ergebnis
--- | ---
`directproduct([1,2,3], ["A", "B"])` | `[[1,"A"], [1,"B"], [2,"A"], [2,"B"], [3,"A"], [3,"B"]]`

#### Verschachtelte Listen vereinfachen: `flatten(<list>)`

Beschreibung: Dieser Operator nimmt eine Liste, die selbst wieder aus Listen bestehen kann. Er gibt eine einzelne Liste von Elementen zurück, die sich aus dem Anhängen aller Listen der zweiten Ordnung ergibt. Mit einem Modifizierer kann das Vereinfachen rekursiv angewendet werden. Auch die Ebenen des Vereinfachens können gesteuert werden.

Dieser Operator erzeugt eine Liste, die das direkte Produkt zweier gegebener Listen darstellt. Das direkte Produkt besteht aus allen Paaren, deren erstes Element aus `<list1>` stammt und deren zweites Element aus `<list2>` stammt.

Modifizierer: Der Modifizierer `levels` kann entweder auf "all" gesetzt werden, was zu einer vollständigen rekursiven Vereinfachung führt, oder er kann auf eine ganze Zahl gesetzt werden, die die maximale Rekursionsebene der Vereinfachung angibt. Die Anweisung `flatten(...,levels->1)` ist äquivalent zu `flatten(...)`.

Beispiel: Nehmen wir an, dass wir setzen

`list=[[1,2],[3,[4,5],[6,[7,8]]],6];`

dann erhalten wir die folgenden Antworten auf verschiedene Aufrufe der Vereinfachung:

Code | Ergebnis
--- | ---
`flatten(list)` | `[1,2,3,[4,5],[6,[7,8]],6]`
`flatten(list,levels->0)` | `[[1,2],[3,[4,5],[6,[7,8]]],6]`
`flatten(list,levels->1)` | `[1,2,3,[4,5],[6,[7,8]],6]`
`flatten(list,levels->2)` | `[1,2,3,4,5,6,[7,8],6]`
`flatten(list,levels->3)` | `[1,2,3,4,5,6,7,8,6]`
`flatten(list,levels->"all")` | `[1,2,3,4,5,6,7,8,6]`

### Reihenfolge der Elemente

Die folgenden Operatoren ändern die Reihenfolge der Elemente innerhalb einer Liste.

#### Eine Liste umkehren: `reverse(<list>)`

Beschreibung: Dieser Operator kehrt die Reihenfolge der Elemente in `<list>` um.

Code | Ergebnis
--- | ---
`reverse([1, 2, 3, 4])` | `[4, 3, 2, 1]`

#### Eine Liste sortieren: `sort(<list>)`

Beschreibung: In CindyScript sind alle Elemente in einer natürlichen vollständigen Ordnung angeordnet, die es ermöglicht, zwei beliebige Elemente zu vergleichen. Zwei Elemente sind gleich, oder eines von ihnen ist größer als das andere. Bei reellen Zahlen ist die Reihenfolge die übliche numerische Ordnung. Bei Zeichenketten ist die Reihenfolge die lexikographische Ordnung. Komplexe Zahlen werden zunächst nach ihren Realteilen geordnet. Wenn zwei komplexe Zahlen den gleichen Realteil haben, werden sie nach ihren Imaginärteilen verglichen. Zwei Listen werden nach dem ersten Eintrag verglichen, in dem sie sich unterscheiden. Darüber hinaus verwendet Cinderella nach Konvention die Ordnung

booleans < numbers < strings < lists

Code | Ergebnis
--- | ---
`sort([4.5, 1.3, 6.7, 0.2])` | `[0.2, 1.3, 4.5, 6.7]`
`sort(["one", "two", "three", "four", "five"])` | `["five","four","one","three","two"]`

#### Eine Liste sortieren: `sort(<list>, <expr>)`

Beschreibung: Dieser Operator nimmt jedes Element der Liste und wertet eine durch `<expr>` ausgedrückte Funktion aus, die darauf angewendet wird. Alle Elemente der Liste werden nach dem Ergebnis dieser Auswertungen sortiert.

Code | Ergebnis
--- | ---
`sort([-4.5, 1.3, -6.7, 0.2], abs(#))` | `[0.2, 1.3, -4.5, -6.7]`
`sort(["one", "two", "three", "four", "five"],length(#))` | `["one","two","four","five","three"]`

#### Eine Liste sortieren: `sort(<list>, <var>, <expr>)`

Beschreibung: Ähnlich wie `sort(<list>, <expr>)`, aber mit `<var>` als Laufvariable.

#### Mengen aus Listen: `set(<list>)`

Beschreibung: Dieser Operator sortiert alle Elemente einer Liste und entfernt Vorkommen identischer Elemente. Somit wird eine eindeutige Darstellung der Liste berechnet, wenn die Liste als eine Menge von Objekten betrachtet wird. Zusammen mit den Operatoren `concat`, `remove` und `common` kann dies als Implementierung von Mengenfunktionalität verwendet werden.

Code | Ergebnis
--- | ---
`set([3, 5, 2, 4, 3, 5, 7])` | `[2, 3, 4, 5, 7]`
`set([3, 5, 2]++[4, 5, 2])` | `[2, 3, 4, 5]`
`set([3, 5, 2]~~[4, 5, 2])` | `[2, 5]`

Diese Seite wurde automatisch mit KI (Claude) übersetzt und wartet noch auf Überprüfung. → Alle KI-übersetzten Seiten