Passer au contenu
Sujets
  • 1 Style et mise en page
    1.1

    Mots-clés et casse

    Le pseudocode est le langage utilisé par Cambridge pour écrire des algorithmes. Il décrit des algorithmes sans nécessiter un langage de programmation généraliste. Ce site interprète un sous-ensemble défini de style Cambridge afin que vous puissiez exécuter des exemples ; une réponse d'examen doit suivre la notation spécifiée pour cette épreuve.

    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.
    1.2

    Identifiants

    Un identifiant est le nom que vous donnez à une variable, une constante, une procédure ou une fonction.

    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 sensibilité aux cas, 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.
    1.3

    Commentaires et indentation

    Un commentaire commence par // et se prolonge jusqu'à la fin de la ligne. Il est destiné aux humains 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
    

    La indentation indique quelles instructions sont à l'intérieur d'une structure. Le programme exige 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.
    Un bloc SI-ALORS-SINON avec barres d'indentation ombragées : SI et FIN DU SI en marge, ALORS et SINON deux espaces dedans, chaque AFFICHAGE quatre espaces dedans
    Compter les espaces : 0, 2, 4

    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.
  • 2 Variables, constantes et types
    2.1

    Les cinq types de données

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

    Type Holds Example
    INTEGER nombre entier 42, -7
    REAL un nombre pouvant comporter une partie fractionnaire 3.14, -0.5
    CHAR caractère unique 'A'
    STRING séquence de caractères "Hello"
    BOOLEAN TRUE ou FALSE TRUE
    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.
    Les cinq types de données : INTEGER, REAL, CHAR, STRING et BOOLEAN
    Les cinq types de données : INTEGER, REAL, CHAR, STRING et BOOLEAN
    2.2

    DECLARE

    DECLARE nomme une variable et fixe son type avant que vous ne l'utilisiez.

    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 RoomLength, Width, Area : INTEGER
    RoomLength ← 6
    Width ← 4
    Area ← RoomLength * 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.
    DECLARE nomme une variable et fixe le type de valeur qu'elle peut contenir
    DECLARE nomme une variable et fixe le type de valeur qu'elle peut contenir
    2.3

    CONSTANT

    Une constante est une valeur fixée pour tout l'algorithme — un taux d'imposition, π, 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 de caractères, 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.
  • 3 Affectation, entrée et sortie
    3.1

    La flèche d'affectation

    L'opérateur d'affectation est ←, une flèche pointant vers la gauche. Il 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.

    Trois lignes d'affectation à côté de la boîte Counter : 0 est stocké, puis 0 + 1 est calculé et 1 stocké, puis 1 + 1 est calculé et 2 stocké
    Côté droit d'abord, puis stocker dans la boîte
    • 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.
    3.2

    INPUT et OUTPUT

    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.
    • Une chaîne littérale dans un OUTPUT va entre guillemets doubles ; une variable non plus.

    Inviter l'utilisateur

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

    DECLARE Radius : REAL
    OUTPUT "Enter the radius: "
    INPUT Radius
    OUTPUT "The diameter is ", Radius * 2
    
    Trois affirmations s'enchaînent verticalement, OUTPUT une invite, INPUT Nom, OUTPUT un message de bienvenue, à côté de l'écran qu'elles produisent
    Le message apparaît d'abord, puis la réponse tapée, puis la réponse

    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.
  • 4 Arithmétique et logique
    4.1

    Opérateurs arithmétiques

    Cinq opérateurs arithmétiques ; leur priorité est listée sous le tableau.

    Opérateur Signification A vaut 7, B vaut 2
    + addition A + B est 9
    - soustraction A - B est 5
    * multiplication A * B est 14
    / division A / B est 3.5
    ^ élever à une puissance A ^ B est 49
    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 /.
    4.2

    DIV et MOD

    La division entière répond à deux questions distinctes, et 0478 écrit chacune d'elles comme un fonction, avec les deux valeurs entre crochets.

    • DIV(a, b) — combien de fois entières b entre 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.

    17 divisé en groupes de 5 : DIV donne les 3 groupes entiers, MOD le 2 restant
    17 divisé en groupes de 5 : DIV donne les 3 groupes entiers, MOD le 2 restant

    À 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.
    4.3

    Opérateurs relationnels et logiques

    Un opérateur relationnel compare deux valeurs et produit TRUE ou FALSE.

    Opérateur Signifie
    = est égal à
    <> n'est pas égal à
    > est supérieur à
    < est inférieur à
    >= est supérieur ou égal à
    <= est inférieur ou égal à
    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.
    AND nécessite que les deux tests soient VRAI : l'âge 14 passe les deux, l'âge 10 échoue au premier
    AND nécessite que les deux tests soient VRAI : l'âge 14 passe les deux, l'âge 10 échoue au premier
  • 5 Opérations sur les chaînes
    5.1

    LENGTH, UCASE et LCASE

    0478 publie quatre routines de chaînes de caractères et aucune autre. Trois d'entre elles sont ici.

    LENGTH(<identifier>) retourne le nombre de caractères qu'une chaîne contient — espaces inclus.

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

    UCASE(<identifier>) retourne la chaîne en majuscules, LCASE(<identifier>) en minuscules aucune ne modifie l'originale — chacune 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.
    5.2

    SUBSTRING

    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.

    Les indices comptent à partir de 1 : SUBSTRING("Computer", 1, 4) donne "Comp"
    Les indices comptent à partir de 1 : SUBSTRING("Computer", 1, 4) donne "Comp"

    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.
  • 6 Sélection
    6.1

    SI, ALORS, SINON, FINSI

    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.
    IF choisit l'un de deux chemins ; les deux se rejoignent à ENDIF
    IF choisit l'un de deux chemins ; les deux se rejoignent à ENDIF

    Encastrement

    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 son absence 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.
    6.2

    CAS DE

    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.
    CASE compare la valeur à chaque option successivement ; Grade = 2 correspond à la deuxième
    CASE compare la valeur à chaque option successivement ; Grade = 2 correspond à la deuxième

    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.
  • 7 Itération
    7.1

    POUR, la boucle comptée

    Itération répète des instructions. Utilisez une boucle FOR lorsque vous savez avant de commencer combien de fois — une boucle contrôlée par compteur.

    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.

    FOR Compteur ← 1 TO 4 effectue quatre passages, et les valeurs 1 et 4 sont incluses
    FOR Compteur ← 1 TO 4 effectue quatre passages, et les valeurs 1 et 4 sont incluses

    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.
    7.2

    TANT QUE, la boucle pré-condition

    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 — une 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.
    7.3

    RÉPÉTER, la boucle post-condition

    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 choisir cette structure : valider une saisie, 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.

    Teste S'exécute au moins une fois ? Condition signifie
    FOR un compteur non (une plage vide s'exécute zéro fois) —
    WHILE avant non continuer tant que ceci est vrai
    REPEAT après oui arrêter lorsque ceci devient vrai

    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.
    WHILE teste d'abord et peut ne pas s'exécuter ; REPEAT teste après et s'exécute au moins une fois
    WHILE teste d'abord et peut ne pas s'exécuter ; REPEAT teste après et s'exécute au moins une fois
  • 8 Tableaux
    8.1

    Tableaux unidimensionnels

    Un tableau contient plusieurs valeurs du même type sous un nom unique. Chaque valeur est placée à un indice.

    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 s'écrivent lower:upper, et les deux sont incluses — [1:3] possède trois éléments.
    • Les tableaux Cambridge commencent normalement à 1, pas 0.
    • Chaque élément a le même type, défini par OF.
    Un tableau 1-D : un nom, plusieurs valeurs, chacune identifiée par son index
    Un tableau 1-D : un nom, plusieurs valeurs, chacune identifiée par son index

    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.
    8.2

    Tableaux bidimensionnels

    Un tableau 2-D est une table : lignes et colonnes, deux indices.

    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 indice correspond à la ligne, le second à la colonne.

    Un tableau 2-D est une grille : G[1, 2] désigne la ligne 1, colonne 2
    Un tableau 2-D est une grille : G[1, 2] désigne la ligne 1, colonne 2

    Les boucles imbriquées parcourent un tableau

    Une boucle par dimension. La boucle intérieure termine toute une ligne 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.
  • 9 Procédures et fonctions
    9.1

    PROCÉDURE et APPEL

    Une procédure est un bloc nommé d'instructions. L'écrire une seule fois et l'appeler depuis plusieurs endroits constitue la décomposition — le principe sur lequel repose tout programme 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 par elle-même. Seul l'appel 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.
    9.2

    FONCTION et RETOUR

    Une fonction est une routine nommée qui retourne 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 procédure est APPELÉE pour accomplir une tâche ; une fonction retourne une valeur à utiliser
    Une procédure est APPELÉE pour accomplir une tâche ; une fonction retourne une valeur à utiliser

    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

    • Le CALL SumSquare(10, 20) — le CALL invoque une procédure, pas une fonction. Utilisez la fonction dans une expression, comme Answer ← SumSquare(10, 20).
    • Une fonction sans RETURN sur certains chemins. Chaque sortie doit retourner une valeur.
    • Omettre RETURNS INTEGER de l'en-tête.
    9.3

    Paramètres

    Un paramètre est une valeur fournie à une procédure ou une fonction 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, chaque paramètre est passé 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.
  • 10 Gestion de fichiers
    10.1

    Écrire dans un fichier

    Un fichier conserve les données après la fin du programme. 0478 utilise quatre commandes, dont 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 :

    Mode Ce qu'il fait
    WRITE créer un nouveau fichier — tout ce qui y était déjà est perdu
    APPEND ajouter à la fin des données existantes
    READ lire depuis le début
    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.
    10.2

    Lire un fichier jusqu'à la fin

    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.

    Ouvrir un fichier en ÉCRITURE ou LECTURE, le parcourir ligne par ligne, puis le fermer
    Ouvrir un fichier en ÉCRITURE ou LECTURE, le parcourir ligne par ligne, puis le fermer

    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.
  • 11 A-Level 9618 : quels changements
    11.1

    Mise en page et opérateurs

    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.

    IGCSE 0478 A-Level 9618
    THEN sur sa propre ligne, indentée de 2 sur la même IF ligne
    constantes CONSTANT Pi ← 3.142 CONSTANT Pi = 3.142
    DIV / MOD fonctions : DIV(10, 3) opérateurs : 10 DIV 3
    concaténation de chaînes virgules dans OUTPUT l'opérateur &
    identifiants doivent commencer par une majuscule casse mixte autorisée
    NEXT doit nommer son compteur bonne pratique
    ROUND, RANDOM() tous deux publiés aucun n'existe

    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 ", 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.
    11.2

    Paramètres : BYVAL et BYREF

    0478 passe tous les paramètres par valeur (sujet 9). 9618 vous permet de choisir et l'indique explicitement 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.
    • Le BYREF — la procédure agit sur la variable propre de l'appelant par référence, donc tout 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
    
    BYVAL transmet une copie ; BYREF permet à la procédure de modifier la variable de l'appelant
    BYVAL transmet une copie ; BYREF permet à la procédure de modifier la variable de l'appelant

    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.
    11.3

    Enregistrements et autres types

    9618 possède des structures de données que 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 enregistrement regroupe des champs de types différents sous un même 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.
    Un enregistrement regroupe des champs de types différents ; la notation par point accède à chacun d'eux
    Un enregistrement regroupe des champs de types différents ; la notation par point accède à chacun d'eux

Se connecter ou créer un compte

IGCSE, A-Level & AP