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

Zum Inhalt

# Elementare Listenoperationen

### Erstellen und Zugreifen auf Listen

#### Erstellen einer Ganzzahlfolge: `<int1>..<int2>`

Beschreibung: Der Ausdruck `<int1>..<int2>` erstellt eine Liste aufeinanderfolgender Ganzzahlen, die mit `<int1>` beginnt und mit `<int2>` endet. Wenn `<int1>` größer als `<int2>` ist, wird die leere Liste zurückgegeben.

Code | Ergebnis
--- | ---
`4..9` | `[4, 5, 6, 7, 8, 9]`
`-2..2` | `[-2, -1, 0, 1, 2]`
`4..1` | `[]`

#### Die Länge einer Liste: `length(<list>)`

Beschreibung: Dieser Operator gibt eine Ganzzahl zurück, die der Anzahl der Elemente in der `<list>` entspricht.

Code | Ergebnis
--- | ---
`length([2 ,5 ,7 ,3])` | `4`
`length([2 ,[5, 4, 5] ,7 ,3]_2)` | `3`
`length(1..1000)` | `1000`

Die Kombination der `length`- und der `repeat`-Operatoren ermöglicht es, alle Elemente einer Liste leicht aufzulisten.

    repeat(length(list),
       println(list_#);
    )

Ein Wort der Vorsicht hier: CindyScript ist so konzipiert, dass es selten nützlich ist, alle Elemente einer Liste mit dem `repeat`-Operator zu durchlaufen. Es gibt elegantere Wege.

#### Testen auf Enthaltensein: `contains(<list>,<expr>)`

Beschreibung: Dieser Operator gibt entweder `true` oder `false` zurück, je nachdem, ob `<list>` das Element enthält.

Code | Ergebnis
--- | ---
`contains([1,3,4,5],4)` | `true`
`contains([1,3,4,5],7)` | `false`
`contains([1,3,4,5],2*2)` | `true`

### Listenmanipulation

#### Verkettung von Listen: `concat(<list1>,<list2>)`

Beschreibung: Dieser Operator erstellt eine Liste durch Verkettung zweier anderer Listen. Dieser Operator kann äquivalent als `<list1>++<list2>` geschrieben werden.

Code | Ergebnis
--- | ---
`concat(["a", "b"], ["c", "d"])` | `["a", "b", "c", "d"]`

#### Entfernen von Elementen aus Listen: `remove(<list1>,<list2>)`

Beschreibung: Dieser Operator erstellt eine Liste durch Entfernen aller Elemente, die in `<list2>` vorkommen, aus `<list1>`. Dieser Operator kann äquivalent als `<list1> -- <list2>` geschrieben werden.

Code | Ergebnis
--- | ---
`remove([1,3,4,5,1,5,6], [1,3,7])` | `[4,5,5,6]`
`[1,3,4,5,1,5,6]--[1,3,7]` | `[4,5,5,6]`

#### Schnittmenge von Listen: `common(<list1>,<list2>)`

Beschreibung: Dieser Operator erstellt eine Liste, die alle Elemente sammelt, die in beiden `<list1>` und `<list2>` vorkommen. In der zurückgegebenen Liste sind die Elemente sortiert und jedes Element kommt höchstens einmal vor. Dieser Operator kann äquivalent als `<list1>~~<list2>` geschrieben werden.

Code | Ergebnis
--- | ---
`common([1,3,4,5,1,5,6], [1,3,7])` | `[1,3]`
`[1,3,4,5,1,5,6]~~[1,3,7]` | `[1,3]`

#### Anfügen eines Elements: `append(<list>,<expr>)`

Beschreibung: Dieser Operator gibt eine Liste zurück, die durch Anfügen von `<expr>` an die Liste `<list>` als letztes Element erstellt wird. Dieser Operator kann äquivalent als `<list>:><expr>` geschrieben werden.

Code | Ergebnis
--- | ---
`append(["a", "b", "c"], "d")` | `["a", "b", "c","d"]`
`["a", "b", "c"]:>"d"` | `["a", "b", "c","d"]`

#### Voranstellen eines Elements: `prepend(<expr>,<list>)`

Beschreibung: Dieser Operator gibt eine Liste zurück, die durch Voranstellen von `<expr>` an die Liste `<list>` als erstes Element erstellt wird. Dieser Operator kann äquivalent als `<expr><:<list>` geschrieben werden.

Code | Ergebnis
--- | ---
`prepend("d",["a", "b", "c"])` | `["d","a", "b", "c"]`
`"d"<:["a", "b", "c"]` | `["d","a", "b", "c"]`

### Durchlaufen von Listen

#### Die forall-Schleife: `forall(<list>,<expr>)`

Beschreibung: Dieser Operator ist nützlich zum Anwenden einer Operation auf alle Elemente einer Liste. Er nimmt eine `<list>` als erstes Argument. Er erstellt eine Schleife, in der `<expr>` für jeden Eintrag der Liste ausgewertet wird. Für jeden Durchlauf nimmt die Laufvariable `#` den Wert des entsprechenden Listeneintrags an.

Beispiel:

    a=["this","is","a","list"];
    forall(a,println(#))

Dieses Code-Fragment erzeugt die Ausgabe

    this
    is
    a
    list

#### Die forall-Schleife: `forall(<list>,<var>,<expr>)`

Beschreibung: Ähnlich wie `forall(<list>,<expr>)`, aber die Laufvariable heißt jetzt `<var>`.

#### Anwenden eines Ausdrucks: `apply(<list>,<expr>)`

Beschreibung: Dieser Operator generiert eine neue Liste, indem die Operation `<expr>` auf alle Elemente einer Liste angewendet wird und die Ergebnisse gesammelt werden. Wie gewohnt ist `#` die Laufvariable, die nacheinander den Wert jedes Elements in der Liste annimmt.

Code | Ergebnis
--- | ---
`apply([1, 2, 3, 4, 5],#^2)` | `[1, 4, 9, 16, 25]`
`apply([1, 2, 3, 4, 5],#+5)` | `[6, 7, 8, 9, 10]`
`apply(1..5, [#,#^2])` | `[[1, 1], [2, 4], [3, 9], [4, 16], [5, 25]]`

#### Anwenden eines Ausdrucks: `apply(<list>,<var>,<expr>)`

Beschreibung: Ähnlich wie `apply(<list>,<expr>)`, aber die Laufvariable heißt jetzt `<var>`.

#### Auswählen von Elementen einer Liste: `select(<list>,<boolexpr>)`

Beschreibung: Dieser Operator wählt alle Elemente einer Liste aus, für die eine bestimmte Bedingung erfüllt ist. Die Bedingung soll durch `<boolexpr>` kodiert werden. Es wird angenommen, dass dieser Ausdruck einen `<bool>`-Wert zurückgibt. Wie gewohnt ist `#` die Laufvariable, die nacheinander den Wert aller Elemente in der Liste annimmt.

Code | Ergebnis
--- | ---
`select(1..10, isodd(#))` | `[1, 3, 5, 7, 9]`
`select(0..10, #+# == #^2)` | `[0,2]`

Eine hochwertige Anwendung des `select`-Operators ist im folgenden Beispiel gegeben:

    divisors(x):=select(1..x,mod(x,#)==0);
    primes(n):=select(1..n,length(divisors(#))==2);
    println(primes(100))

Sie erzeugt die Ausgabe

    [2,3,5,7,11,13,17,19,23,29,31,37,41,43,47,53,59,61,67,71,73,79,83,89,97]

In diesem Beispiel wird zunächst eine Funktion `divisors(x)` definiert, die durch Auswahl derjenigen Zahlen definiert wird, die `x` ohne Rest teilen. Dann wird eine Funktion `primes(n)` definiert, die alle Zahlen zwischen `1` und `n` auswählt, die genau zwei Teiler haben. Diese Zahlen sind die Primzahlen.

#### Auswählen von Elementen einer Liste: `select(<list>,<var>,<boolexpr>)`

Beschreibung: Ähnlich wie `select(<list>,<boolexpr>)`, aber die Laufvariable heißt jetzt .

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