This page in English

Kontrollfluss ​

c0de hat eine Bedingung und vier Schleifen, alle aus einer Schlüsselwortzeile und einem Codeblock zwischen BEGIN und END. Sie sehen aus wie die Anweisungen von BASIC oder Pascal, aber die Einzelheiten sind anders: Es gibt kein ELSE IF, FOR schließt seinen Endwert ein, und REPEAT macht weiter, solange seine Bedingung wahr ist. Diese Lektion schreibt FizzBuzz, geht durch einen Hash und nimmt sich noch einmal die Primzahlen der Anleitung vor.

Was du brauchst

Eine Kreativwelt mit erlaubten Cheats (siehe Tutorials), einen Auslöserblock, einen Schraubenschlüssel, einen Knopf, ein paar nicht initialisierte Variablenkarten, eine Variablenkarte mit dem Namen n vom Typ INTEGER und eine mit dem Namen limit vom Typ INTEGER. Für die Primzahlen: einen Komparator mit einer Redstone-Lampe.

Die Anweisungen ​

c0dePythonHinweise
IF c ; … END ELSE … END IFif c: … else:kein ELSE IF: Setze ein weiteres IF in den ELSE-Block
FOR i INTEGER 1 ; n ;for i in range(1, n + 1):der Endwert ist eingeschlossen
FOR x FLOAT 0 ; 1 ; 0.25 ;–der dritte Wert ist die Schrittweite, 1, wenn du ihn weglässt
EACH item listfor item in list:bei einem Hash: die Schlüssel, sortiert
WHILE c ;while c:prüft vor dem Block
REPEAT … END REPEAT c ;while True: … if not c: breakprüft nach dem Block, läuft, solange c wahr ist
BREAK / BREAK c ;break / if c: breakverlässt die innerste Schleife
RETURNreturnbeendet die Funktion; ihre Ergebnisse behalten ihre Werte
EXIT 3 ;sys.exit(3)beendet den ganzen Prozess mit einem Exit-Code von 0 bis 15

Auf jede von ihnen folgt ein Codeblock. Sein END nennt die Anweisung noch einmal: END FOR, END EACH, END WHILE. Nur der erste Block eines IF mit ELSE endet mit einem einzelnen END. Ein Codeblock darf nicht leer sein; NOOP füllt einen, der nichts zu tun hat.

FizzBuzz ​

c0de
PROGRAM fizzbuzz
NOOP
NOOP
FUNCTION fizzbuzz
    PARAMETER n INTEGER 15
    RESULT output STRING
BEGIN
    FOR i INTEGER 1 ; n ;
    BEGIN
        IF i \ 15 = 0 ;
        BEGIN
            ASSIGN output output ⊕ "FizzBuzz " ;
        END
        ELSE
        BEGIN
            IF i \ 3 = 0 ;
            BEGIN
                ASSIGN output output ⊕ "Fizz " ;
            END
            ELSE
            BEGIN
                IF i \ 5 = 0 ;
                BEGIN
                    ASSIGN output output ⊕ "Buzz " ;
                END
                ELSE
                BEGIN
                    ASSIGN output output ⊕ i ⊕ " " ;
                END IF
            END IF
        END IF
    END FOR
END FUNCTION

Stelle den Auslöserblock auf das Programm fizzbuzz und die Funktion fizzbuzz ein. Mit einer nicht initialisierten Karte ist output gleich "1 2 Fizz 4 Buzz Fizz 7 8 Fizz Buzz 11 Fizz 13 14 FizzBuzz ". Lege die Karte n mit einem anderen Wert hinein, um weiter zu zählen; mit 0 läuft die Schleife nicht, und output bleibt leer.

  • Die FOR-Schleife zählt von 1 bis n, beide eingeschlossen. Ihr Start, Ende und ihre Schrittweite werden einmal ausgewertet, vor der ersten Runde: Wenn du n in der Schleife änderst, ändert das nicht, wie oft sie läuft.
  • Ohne ELSE IF ist jeder weitere Fall ein IF im ELSE-Block des vorigen, jedes Mal eine Ebene tiefer. Das erste END jedes IF steht allein, das letzte ist END IF.
  • Ein IF braucht ein BOOLEAN. IF i \ 3 ; würde TYPE_MISMATCH auslösen: Schreibe IF i \ 3 = 0 ;.

Durch einen Hash gehen ​

EACH geht durch eine Kopie eines Arrays oder Hashs. Bei einem Array bekommt die Schleifenvariable die Elemente der Reihe nach; bei einem Hash bekommt sie die Schlüssel, sortiert nach ihren Unicode-Codepoints, und du liest den Wert mit dem Schlüssel als Index.

c0de
PROGRAM stocklist
NOOP
NOOP
FUNCTION stock
    RESULT report STRING
BEGIN
    VARIABLE chest HASH INTEGER
    BEGIN
        torch 64
        Diamond 3
        apple 12
        coal 0
    END VARIABLE
    EACH item chest
    BEGIN
        IF chest[item] > 0 ;
        BEGIN
            ASSIGN report report ⊕ item ⊕ "=" ⊕ chest[item] ⊕ " " ;
        END IF
    END EACH
END FUNCTION

Stelle den Auslöserblock auf das Programm stocklist und die Funktion stock ein, lege eine nicht initialisierte Karte hinein und drücke den Knopf. Klicke die Karte report im Ausgabeinventar mit rechts an: Sie ist "Diamond=3 apple=12 torch=64 ". Großbuchstaben kommen vor Kleinbuchstaben, und coal lässt das IF weg. Die Reihenfolge ist jedes Mal dieselbe, anders als die Reihenfolge eines dict oder einer HashMap, auf die du dich nicht verlassen solltest.

Primzahlen, noch einmal ​

Die Anleitung findet die Primzahlen bis 20 mit zwei FOR-Schleifen. Diese Version nimmt die Grenze als Parameter, hört bei der Quadratwurzel mit dem Testen auf und gibt die Primzahlen als Array zurück:

c0de
PROGRAM primesrevisited
NOOP
NOOP
FUNCTION primes
    PARAMETER limit INTEGER 20
    RESULT found ARRAY INTEGER
    RESULT count INTEGER
BEGIN
    IF limit < 2 ;
    BEGIN
        EXIT 1 ;
    END IF
    FOR candidate INTEGER 2 ; limit ;
    BEGIN
        VARIABLE prime BOOLEAN TRUE
        VARIABLE divisor INTEGER 2
        WHILE divisor * divisor ≤ candidate ;
        BEGIN
            ASSIGN prime candidate \ divisor ≠ 0 ;
            BREAK NOT prime ;
            ASSIGN divisor divisor + 1 ;
        END WHILE
        IF prime ;
        BEGIN
            ASSIGN found[count] candidate ;
            ASSIGN count count + 1 ;
        END IF
    END FOR
END FUNCTION

Stelle den Auslöserblock auf das Programm primesrevisited und die Funktion primes ein, lege zwei nicht initialisierte Karten hinein und drücke den Knopf. found ist [2, 3, 5, 7, 11, 13, 17, 19] und count ist 8. Mit einer Karte limit = 100 ist count gleich 25.

  • IF limit < 2 ; beendet mit EXIT 1 ; den ganzen Prozess. Ein Komparator neben dem Auslöserblock gibt dann ein Signal der Stärke 1 aus, und die Lampe leuchtet; nach einem normalen Ende ist der Exit-Code 0. EXIT schreibt trotzdem die Ergebnisse der Einstiegsfunktion, so wie sie in diesem Moment sind: ein leeres Array und 0.
  • Die innere Schleife ist ein WHILE, weil sich ihr Ende, divisor * divisor ≤ candidate, mit divisor ändert. Ein FOR würde sein Ende nur einmal auswerten.
  • BREAK NOT prime ; ist ein BREAK mit Bedingung: Es verlässt die WHILE-Schleife nur, wenn die Bedingung wahr ist, wie if not prime: break.
  • VARIABLE prime BOOLEAN TRUE steht im Codeblock der FOR-Schleife, also beginnt jede Runde mit einem neuen prime, das wahr ist. Variablen eines Codeblocks werden vergessen, wenn er endet.
  • ASSIGN found[count] candidate ; hängt an: count ist immer die Länge des Arrays, und eine Zuweisung an den Index direkt nach dem Ende fügt ein Element hinzu.

Unterschiede, über die du stolpern wirst ​

  • FOR i INTEGER 1 ; 10 ; läuft zehnmal, einschließlich 10 – anders als range(1, 10).
  • FOR i INTEGER 10 ; 1 ; läuft gar nicht. Rückwärtszählen braucht eine negative Schrittweite: FOR i INTEGER 10 ; 1 ; -1 ;. Eine Schrittweite von 0 löst INVALID_LOOP_STEP aus.
  • Die Schleifenvariable von FOR und EACH kann nicht geändert werden (eine rote Zeile), und nach der Schleife gibt es sie nicht mehr.
  • REPEAT läuft, solange seine Bedingung wahr ist. Es ist nicht das REPEAT … UNTIL von Pascal und vielen BASICs: END REPEAT i ≤ n ; macht weiter, solange i ≤ n gilt.
  • Es gibt kein ELSE IF, kein CONTINUE, kein BREAK mit Sprungmarke, kein switch und kein GOTO. BREAK verlässt nur die innerste Schleife.
  • Wenn du ein Array oder einen Hash in einem EACH darüber änderst, ändert das die Schleife nicht: Sie geht durch eine Kopie.
  • EXIT beendet den Prozess, nicht die Funktion, und nimmt nur 0 bis 15. 15 ist auch der Code eines Absturzes; ein Wert außerhalb löst INVALID_EXIT_CODE aus.

Probier es selbst ​

  1. Schreibe FizzBuzz mit einer REPEAT-Schleife statt FOR. Was gibt es für n = 0 zurück?
Lösung
c0de
PROGRAM fizzbuzzrepeat
NOOP
NOOP
FUNCTION fizzbuzz
    PARAMETER n INTEGER 15
    RESULT output STRING
BEGIN
    VARIABLE i INTEGER 1
    REPEAT
    BEGIN
        VARIABLE word STRING
        IF i \ 3 = 0 ;
        BEGIN
            ASSIGN word "Fizz" ;
        END IF
        IF i \ 5 = 0 ;
        BEGIN
            ASSIGN word word ⊕ "Buzz" ;
        END IF
        IF word = "" ;
        BEGIN
            ASSIGN word "" ⊕ i ;
        END IF
        ASSIGN output output ⊕ word ⊕ " " ;
        ASSIGN i i + 1 ;
    END REPEAT i ≤ n ;
END FUNCTION

Für 15 ist das Ergebnis dasselbe wie vorher. Für 0 ist es "1 ": REPEAT prüft seine Bedingung erst nach der ersten Runde. Diese Version baut außerdem jedes Wort mit drei IFs, statt sie zu verschachteln: word ist in jeder Runde neu, also beginnt es leer.

  1. Füge den Primzahlen ein Ergebnis sum hinzu, das sie mit einer EACH-Schleife addiert.
Lösung
c0de
PROGRAM primesum
NOOP
NOOP
FUNCTION primes
    PARAMETER limit INTEGER 20
    RESULT found ARRAY INTEGER
    RESULT count INTEGER
    RESULT sum INTEGER
BEGIN
    IF limit < 2 ;
    BEGIN
        EXIT 1 ;
    END IF
    FOR candidate INTEGER 2 ; limit ;
    BEGIN
        VARIABLE prime BOOLEAN TRUE
        VARIABLE divisor INTEGER 2
        WHILE divisor * divisor ≤ candidate ;
        BEGIN
            ASSIGN prime candidate \ divisor ≠ 0 ;
            BREAK NOT prime ;
            ASSIGN divisor divisor + 1 ;
        END WHILE
        IF prime ;
        BEGIN
            ASSIGN found[count] candidate ;
            ASSIGN count count + 1 ;
        END IF
    END FOR
    EACH p found
    BEGIN
        ASSIGN sum sum + p ;
    END EACH
END FUNCTION

Die Summe der Primzahlen bis 20 ist 77. Die Funktion hat jetzt drei Ergebnisse, also braucht sie drei nicht initialisierte Karten.

  1. Du startest die Primzahlen mit limit = 1. Welchen Exit-Code liest der Komparator, und welche Karten kommen heraus?
Lösung

Exit-Code 1, also gibt der Komparator ein Signal der Stärke 1 aus. EXIT beendet den Prozess normal, es ist kein Absturz: Die Karte limit und eine nicht initialisierte Karte gehen hinein, und die Ergebniskarten found (ein leeres Array) und count (0) kommen heraus.

Mehr dazu ​