Cambridge Pseudocode Handout · ⁨Feuille de travail Cambridge Pseudocode⁩

Le pseudocode 伪代码 est le langage dans lequel Cambridge écrit les algorithmes 算法. Ce n'est pas un langage réel. langage de programmation — aucun ordinateur ne l'exécute — mais l'examen le note comme si c'était le cas, donc la forme est importante.

Chaque mot clé 关键字 s'écrit en MAJUSCULES : IF, REPEAT, PROCEDURE, OUTPUT.

DECLARE Count : INTEGER
Count ← 3
IF Count > 0
  THEN
    OUTPUT "Ready"
ENDIF

• Écrivez IF, jamais if ou If.
• Un mot clé ne peut jamais être utilisé comme nom personnel : vous ne pouvez pas appeler une variable FOR.

Erreurs courantes

• Mots clés en minuscules. La grille d'évaluation attend des majuscules.
• Invention de mots clés. Seuls les mots de cette fiche font partie du programme.

Un identifiant 标识符 est le nom que vous donnez à une variable 变量, une constante 常量, une procédure 过程 or a function 函数.

DECLARE NumberOfPlayers : INTEGER
NumberOfPlayers ← 4
OUTPUT NumberOfPlayers

Quatre règles, toutes issues du programme :

• Il doit commencer par une majuscule : Count, pas count.
• Il ne peut contenir que des lettres et des chiffres — pas d'espaces, pas de ponctuation.
• Il n'est pas sensible à la casse 不区分大小写, donc Count et COUNT sont le même nom. Choisissez une orthographe et tenez-y bon.
• Faites qu'il ait un sens. NumberOfPlayers mérite le temps du lecteur ; N non.

Erreurs courantes

• count ← 0 — début en minuscule. 0478 exige la majuscule.
• Number of players — les espaces ne sont pas autorisés dans un nom.

Un commentaire 注释 commence par // et se poursuit jusqu'à la fin de la ligne. C'est pour l'humain lecteur ; l'algorithme l'ignore.

// Swap the values of X and Y
DECLARE X, Y, Temp : INTEGER
X ← 1
Y ← 2
Temp ← X   // temporarily store X
X ← Y
Y ← Temp
OUTPUT X, " ", Y

L'indentation 缩进 indique quelles instructions sont à l'intérieur d'une structure. Le programme demande quatre espaces par niveau, avec une exception que vous devez connaître :

DECLARE X, Y : INTEGER
X ← 7
Y ← 3
IF X > Y
  THEN
    OUTPUT "X is bigger"
  ELSE
    OUTPUT "Y is bigger or equal"
ENDIF

• THEN et ELSE sont indentés de deux espaces par rapport à leur IF.
• Les instructions qui les suivent sont indentées de quatre.
• ENDIF est aligné avec son propre IF.

Erreurs courantes

• Placer THEN sur la ligne IF. C'est la mise en page A-Level 9618 — voir sujet 11.
• Aucune indentation du tout. Un correcteur doit voir la structure pour accorder les points de structure.

Le pseudocode 0478 a exactement cinq types de données 数据类型. Apprenez la liste — nommer un type qui n'y figure pas fait perdre le point.

DECLARE Age : INTEGER
DECLARE Price : REAL
DECLARE Grade : CHAR
DECLARE Name : STRING
DECLARE Passed : BOOLEAN
Age ← 17
Price ← 2.50
Grade ← 'A'
Name ← "Mei"
Passed ← TRUE
OUTPUT Name, " is ", Age, " and passed: ", Passed

• Un STRING s'écrit entre guillemets double, un CHAR entre guillemets simple.
• TRUE et FALSE sont des mots clés, donc ils sont en majuscules et ne portent pas de guillemets.

Erreurs courantes

• Écrire FLOAT, DOUBLE ou BOOL. Ce sont de vrais langages, pas ce programme.
• 'Hello' pour une chaîne — les guillemets simples ne tiennent qu'un seul caractère.

DECLARE nomme une variable 变量 et fixe son type avant de l'utiliser.

DECLARE <identifier> : <data type>

DECLARE Counter : INTEGER
DECLARE TotalToPay : REAL
Counter ← 1
TotalToPay ← 19.99
OUTPUT "Item ", Counter, " costs ", TotalToPay

Plusieurs noms d'un même type peuvent aller sur une seule ligne, séparés par des virgules :

DECLARE Length, Width, Area : INTEGER
Length ← 6
Width ← 4
Area ← Length * Width
OUTPUT "Area = ", Area

• Déclare une variable avant sa première utilisation, près du haut de l'algorithme.
• Une variable conserve son type tout au long de l'algorithme — un INTEGER ne contient jamais "Mei".

Erreurs courantes

• Omettre les deux-points : DECLARE Counter INTEGER.
• Utiliser une variable qui n'a jamais été déclarée. L'examen exige la déclaration.

Une constante 常量 est une valeur fixée pour tout l'algorithme — un taux de taxe, π, la taille d'une classe. La nommer une fois signifie qu'un changement se fait à un seul endroit.

CONSTANT <identifier> ← <value>

CONSTANT TaxRate ← 0.20
DECLARE Price, Tax : REAL
Price ← 50.00
Tax ← Price * TaxRate
OUTPUT "Tax to pay: ", Tax

• En 0478 on utilise la flèche, exactement comme pour une affectation.
• La valeur doit être un littéral 字面量 — un nombre, une chaîne, TRUE — jamais un calcul et jamais une autre variable.
• Une constante ne peut jamais recevoir une nouvelle valeur plus tard. C'est toute son utilité.

Erreurs courantes

• CONSTANT TaxRate = 0.20. La forme = est l'orthographe A-Level 9618 — voir sujet 11.
• Affecter à une constante plus loin dans l'algorithme.

L'opérateur d'affectation 赋值 est ←, une flèche pointant vers la gauche. Cela signifie prendre la valeur à droite et la mettre dans la boîte à gauche.

<identifier> ← <value>

DECLARE Counter : INTEGER
Counter ← 0
Counter ← Counter + 1
Counter ← Counter + 1
OUTPUT Counter

Counter ← Counter + 1 semble impossible en mathématiques et est ordinaire comme instruction : calculez le côté droit avec la valeur que la boîte contient maintenant, puis stockez le résultat dedans.

• Si vous ne pouvez pas taper ←, écrivez <-. Les deux sont acceptés, ici et à l'examen.
• Le côté gauche doit être un identifiant unique ou un élément de tableau. Jamais un calcul.

Erreurs courantes

• Counter = 0. En pseudocode = est une comparaison, pas une affectation — et confondre les deux est l'erreur de syntaxe la plus fréquente dans cette épreuve.
• Counter + 1 ← Counter. La flèche pointe vers la chose qui change.

INPUT lit une valeur depuis l'utilisateur dans une variable. OUTPUT affiche une ou plusieurs valeurs.

DECLARE Name : STRING
DECLARE Age : INTEGER
INPUT Name
INPUT Age
OUTPUT "Hello ", Name
OUTPUT "Next year you will be ", Age + 1

• INPUT prend exactement une variable, et cette variable doit déjà être déclarée.
• OUTPUT prend n'importe quel nombre d'éléments séparés par des virgules ; ils sont imprimés l'un après l'autre sans rien entre eux.
• Un littéral 字面量 chaîne dans un OUTPUT va entre guillemets doubles ; une variable non.

Inviter l'utilisateur

Un INPUT seul n'affiche rien à l'écran, donc un algorithme bien écrit affiche d'abord une invite 提示:

DECLARE Radius : REAL
OUTPUT "Enter the radius: "
INPUT Radius
OUTPUT "The diameter is ", Radius * 2

Erreurs courantes

• INPUT "Enter a number", X — l'invite est une instruction OUTPUT séparée.
• OUTPUT "Total: " + Total. 0478 joint les éléments de sortie avec une virgule ; + est une arithmétique et & appartient au A-Level 9618 (sujet 11).
• Oublier les guillemets : OUTPUT Hello cherche une variable nommée Hello.

Cinq opérateurs arithmétiques 算术, dans l'ordre qu'utilise une calculatrice.

DECLARE A, B : INTEGER
A ← 7
B ← 2
OUTPUT "Sum: ", A + B
OUTPUT "Product: ", A * B
OUTPUT "Quotient: ", A / B
OUTPUT "Power: ", A ^ B

Les parenthèses viennent en premier, puis ^, puis * et /, puis + et - — la priorité 优先级. Utilisez des parenthèses chaque fois que le lecteur devrait s'arrêter pour réfléchir.

DECLARE Total : REAL
Total ← (12 + 18) / 2
OUTPUT "Mean: ", Total

Erreurs courantes

• Attendre que / donne un nombre entier. 7 / 2 est 3.5, pas 3 ; pour un nombre entier utilisez DIV.
• Écrire A x B ou A ÷ B. Utilisez * et /.

La division entière 整数除法 répond à deux questions différentes, et 0478 écrit chacune d'elles comme un fonction 函数, avec les deux valeurs entre parenthèses.

• DIV(a, b) — combien de fois b tient dans a, le quotient 商.
• MOD(a, b) — ce qu'il reste, le reste 余数.

OUTPUT DIV(10, 3)
OUTPUT MOD(10, 3)
OUTPUT DIV(17, 5)
OUTPUT MOD(17, 5)

Les deux prennent des entiers, et les deux retournent un entier.

À quoi elles servent

MOD est le test standard pour divise exactement, ce qui en fait le moyen de demander si un nombre est pair 偶数 :

DECLARE Number : INTEGER
Number ← 12
IF MOD(Number, 2) = 0
  THEN
    OUTPUT Number, " is even"
  ELSE
    OUTPUT Number, " is odd"
ENDIF

DIV convertit un total en unités entières — secondes en minutes, pence en livres :

DECLARE Seconds : INTEGER
Seconds ← 200
OUTPUT DIV(Seconds, 60), " minutes and ", MOD(Seconds, 60), " seconds"

Erreurs courantes

• 10 MOD 3. C'est la forme A-Level 9618 ; 0478 utilise la forme fonction MOD(10, 3).
• Mélanger les deux. DIV donne la partie entière ; MOD donne ce qui ne rentre pas.

Un opérateur relationnel 关系运算符 compare deux valeurs et produit TRUE ou FALSE.

DECLARE Mark : INTEGER
Mark ← 55
OUTPUT "Pass: ", Mark >= 50
OUTPUT "Perfect: ", Mark = 100
OUTPUT "Not zero: ", Mark <> 0

Les trois opérateurs logiques 逻辑运算符 joignent des conditions :

• AND — les deux côtés doivent être TRUE.
• OR — au moins un côté doit être TRUE.
• NOT — transforme TRUE en FALSE et vice versa.

DECLARE Age : INTEGER
DECLARE HasTicket : BOOLEAN
Age ← 16
HasTicket ← TRUE
IF Age >= 15 AND HasTicket = TRUE
  THEN
    OUTPUT "Admitted"
ENDIF
IF NOT (Age > 18)
  THEN
    OUTPUT "Still a student rate"
ENDIF

Erreurs courantes

• <> est le signe différent de ici — pas !=, qui appartient à d'autres langages.
• IF Age >= 15 AND <= 18. Chaque côté de AND nécessite sa propre comparaison complète : Age >= 15 AND Age <= 18.
• Appeler ces opérateurs de comparaison dans une réponse. Le terme du programme est relationnel.

0478 publie quatre routines de chaînes 字符串 et aucune autre. Trois d'entre elles sont ici.

LENGTH(<identifier>) retourne combien de caractères 字符 une chaîne contient — espaces inclus.

OUTPUT LENGTH("Happy Days")
OUTPUT LENGTH("")

UCASE(<identifier>) retourne la chaîne en MAJUSCULES 大写, LCASE(<identifier>) en minuscules case 小写. Aucun ne modifie la valeur originale — chacun retourne une nouvelle valeur.

DECLARE Name : STRING
Name ← "Happy"
OUTPUT UCASE(Name)
OUTPUT LCASE(Name)
OUTPUT Name

Cette dernière ligne imprime toujours Happy : pour garder le changement, vous devez l'affecter en retour.

DECLARE Name : STRING
Name ← "Happy"
Name ← UCASE(Name)
OUTPUT Name

Comparer sans se soucier de la casse

UCASE des deux côtés est la méthode standard pour accepter une réponse quelle que soit sa frappe :

DECLARE Answer : STRING
Answer ← "yes"
IF UCASE(Answer) = "YES"
  THEN
    OUTPUT "Accepted"
ENDIF

Erreurs courantes

• Attendre que UCASE(Name) modifie Name. Affectez le résultat en retour.
• LENGTH compte les caractères, pas les mots. LENGTH("Happy Days") vaut 10.

SUBSTRING(<identifier>, <start>, <length>) extrait une portion d'une chaîne — en commençant à la position start, en prenant length caractères.

OUTPUT SUBSTRING("Happy Days", 1, 5)
OUTPUT SUBSTRING("Happy Days", 7, 4)

⚠️ Le comptage commence à 1, pas 0. Le premier caractère de "Happy Days" est à la position 1.

Prendre un seul caractère, et le reste

DECLARE Word : STRING
Word ← "Computer"
OUTPUT "First letter: ", SUBSTRING(Word, 1, 1)
OUTPUT "Last letter: ", SUBSTRING(Word, LENGTH(Word), 1)
OUTPUT "Without the first: ", SUBSTRING(Word, 2, LENGTH(Word) - 1)

LENGTH à l'intérieur de SUBSTRING est ce qui rend les deux dernières lignes fonctionnelles pour un mot de taille quelconque — durcir 8 casserait dès que le mot changerait.

Lire une chaîne un caractère à la fois

DECLARE Word : STRING
DECLARE Index : INTEGER
Word ← "Cat"
FOR Index ← 1 TO LENGTH(Word)
    OUTPUT SUBSTRING(Word, Index, 1)
NEXT Index

Erreurs courantes

• Commence à 0. La position 1 est le premier caractère.
• Lire le troisième argument comme une position de fin. C'est un compte — SUBSTRING(W, 2, 3) prend trois caractères en partant du deuxième.
• Demander plus de caractères que la chaîne ne contient.

Sélection 选择 exécute un groupe d'instructions ou un autre, selon une condition 条件.

IF <condition>
  THEN
    <statements>
ENDIF

DECLARE Mark : INTEGER
Mark ← 72
IF Mark >= 50
  THEN
    OUTPUT "Pass"
ENDIF

Ajouter ELSE pour l'autre cas. Exactement une des deux branches 分支 s'exécute — jamais les deux, jamais aucune.

DECLARE Mark : INTEGER
Mark ← 41
IF Mark >= 50
  THEN
    OUTPUT "Pass"
  ELSE
    OUTPUT "Fail"
ENDIF

La mise en page est la seule partie où les élèves perdent des points, apprenez-la comme une forme :

• IF et sa condition sur une même ligne, rien après la condition.
• THEN et ELSE sur leurs propres lignes, indentés de deux espaces.
• Les instructions indentées de quatre.
• ENDIF revient à la colonne de son IF.

Emboîtement 嵌套

Un IF dans un IF gère plus de deux issues. Chacun a besoin de son propre ENDIF.

DECLARE Mark : INTEGER
Mark ← 85
IF Mark >= 80
  THEN
    OUTPUT "Distinction"
  ELSE
    IF Mark >= 50
      THEN
        OUTPUT "Pass"
      ELSE
        OUTPUT "Fail"
    ENDIF
ENDIF

Erreurs courantes

• Oublier ENDIF. Chaque IF se ferme, et un manquant est une erreur de syntaxe 语法错误 que le marqueur verra instantanément.
• IF Mark >= 50 THEN OUTPUT "Pass" sur une seule ligne. Aucune telle forme n'existe ni dans programme ; écrivez les trois lignes.
• IF Mark = 50 THEN écrit comme IF Mark ← 50. La flèche assigne ; = compare.

Quand une variable est testée contre plusieurs valeurs uniques, CASE OF l'exprime bien plus clairement qu'une pile d'emboîtements IFs.

CASE OF <identifier>
    <value 1> : <statement>
    <value 2> : <statement>
    OTHERWISE <statement>
ENDCASE

DECLARE Choice : INTEGER
Choice ← 2
CASE OF Choice
    1 : OUTPUT "You chose north"
    2 : OUTPUT "You chose south"
    3 : OUTPUT "You chose east"
    4 : OUTPUT "You chose west"
    OTHERWISE OUTPUT "That is not a direction"
ENDCASE

• Chaque branche est une valeur, un deux-points, puis ce qu'il faut faire.
• OTHERWISE attrape tout ce que les valeurs listées ont manqué. C'est optionnel, et en écrire un est une bonne pratique — c'est ce qui se passe quand l'utilisateur tape quelque chose d'inattendu.
• La première branche correspondante s'exécute, et les autres sont ignorées.

Une plage, et un caractère

DECLARE Grade : CHAR
Grade ← 'B'
CASE OF Grade
    'A' : OUTPUT "Excellent"
    'B' : OUTPUT "Good"
    'C' : OUTPUT "Satisfactory"
    OTHERWISE OUTPUT "Unclassified"
ENDCASE

Erreurs courantes

• Utiliser CASE OF pour une condition. Elle teste une variable contre des valeurs ; Mark >= 50 nécessite un IF.
• Oublier ENDCASE.
• Omettre OTHERWISE puis se demander pourquoi une valeur inattendue ne fait rien du tout.

Itération 迭代 répète des instructions. Utilisez une boucle FOR lorsque vous savez avant de commencer combien de fois — une boucle à contrôle de comptage 计数控制.

FOR <identifier> ← <value1> TO <value2>
    <statements>
NEXT <identifier>

DECLARE Index : INTEGER
FOR Index ← 1 TO 5
    OUTPUT "Line ", Index
NEXT Index

Le compteur 计数器 commence à la première valeur, et la boucle s'exécute une fois pour chaque valeur jusqu'à et en incluant la seconde. 1 TO 5 s'exécute cinq fois.

PAS

STEP change la taille de chaque saut. Un pas négatif compte vers le bas.

DECLARE Index : INTEGER
FOR Index ← 2 TO 10 STEP 2
    OUTPUT Index
NEXT Index
FOR Index ← 3 TO 1 STEP -1
    OUTPUT "Countdown ", Index
NEXT Index

Sommes cumulées

L'usage le plus courant : une variable hors de la boucle à laquelle la boucle ajoute.

DECLARE Index, Total : INTEGER
Total ← 0
FOR Index ← 1 TO 10
    Total ← Total + Index
NEXT Index
OUTPUT "Sum of 1 to 10 is ", Total

Total ← 0 doit se situer avant la boucle. À l'intérieur, il serait réinitialisé à chaque passage.

Erreurs courantes

• NEXT nommant le mauvais compteur. Les boucles imbriquées doivent se fermer dans l'ordre inverse de celui où elles s'ouvrent : l'inner NEXT d'abord.
• Supposer que 1 TO 5 s'exécute quatre fois. Les deux extrémités sont incluses.
• Modifier le compteur à l'intérieur de la boucle. Laissez FOR en être propriétaire.

Une boucle WHILE teste avant chaque passage, donc elle peut s'exécuter zéro fois. Utilisez-la lorsque le nombre de répétitions dépend de quelque chose qui se produit pendant l'exécution de la boucle.

WHILE <condition> DO
    <statements>
ENDWHILE

DECLARE Total : INTEGER
Total ← 1
WHILE Total < 100 DO
    Total ← Total * 2
ENDWHILE
OUTPUT "First power of two past 100: ", Total

Quelque chose à l'intérieur de la boucle doit finalement rendre la condition fausse, sinon la boucle ne finit jamais — un boucle infinie 无限循环.

DECLARE Count : INTEGER
Count ← 5
WHILE Count > 0 DO
    OUTPUT Count
    Count ← Count - 1
ENDWHILE
OUTPUT "Lift off"

Erreurs courantes

• Oublier de modifier la variable testée par la condition, provoquant une boucle infinie.
• Omettre DO ou ENDWHILE.
• Utiliser WHILE lorsque le comptage est connu. Un FOR exprime votre sens en une seule ligne.

Une boucle REPEAT teste après chaque passage, donc elle s'exécute toujours au moins une fois.

REPEAT
    <statements>
UNTIL <condition>

Ce « au moins une fois » est la raison de la choisir : valider 验证 l'entrée, où vous devez demander avant de pouvoir juger la réponse.

DECLARE Number : INTEGER
Number ← 0
REPEAT
    Number ← Number + 25
    OUTPUT "Trying ", Number
UNTIL Number >= 100
OUTPUT "Reached ", Number

⚠️ UNTIL énonce la condition qui arrête la boucle ; WHILE énonce celle qui la maintient active. Elles sont opposées, et les inverser est l'erreur classique.

Erreurs courantes

• Écrire UNTIL Number < 100 au lieu de UNTIL Number >= 100.
• Utiliser REPEAT là où le corps doit pouvoir s'exécuter zéro fois.
• Oublier que UNTIL termine la structure — il n'y a pas de ENDREPEAT.

Un tableau 数组 contient de nombreuses valeurs d'un même type sous un seul nom. Chaque valeur est placée à un index 下标.

DECLARE <identifier> : ARRAY[<lower>:<upper>] OF <data type>

DECLARE Names : ARRAY[1:3] OF STRING
Names[1] ← "Mei"
Names[2] ← "Sam"
Names[3] ← "Ana"
OUTPUT Names[2]

• Les bornes 边界 sont écrites lower:upper, et les deux sont incluses — [1:3] a trois éléments 元素.
• Les tableaux Cambridge commencent normalement à 1, pas 0.
• Chaque élément a le même type, défini par OF.

Remplir et lire avec une boucle POUR

Un tableau et une boucle comptée vont ensemble : le compteur est l'index.

DECLARE Scores : ARRAY[1:5] OF INTEGER
DECLARE Index, Total : INTEGER
FOR Index ← 1 TO 5
    Scores[Index] ← Index * 10
NEXT Index
Total ← 0
FOR Index ← 1 TO 5
    Total ← Total + Scores[Index]
NEXT Index
OUTPUT "Total: ", Total
OUTPUT "Mean: ", Total / 5

Trouver le plus grand

DECLARE Scores : ARRAY[1:5] OF INTEGER
DECLARE Index, Largest : INTEGER
Scores[1] ← 42
Scores[2] ← 17
Scores[3] ← 93
Scores[4] ← 8
Scores[5] ← 55
Largest ← Scores[1]
FOR Index ← 2 TO 5
    IF Scores[Index] > Largest
      THEN
        Largest ← Scores[Index]
    ENDIF
NEXT Index
OUTPUT "Largest: ", Largest

Commencez Largest au premier élément, jamais à 0 — avec des données négatives, 0 gagnerait et la réponse serait fausse.

Erreurs courantes

• Lire Scores[6] depuis un tableau déclaré [1:5]. C'est hors limites 越界.
• Écrire Scores(3). Les tableaux utilisent des crochets ; les parenthèses appelent une fonction.
• Déclarer [1:5] puis parcourir 0 TO 4.

Un tableau 2-D 二维数组 est un tableau : lignes et colonnes, deux index.

DECLARE <identifier> : ARRAY[<lower1>:<upper1>, <lower2>:<upper2>] OF <data type>

DECLARE Grid : ARRAY[1:2, 1:3] OF INTEGER
Grid[1,1] ← 1
Grid[1,2] ← 2
Grid[1,3] ← 3
Grid[2,1] ← 4
Grid[2,2] ← 5
Grid[2,3] ← 6
OUTPUT Grid[2,3]

Le premier index est la ligne 行, le second la colonne 列.

Les boucles imbriquées parcourent un tableau

Une boucle par dimension 维度. La boucle intérieure termine une ligne entière avant que l'extérieure ne passe à la suivante.

DECLARE Grid : ARRAY[1:2, 1:3] OF INTEGER
DECLARE Row, Col : INTEGER
FOR Row ← 1 TO 2
    FOR Col ← 1 TO 3
        Grid[Row, Col] ← Row * Col
    NEXT Col
NEXT Row
FOR Row ← 1 TO 2
    FOR Col ← 1 TO 3
        OUTPUT "Grid[", Row, ",", Col, "] = ", Grid[Row, Col]
    NEXT Col
NEXT Row

⚠️ L'inner NEXT ferme le compteur intérieur. NEXT Row avant NEXT Col traverse les boucles et n'a aucun sens — un marqueur le remarque instantanément.

Erreurs courantes

• Inverser ligne et colonne. Grid[2,3] est ligne 2, colonne 3.
• Grid[Row][Col]. Cambridge écrit une paire de crochets avec une virgule à l'intérieur.
• Traverser les lignes NEXT comme ci-dessus.

Une procédure 过程 est un bloc nommé d'instructions. En écrire une une fois et l'appeler depuis plusieurs endroits est la décomposition 分解 — l'idée sur laquelle repose entièrement le papier 2.

PROCEDURE <identifier>
    <statements>
ENDPROCEDURE

Une procédure est appelée par nom, avec le mot-clé CALL :

PROCEDURE DefaultLine
    OUTPUT "------------------------------"
ENDPROCEDURE

CALL DefaultLine
OUTPUT "Report"
CALL DefaultLine

• La définition 定义 ne fait rien toute seule. Seul CALL l'exécute.
• Le contrôle retourne à la ligne suivant l'appel CALL lorsque la procédure se termine.
• Une procédure ne renvoie pas de valeur. Si vous en avez besoin, vous voulez une fonction.

Erreurs courantes

• Écrire DefaultLine seul pour l'exécuter. 0478 exige CALL.
• Omettre ENDPROCEDURE.
• S'attendre à ce que les variables propres à la procédure existent à l'extérieur.

Une fonction 函数 est une procédure qui rend une valeur. Elle s'écrit là où cette valeur est nécessaire — à l'intérieur d'un OUTPUT, à droite d'une affectation, dans une condition.

FUNCTION <identifier>(<parameters>) RETURNS <data type>
    <statements>
    RETURN <value>
ENDFUNCTION

FUNCTION SumSquare(Number1 : INTEGER, Number2 : INTEGER) RETURNS INTEGER
    RETURN Number1 * Number1 + Number2 * Number2
ENDFUNCTION

OUTPUT "Sum of squares = ", SumSquare(10, 20)

• RETURNS <data type> dans l'en-tête indique quel type est rendu. Ce n'est pas optionnel.
• RETURN termine la fonction immédiatement — rien après ne s'exécute.
• Une fonction n'est jamais appelée avec CALL ; elle est utilisée partout où sa valeur est requise.

Une fonction dans une condition

FUNCTION IsEven(Number : INTEGER) RETURNS BOOLEAN
    RETURN MOD(Number, 2) = 0
ENDFUNCTION

DECLARE Index : INTEGER
FOR Index ← 1 TO 6
    IF IsEven(Index)
      THEN
        OUTPUT Index, " is even"
    ENDIF
NEXT Index

Erreurs courantes

• CALL SumSquare(10, 20) — qui jette la réponse.
• Une fonction sans RETURN sur certains chemins. Chaque sortie doit retourner une valeur.
• Omettre RETURNS INTEGER de l'en-tête.

Un paramètre 参数 est une valeur qu'une procédure ou une fonction reçoit lors de son appel. Chacun portent son propre type.

PROCEDURE Line(Size : INTEGER)
    DECLARE Index : INTEGER
    FOR Index ← 1 TO Size
        OUTPUT "-"
    NEXT Index
ENDPROCEDURE

CALL Line(5)
CALL Line(20)

Plusieurs paramètres sont séparés par des virgules, et l'ordre à l'appel doit correspondre à l'ordre dans la définition :

PROCEDURE Greet(Name : STRING, Times : INTEGER)
    DECLARE Index : INTEGER
    FOR Index ← 1 TO Times
        OUTPUT "Hello ", Name
    NEXT Index
ENDPROCEDURE

CALL Greet("Mei", 2)
CALL Greet("Sam", 1)

⚠️ Dans 0478 tous les paramètres sont passés par valeur 传值 : la procédure travaille sur une copie, donc la modifier à l'intérieur ne change rien à l'extérieur. Pour obtenir une valeur de retour, utilisez une FUNCTION et RETURN la. (A-Level 9618 ajoute BYREF pour l'autre comportement — sujet 11.)

FUNCTION Doubled(Number : INTEGER) RETURNS INTEGER
    RETURN Number * 2
ENDFUNCTION

DECLARE Value : INTEGER
Value ← 7
Value ← Doubled(Value)
OUTPUT Value

Erreurs courantes

• PROCEDURE Line(Size) sans type.
• Appeler avec les arguments dans le mauvais ordre — Greet(2, "Mei") est une erreur de type.
• S'attendre à ce qu'une procédure modifie la variable que vous avez passée. En 0478, elle ne peut pas.

Un fichier 文件 conserve les données après la fin du programme. 0478 utilise quatre commandes, et chacune nomme le fichier sur lequel elle opère.

OPENFILE <file identifier> FOR WRITE
WRITEFILE <file identifier>, <data>
CLOSEFILE <file identifier>

OPENFILE "names.txt" FOR WRITE
WRITEFILE "names.txt", "Mei"
WRITEFILE "names.txt", "Sam"
CLOSEFILE "names.txt"
OUTPUT "Saved"

Trois modes de fichier 文件模式 :

OPENFILE "log.txt" FOR WRITE
WRITEFILE "log.txt", "first"
CLOSEFILE "log.txt"
OPENFILE "log.txt" FOR APPEND
WRITEFILE "log.txt", "second"
CLOSEFILE "log.txt"
OUTPUT "Both lines saved"

• Un WRITEFILE écrit une ligne.
• CLOSEFILE n'est pas optionnel. Un fichier non fermé peut perdre les données encore en attente d'être écrites, et c'est une réponse d'examen classique.

Erreurs courantes

• FOR WRITE au lieu de FOR APPEND, qui détruit silencieusement l'ancien contenu.
• Oublier CLOSEFILE.
• Ouvrir un fichier déjà ouvert.

READFILE lit une ligne dans une variable. La variable doit être déclarée au préalable.

OPENFILE <file identifier> FOR READ
READFILE <file identifier>, <variable>
CLOSEFILE <file identifier>

Normalement, vous ne savez pas combien de lignes il y a, donc vous lisez jusqu'à la fin du fichier — ce que rapporte la fonction EOF.

OPENFILE "names.txt" FOR WRITE
WRITEFILE "names.txt", "Mei"
WRITEFILE "names.txt", "Sam"
WRITEFILE "names.txt", "Ana"
CLOSEFILE "names.txt"

DECLARE Line : STRING
OPENFILE "names.txt" FOR READ
WHILE NOT EOF("names.txt") DO
    READFILE "names.txt", Line
    OUTPUT Line
ENDWHILE
CLOSEFILE "names.txt"

EOF("names.txt") est TRUE une fois que toutes les lignes ont été lues, donc WHILE NOT EOF(...) signifie tant qu'il reste encore quelque chose à lire.

Compter pendant la lecture

OPENFILE "marks.txt" FOR WRITE
WRITEFILE "marks.txt", 40
WRITEFILE "marks.txt", 65
WRITEFILE "marks.txt", 88
CLOSEFILE "marks.txt"

DECLARE Mark, Count, Total : INTEGER
Count ← 0
Total ← 0
OPENFILE "marks.txt" FOR READ
WHILE NOT EOF("marks.txt") DO
    READFILE "marks.txt", Mark
    Count ← Count + 1
    Total ← Total + Mark
ENDWHILE
CLOSEFILE "marks.txt"
OUTPUT Count, " marks, mean ", Total / Count

Erreurs courantes

• Une boucle WHILE EOF(...) — qui ne s'exécute que lorsqu'il ne reste plus rien. Vous voulez NOT.
• Lire au-delà de la fin car la boucle n'a pas de garde EOF.
• Ouvrir FOR READ un fichier qui n'a jamais été écrit.

Cambridge publie deux spécifications pseudocode, et elles divergent. Tout dans les chapitres 1-10 correspond à l'IGCSE 0478. L'A-Level 9618 modifie les détails ci-dessous — et un élève qui étudie les deux perd des points en écrivant l'un dans l'examen de l'autre.

Il s'agit du format 0478, et il s'exécute ici :

DECLARE Total : REAL
CONSTANT Rate ← 0.5
Total ← 10
IF MOD(7, 2) = 1
  THEN
    OUTPUT "Odd, half rate ", Total * Rate
ENDIF

Le format 9618 du même algorithme est écrit ainsi — notez THEN sur la IF ligne, = dans le CONSTANT, et MOD entre ses deux valeurs :

DECLARE Total : REAL
CONSTANT Rate = 0.5
Total ← 10
IF 7 MOD 2 = 1 THEN
    OUTPUT "Odd, half rate " & STR(Total * Rate)
ENDIF

⚠️ Laquelle est correcte dépend uniquement de l'examen que vous passez. Aucune n'est une erreur; chacune est une erreur dans l'examen de l'autre. Le terrain de jeu de cette page exécute les règles 0478, ainsi une construction 9618 sera refusée avec un message indiquant le programme auquel elle appartient — qui est un moyen rapide de vérifier vos propres habitudes.

Erreurs courantes

• Écrire THEN sur la IF ligne dans une réponse 0478, parce que c'est ce qu'un manuel ou un site web a montré. C'est l'erreur inter-programmes la plus courante.
• 10 MOD 3 en 0478. Là, c'est MOD(10, 3).
• ROUND(3.14159, 2) dans une réponse 9618. Le 9618 n'a absolument pas de ROUND.

Le 0478 passe tous les paramètres par valeur 传值 (chapitre 9). Le 9618 vous laisse choisir, et l'indique dans l'en-tête.

• BYVAL — la procédure reçoit une copie. La modifier ne change rien à l'extérieur. C'est le défaut lorsque ni l'un ni l'autre mot n'est écrit.
• BYREF — la procédure travaille sur la variable propriétaire 引用 de l'appelant, donc un changement est visible après l'appel.

Ceci est uniquement pour le 9618. Il ne s'exécute pas ici, et n'est pas accepté dans une réponse 0478 :

PROCEDURE Increase(BYREF Value : INTEGER)
    Value ← Value + 1
ENDPROCEDURE

DECLARE Count : INTEGER
Count ← 5
CALL Increase(Count)
OUTPUT Count      // prints 6

La façon 0478 d'obtenir une valeur en retour

Utilisez une FUNCTION et affectez ce qu'elle retourne. C'est toute la réponse 0478, et elle s'exécute :

FUNCTION Increased(Value : INTEGER) RETURNS INTEGER
    RETURN Value + 1
ENDFUNCTION

DECLARE Count : INTEGER
Count ← 5
Count ← Increased(Count)
OUTPUT Count

Erreurs courantes

• Écrire BYREF dans une réponse 0478. Ce mot-clé n'est pas dans ce programme.
• S'attendre à ce qu'un paramètre 9618 standard se comporte comme une BYREF. Sans le mot, c'est BYVAL.

Le 9618 possède des structures de données 数据结构 que le 0478 n'a pas. Vous les rencontrerez uniquement au niveau A-Level, et aucun ne s'exécute sous les règles 0478 de cette page.

Un record 记录 regroupe des champs de types différents sous un seul nom (section 9618 4) :

TYPE Student
    DECLARE Name : STRING
    DECLARE Mark : INTEGER
ENDTYPE

DECLARE Candidate : Student
Candidate.Name ← "Mei"
Candidate.Mark ← 91
OUTPUT Candidate.Name, " scored ", Candidate.Mark

Un type énuméré 枚举类型 liste les seules valeurs qu'une variable peut prendre :

TYPE Vehicle = (Car, Bus, Taxi)
DECLARE MyRide : Vehicle
MyRide ← Taxi

Le 9618 ajoute également un type de données DATE, fichiers à accès aléatoire (OPENFILE … FOR RANDOM), pointeurs, et classes avec CLASS … ENDCLASS pour son examen orienté objet.

⚠️ Le 0478 a cinq types de données et les tableaux, et rien d'autre (chapitre 2). Une réponse 0478 qui déclare un enregistrement répond à un autre programme.

Erreurs courantes

• Utiliser un enregistrement dans une réponse 0478. Utilisez plutôt des tableaux parallèles — un tableau par champ, partageant un index.
• Penser que TYPE signifie la même chose que DECLARE. TYPE définit un nouveau type ; DECLARE crée une variable d'un type existant.