Sammlungen und Strukturen
c0de hat drei Wege, Werte zusammenzufassen: Das ARRAY ist eine Liste, der HASH ein Wörterbuch mit Textschlüsseln, der STRUCT ein Datensatz mit benannten Elementen. Sie fühlen sich an wie Listen, Dicts und Dataclasses in Python, mit einem großen Unterschied: Sie sind Werte. Jede Zuweisung, jeder Parameter und jedes Ergebnis ist eine Kopie, und es gibt keine Referenzen, kein Aliasing und kein null.
Was du brauchst
Eine Kreativwelt mit erlaubten Cheats (siehe Tutorials), einen Auslöserblock, einen Schraubenschlüssel, einen Knopf, eine ARRAY-Variablenkarte mit dem Untertyp INTEGER und dem Namen numbers, eine STRING-Variablenkarte mit dem Namen text, zwei STRUCT-Variablenkarten mit den Namen a und b und ein paar nicht initialisierte Variablenkarten.
Das Modell
- ARRAY T ist eine Liste von Werten des Typs T, von 0 an nummeriert. Es wächst und schrumpft von selbst; du deklarierst nie eine Größe. Arrays von Arrays (
ARRAY ARRAY INTEGER) sind möglich, bis zu 8 Dimensionen. - HASH T speichert Werte des Typs T unter Schlüsseln, die immer STRINGs sind. EACH geht seine Schlüssel in alphabetischer Reihenfolge durch, nicht in der Reihenfolge, in der sie hinzugefügt wurden.
- STRUCT deklariert einen Typ mit benannten Elementen, im globalen Teil des Programms und über allem, was ihn verwendet. Ein Element kann eine vorher deklarierte Struktur sein; nur so lassen sich Strukturen verschachteln. Eine Struktur hat keine Methoden.
- Werte, keine Referenzen.
ASSIGN copy original ;kopiert das ganze Array, den ganzen Hash oder die ganze Struktur. Eine Änderung ancopyändert nieoriginal, und eine Funktion ändert nie die Variablen ihres Aufrufers.
| Python | c0de |
|---|---|
a = [] | VARIABLE a ARRAY INTEGER |
a[i] | a[i] |
len(a) | CALL LEN mit PARAMETER value a ; |
a.append(x) | ASSIGN a[n] x ;, wobei n die Länge von a ist |
a.insert(i, x) | CALL INSERT |
del a[i], del d[k] | CALL REMOVE mit index oder key |
a.clear() | CALL CLEAR |
d = {} | VARIABLE d HASH INTEGER |
k in d | CALL HAS_KEY |
for k in sorted(d) | EACH k d |
a, b = b, a | CALL SWAP |
@dataclass class Point | STRUCT point |
p.x | p.x |
Indizes
Ein Index ist Teil eines LABELs: numbers[0], counts[word], stock["gold"], path.from.x. Er hat bis zu 8 Einträge, und jeder Eintrag ist ein Literal oder der Name einer Variablen oder Konstanten – nie ein Ausdruck. sorted[next] geht, sorted[i + 1] nicht; berechne die Position zuerst in eine Variable.
- Das Lesen einer Position außerhalb des Arrays löst INDEX_OUT_OF_BOUNDS aus; es gibt keine negativen Positionen vom Ende her. Das Lesen eines Schlüssels, den der Hash nicht hat, löst UNKNOWN_KEY aus.
- Eine Zuweisung an die Position direkt nach dem letzten Element hängt eines an; eine Position weiter draußen löst INDEX_OUT_OF_BOUNDS aus. Eine Zuweisung an einen neuen Schlüssel fügt ihn dem Hash hinzu.
- Ein STRING kann Zeichen für Zeichen gelesen werden,
text[i]ist ein CHAR. Er kann nicht über einen Index geändert werden, und EACH geht nicht durch einen STRING.
Arrays, Hashes und Strukturen können Startwerte in einem Codeblock nach ihrer VARIABLE- oder CONSTANT-Zeile bekommen, mit einer Zeile pro Eintrag, etwa y 64 für das Element y einer Struktur. Dort sind nur Literale erlaubt, keine Ausdrücke.
Die Programme
Bubblesort, das das sortierte Array und die Zahl der Vertauschungen zurückgibt:
PROGRAM sorting
NOOP
NOOP
FUNCTION bubbleSort
PARAMETER numbers ARRAY INTEGER
RESULT sorted ARRAY INTEGER
RESULT swaps INTEGER
BEGIN
VARIABLE last INTEGER
VARIABLE next INTEGER
VARIABLE swapped BOOLEAN TRUE
ASSIGN sorted numbers ;
CALL LEN
PARAMETER value sorted ;
RESULT result last
WHILE swapped ;
BEGIN
ASSIGN swapped FALSE ;
ASSIGN last last - 1 ;
FOR i INTEGER 0 ; last - 1 ;
BEGIN
ASSIGN next i + 1 ;
IF sorted[i] > sorted[next] ;
BEGIN
CALL SWAP
PARAMETER a sorted[i] ;
PARAMETER b sorted[next] ;
RESULT a sorted[i]
RESULT b sorted[next]
ASSIGN swapped TRUE ;
ASSIGN swaps swaps + 1 ;
END IF
END FOR
END WHILE
END FUNCTIONDasselbe in Python:
def bubble_sort(numbers: list[int]) -> tuple[list[int], int]:
sorted, swaps = numbers.copy(), 0
last, swapped = len(sorted), True
while swapped:
swapped = False
last -= 1
for i in range(0, last):
if sorted[i] > sorted[i + 1]:
sorted[i], sorted[i + 1] = sorted[i + 1], sorted[i]
swapped = True
swaps += 1
return sorted, swapsWörter zählen mit einem HASH:
PROGRAM words
NOOP
INCLUDE c0de/strings
NOOP
FUNCTION countWords
PARAMETER text STRING
RESULT counts HASH INTEGER
RESULT words INTEGER
BEGIN
VARIABLE length INTEGER
VARIABLE word STRING
VARIABLE known BOOLEAN
CALL c0de/strings/LCASE
PARAMETER text text ⊕ " " ;
RESULT result text
CALL LEN
PARAMETER value text ;
RESULT result length
FOR i INTEGER 0 ; length - 1 ;
BEGIN
IF text[i] ≠ ' ' ;
BEGIN
ASSIGN word word ⊕ text[i] ;
END
ELSE
BEGIN
IF word ≠ "" ;
BEGIN
CALL HAS_KEY
PARAMETER hash counts ;
PARAMETER key word ;
RESULT result known
IF NOT known ;
BEGIN
ASSIGN counts[word] 0 ;
END IF
ASSIGN counts[word] counts[word] + 1 ;
ASSIGN words words + 1 ;
ASSIGN word "" ;
END IF
END IF
END FOR
END FUNCTIONZwei Strukturen für Punkte und Linien in der Welt:
PROGRAM points
NOOP
INCLUDE c0de/math
NOOP
STRUCT point
BEGIN
x INTEGER
y INTEGER
z INTEGER
END STRUCT
STRUCT line
BEGIN
from STRUCT point
to STRUCT point
END STRUCT
NOOP
FUNCTION length
PARAMETER path STRUCT line
RESULT result FLOAT
BEGIN
VARIABLE dx INTEGER
VARIABLE dy INTEGER
VARIABLE dz INTEGER
ASSIGN dx path.to.x - path.from.x ;
ASSIGN dy path.to.y - path.from.y ;
ASSIGN dz path.to.z - path.from.z ;
CALL c0de/math/SQR
PARAMETER value dx * dx + dy * dy + dz * dz ;
RESULT result result
END FUNCTION
NOOP
FUNCTION measure
PARAMETER a STRUCT point
PARAMETER b STRUCT point
RESULT path STRUCT line
RESULT distance FLOAT
RESULT above STRUCT point
BEGIN
ASSIGN path.from a ;
ASSIGN path.to b ;
ASSIGN above a ;
ASSIGN above.y above.y + 10 ;
CALL length
PARAMETER path path ;
RESULT result distance
END FUNCTIONStarten
Bubblesort: Stelle den Auslöserblock auf das Programm sorting und die Funktion bubbleSort ein. Lege die Karte numbers mit den Werten 5, 3, 8, 1, 9, 2 und eine nicht initialisierte Karte hinein. Die Ergebnisse sind sorted mit 1, 2, 3, 5, 8, 9 und swaps 8. Ein leeres Array kommt leer zurück, mit 0 Vertauschungen.
Wörter zählen: die Funktion countWords des Programms words, mit der Karte text = "The creeper saw the pig and the creeper ran" und einer nicht initialisierten Karte. Das Ergebnis counts ist der Hash and 1, creeper 2, pig 1, ran 1, saw 1, the 3, und words ist 9.
Punkte: die Funktion measure des Programms points. Variablenkarten können Strukturen eines Programms enthalten: Tippe STRUCT point in das Typfeld des Kartendialogs. Lege a = (x 0, y 64, z 0), b = (x 3, y 68, z 12) und eine nicht initialisierte Karte in den Auslöserblock. path ist die Linie von a nach b, distance ist 13.0, und above ist (x 0, y 74, z 0).
So funktioniert es
- Die Kopie gibt es umsonst.
ASSIGN sorted numbers ;kopiert den Parameter in das Ergebnis;numbersist ohnehin eine Kopie des Arrays des Aufrufers. Das Sortieren arbeitet nur mitsorted. - Keine Ausdrücke in Indizes. Deshalb hat
bubbleSortdie Variablenext=i + 1und vergleichtsorted[i]mitsorted[next]. - Elemente vertauschen. SWAP bekommt
sorted[i]undsorted[next]als Parameter und gibt sie vertauscht in dieselben zwei Elemente zurück. Auch Ziele von Ergebnissen können einen Index haben. - Zeichen lesen.
countWordshängt ein Leerzeichen an, damit auch das letzte Wort gezählt wird, und geht den Text mit FOR undtext[i]durch, weil EACH nur mit Arrays und Hashes funktioniert. Die Prüfungword ≠ ""überspringt doppelte Leerzeichen. - Erst der Schlüssel, dann lesen. Bevor
counts[word] + 1den Schlüssel liest, prüft HAS_KEY, ob es ihn gibt, und ein neues Wort beginnt bei 0. Der Schlüssel ist der Wert der Variablenword. - Verschachtelte Strukturen.
linehat zwei Elemente vom Typpoint, also wirdpointzuerst deklariert.path.to.xist ein Index mit zwei Einträgen: dem Elementto, dann dessen Elementx. - Wieder Kopien.
ASSIGN above a ;kopierta, undASSIGN above.y above.y + 10 ;ändert nur die Kopie:path.from, auch eine Kopie vona, hat immer noch y 64.lengthbekommt seine eigene Kopie vonpath.
Unterschiede, über die du stolpern wirst
- Ein Index ist ein Literal oder eine Variable, nie ein Ausdruck:
list[i + 1]gibt es nicht. - Einen fehlenden Schlüssel oder eine fehlende Position zu lesen ist ein Fehler, nicht
Noneoderundefined. Verwende vorher HAS_KEY oder LEN. ASSIGN b a ;kopiert das ganze Array, den ganzen Hash oder die ganze Struktur. Es gibt keine Referenzen, auch nicht in eine Funktion hinein.=vergleicht zwei Arrays nach ihrem Inhalt.- LEN, INSERT, REMOVE, CLEAR und SWAP geben den geänderten Wert als Ergebnis zurück. Um eine Variable zu ändern, verwende sie als Parameter und als Ziel des Ergebnisses.
- Neue Elemente kommen nur direkt hinter das letzte. Es gibt keine Lücken, und Position -1 ist ein Fehler, nicht das letzte Element.
- Hash-Schlüssel sind immer STRINGs, und EACH sortiert sie alphabetisch.
- Ein STRING ist über seinen Index nur lesbar, und EACH geht nicht durch ihn.
- Strukturtypen werden global deklariert, über ihrer ersten Verwendung. Elemente ohne Startwert haben den Standardwert ihres Typs.
- Startwerte von Sammlungen sind nur Literale; alles Berechnete braucht ASSIGN.
Probier es selbst
- Schreibe eine Funktion
repeated, die die Wörter eines Texts zurückgibt, die mehr als einmal vorkommen, als ARRAY STRING in alphabetischer Reihenfolge. VerwendecountWords.
Lösung
PROGRAM words
NOOP
INCLUDE c0de/strings
NOOP
FUNCTION countWords
PARAMETER text STRING
RESULT counts HASH INTEGER
RESULT words INTEGER
BEGIN
VARIABLE length INTEGER
VARIABLE word STRING
VARIABLE known BOOLEAN
CALL c0de/strings/LCASE
PARAMETER text text ⊕ " " ;
RESULT result text
CALL LEN
PARAMETER value text ;
RESULT result length
FOR i INTEGER 0 ; length - 1 ;
BEGIN
IF text[i] ≠ ' ' ;
BEGIN
ASSIGN word word ⊕ text[i] ;
END
ELSE
BEGIN
IF word ≠ "" ;
BEGIN
CALL HAS_KEY
PARAMETER hash counts ;
PARAMETER key word ;
RESULT result known
IF NOT known ;
BEGIN
ASSIGN counts[word] 0 ;
END IF
ASSIGN counts[word] counts[word] + 1 ;
ASSIGN words words + 1 ;
ASSIGN word "" ;
END IF
END IF
END FOR
END FUNCTION
NOOP
FUNCTION repeated
PARAMETER text STRING
RESULT words ARRAY STRING
BEGIN
VARIABLE counts HASH INTEGER
VARIABLE next INTEGER
CALL countWords
PARAMETER text text ;
RESULT counts counts
EACH word counts
BEGIN
IF counts[word] > 1 ;
BEGIN
ASSIGN words[next] word ;
ASSIGN next next + 1 ;
END IF
END EACH
END FUNCTIONFür "The creeper saw the pig and the creeper ran" ist words creeper, the. EACH liefert die Schlüssel in alphabetischer Reihenfolge, und next ist immer die Länge von words, also hängt words[next] an.
- Entferne den Aufruf von HAS_KEY und das IF danach aus
countWords. Was passiert?
Lösung
Der Prozess stürzt beim ersten Wort mit UNKNOWN_KEY ab: counts[word] + 1 liest einen Schlüssel, den es noch nicht gibt. Ein Hash hat keinen Standardwert für fehlende Schlüssel.
Mehr dazu
- Die Sprache: Typen, Variablen und Konstanten, Strukturen, ASSIGN und EACH-Schleifen
- Bibliotheken: Werte ändern
- Handbuch Funktionen: LEN, HAS_KEY, REMOVE, INSERT, CLEAR und SWAP
- Handbuch Daten: TYPE_ARRAY, TYPE_HASH und TYPE_STRUCT