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