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