Programmation

De la conception au code

Vous devriez être capable de transformer une conception — un organigramme 流程图 (program flowchart) ou anglais structuré 结构化英语 — en pseudo-code 伪代码, puis dans un langage réel :

1. repérez les variables 变量 et leurs types de données 数据类型.
2. convertissez les boîtes d'entrée/sortie en INPUT / OUTPUT.
3. convertissez les losanges de décision en IF...ELSE...ENDIF (ou CASE).
4. convertissez les flèches de boucle en WHILE, REPEAT...UNTIL, ou FOR.
5. convertissez les boîtes de traitement en affectations ou calculs.
6. vérifiez en effectuant un traçage avec une petite entrée.

Constantes et variables

Une constante 常量 retient une valeur qui ne change jamais ; une variable retient une valeur qui peut changer. Déclarez-les avec un type :

CONSTANT Pi = 3.14159
DECLARE Radius : REAL
DECLARE Area : REAL

Radius ← 5
Area ← Pi * Radius * Radius

Utilisez des constantes pour les valeurs fixes qui reviennent (Pi, MaxScore) ; elles rendent le code plus clair et facile à modifier en un seul endroit.

Dans l'examen, une constante est la réponse à la question « identifier un moyen plus approprié de représenter » une valeur fixe, comme un taux de taxe ou un score maximum, qui apparaît à plusieurs endroits dans le pseudo-code. Les avantages que le barème liste : la valeur est définie une seule fois et ne peut pas être modifiée accidentellement par le programme ; un changement est fait en un seul endroit et atteint toutes les instructions qui l'utilisent ; l'identifiant donne à la valeur un sens (MaxScore plutôt que 100), donc le code est plus facile à lire et à vérifier ; et il y a moins de risque d'erreur de frappe dans une longue valeur telle que 3.14159. Une question « indiquer une valeur qui pourrait être remplacée par une constante » demande la littérale du pseudo-code (0.2, 40), pas un nouveau nom.

Chaque variable est déclarée une seule fois, avec un identificateur 标识符 (son nom) et un type de données, avant qu'elle ne soit utilisée. Les six types dans le guide de pseudo-code 9618 :

Une question « donner le type de données approprié » se répond selon la manière dont la variable est utilisée dans le pseudo-code : une valeur avec une virgule décimale est REAL ; quelque chose défini à TRUE ou FALSE est BOOLEAN ; une valeur entre guillemets simples est CHAR ; une valeur utilisée comme index de tableau, ou avec DIV et MOD, est INTEGER. Écrivez le type en majuscules, orthographié comme le guide l'écrit.

Exemple résolu. Indiquez le type de données approprié pour chaque variable.

Found ← FALSE
Initial ← 'K'
Price ← 12.99
Count ← Count + 1
Name ← "Li Wei"

Found est BOOLEAN (elle retient FALSE) ; Initial est CHAR (un caractère entre guillemets simples) ; Price est REAL (une valeur décimale) ; Count est INTEGER (un compteur qui augmente de un) ; Name est STRING (du texte entre guillemets doubles).

Affectation et expressions

Utilisez ← pour l'affectation 赋值 :

Total ← Total + 1
Average ← Sum / Count

Les expressions utilisent des opérateurs 运算符 :

• arithmétiques + - * /, plus DIV (division entière) et MOD (reste) : 7 DIV 2 = 3 ; 7 MOD 2 = 1.
• comparaisons =, <>, <, >, <=, >=.
• logique AND, OR, NOT.

Précédence 优先级 (du plus élevé au plus bas) : NOT → * / DIV MOD → + - → comparaisons → AND → OR. Utilisez des parenthèses si vous n'en êtes pas sûr.

Entrée et sortie

OUTPUT "Enter your name:"
INPUT Name
OUTPUT "Hello, ", Name

Fonctions intégrées et routines de bibliothèque

De nombreuses tâches disposent de routines de bibliothèque 库例程 prêtes, donc vous n'avez pas besoin de les écrire. La feuille d'insertion Paper 2 insert 附页 répertorie celles que vous pouvez utiliser, avec leurs noms exacts, paramètres et types de retour ; toute autre fonction dont une question a besoin est donnée dans l'énoncé. Les noms ci-dessous sont ceux de l'insert. VAL et STR sont des noms IGCSE et n'apparaissent ni dans le document 9618, donc ils ne rapportent rien. UCASE et LCASE sont d'un cas différent : ce sont des 9618, définis dans le Guide de Pseudo-code, mais ils prennent un seul CHAR, et l'insert ne les répertorie absolument pas — pour une chaîne complète sur Paper 2, la routine est TO_UPPER.

Une bibliothèque de programmes 程序库 contient des routines déjà écrites, compilées et testées ; un programme les appelle au lieu d'en écrire ses propres. Les avantages que le barème accepte, pour une question « citez trois avantages » : les routines sont déjà testées, donc elles sont moins susceptibles de contenir des erreurs ; elles économisent du temps de développement ; elles peuvent faire des choses qu'un programmeur ne pourrait pas écrire (statistiques complexes, graphismes) ; elles sont écrites par des experts et réutilisées dans de nombreux programmes ; et une routine avec une interface fixe peut être appelée depuis n'importe où dans le programme.

Les chaînes sont jointes avec & (concaténation 连接) : "A" & "BC" est "ABC". Utilisez les noms exacts de l'insert, avec les paramètres dans son ordre.

Les dates et nombres aléatoires apparaissent sous forme d'instructions sur une ligne. SETDATE(17, 11, 2007) construit le 17 novembre 2007 ; 12 - MONTH(MyDOB) est le nombre de mois du mois de naissance jusqu'à la fin de l'année ; IF DAYINDEX(MyDOB) = 5 THEN teste pour un jeudi, car dimanche est le jour 1. RAND(n) retourne un nombre réel de 0 jusqu'à, mais sans inclure, n, donc un entier aléatoire de Low à High inclus est INT(RAND(High - Low + 1)) + Low : INT(RAND(21)) - 10 donne une valeur de -10 à 10.

Exemple résolu. Évaluez chaque expression, sachant Word ← "Program", Code ← 'Q' et N ← 7.

Travaillez de l'intérieur vers l'extérieur, et gardez les guillemets : "7" est une chaîne et 7 est un nombre.

Exemple résolu. Chaque instruction peut contenir une erreur dans son utilisation d'une fonction ou d'un opérateur. Décrivez l'erreur, ou écriveZ NO ERROR. (Supposez que chaque variable a le bon type.)

Chaque opérateur fonctionne sur des types particuliers : & sur les chaînes, + - * / DIV MOD sur les nombres, AND OR NOT sur les Booléens, et = <> sur deux valeurs du même type. Un tableau « évaluez chaque expression, ou écrivez ERROR » est noté de la même façon : LENGTH(42) et "A" + 1 sont ERROR, car le type ne correspond pas à la fonction ou à l'opérateur.

Exemple résolu. Avec Points ← 100, Active ← TRUE et Exempt ← FALSE, évaluez chaque expression.

La dernière expression se simplifie : X OR NOT X est TRUE quel que soit X, donc toute l'expression n'est que NOT Exempt. Évaluez d'abord les parenthèses, puis NOT, ensuite AND, puis OR.

Sélection 选择 choisit quelles étapes s'exécutent.

IF age >= 18 THEN
    OUTPUT "Adult"
ELSE
    OUTPUT "Minor"
ENDIF

Pour plus de deux cas, vous pouvez utiliser un IF imbriqué nested 嵌套, mais une forte imbrication est difficile à lire — un CASE est plus propre lors du test d'une valeur contre plusieurs options :

CASE OF Grade
    "A": OUTPUT "Excellent"
    "B": OUTPUT "Good"
    OTHERWISE: OUTPUT "Try again"
ENDCASE

Cambridge CASE permet les valeurs simples, les listes de valeurs (1, 2, 3:) et les plages (1 TO 5:).

Un IF imbriqué est un IF à l'intérieur d'une branche d'un autre IF. Chaque IF a besoin de son propre ENDIF, et l'examinateur vérifie que chaque construction est fermée :

IF Mark >= 50 THEN
    IF Mark >= 80 THEN
        OUTPUT "Distinction"
    ELSE
        OUTPUT "Pass"
    ENDIF
ELSE
    OUTPUT "Fail"
ENDIF

Les limites sont là où des points sont perdus. "Une note de 50 ou plus suffit" est Mark >= 50, pas Mark > 50 ; la dernière CASE branche, pour "tout le reste", s'écrit OTHERWISE, pas une condition comme > 200. Une mauvaise comparaison ici est une erreur logique 逻辑错误 : le programme s'exécute, mais donne la mauvaise sortie pour certaines entrées — et une table de traçage avec une valeur limite telle que 50 est la méthode pour la détecter.

Exemple résolu. Réécrivez ceci avec la même fonctionnalité, sans utiliser de structure CASE.

CASE OF MySwitch
    1: ThisChar ← 'a'
    2: ThisChar ← 'y'
    3: ThisChar ← '7'
    OTHERWISE: ThisChar ← '*'
ENDCASE

Chaque valeur devient une branche d'une chaîne de IFs, et OTHERWISE devient la dernière ELSE :

IF MySwitch = 1 THEN
    ThisChar ← 'a'
ELSE
    IF MySwitch = 2 THEN
        ThisChar ← 'y'
    ELSE
        IF MySwitch = 3 THEN
            ThisChar ← '7'
        ELSE
            ThisChar ← '*'
        ENDIF
    ENDIF
ENDIF

Deux clauses qui attribuent la même valeur sont fusionnées en une seule clause avec une liste de valeurs : 1, 2: ThisChar ← 'a'. Les gardes sont testés dans l'ordre : avec des plages telles que 1 TO 50: suivies de 40 TO 60:, une valeur de 45 suit la première branche correspondante, donc une attribution dans une branche ultérieure peut ne jamais être exécutée — et lorsque les branches précédentes couvrent déjà toutes les valeurs possibles, la branche OTHERWISE n'est jamais atteinte non plus.

Dans l'autre sens, les IF imbriqués qui testent plusieurs booléens sont plus clairs sous la forme d'une condition par résultat : IF A AND B AND C THEN CALL Sub1(), puis IF A AND B AND NOT C THEN CALL Sub2(), et ainsi de suite. Le regroupement des tests avec AND et OR élimine l'imbrication, et IF A THEN est accepté à la place de IF A = TRUE THEN.

Itération 迭代 répète un bloc. Trois boucles diffèrent par le nombre de fois que le corps s'exécute.

Boucle contrôlée par compteur (FOR)

Une boucle contrôlée par compteur 计数循环 — utilisez-la lorsque vous savez combien de fois répéter :

FOR i ← 1 TO 10
    OUTPUT i
NEXT i

Un STEP peut modifier le compteur (par ex. FOR i ← 10 TO 1 STEP -1). Idéal pour un nombre fixe de répétitions ou pour traiter chaque élément d'un tableau 数组.

Boucle à précondition (WHILE)

Une boucle à précondition 前测循环 teste la condition avant chaque passage, elle peut donc s'exécuter zéro fois :

WHILE total < 100 DO
    INPUT n
    total ← total + n
ENDWHILE

Boucle à postcondition (REPEAT...UNTIL)

Une boucle à postcondition 后测循环 teste la condition après chaque passage, elle s'exécute donc toujours au moins une fois :

REPEAT
    INPUT password
UNTIL password = correctPassword

Choisir la bonne boucle

• compteur connu à l'avance → FOR.
• peut nécessiter zéro passages → WHILE.
• toujours au moins un passage → REPEAT...UNTIL.

Justifiez votre choix selon si le compteur est connu et si le corps doit s'exécuter au moins une fois. Une question typique donne un scénario ("demander un mot de passe jusqu'à ce qu'il soit correct, mais toujours demander au moins une fois") et demande quelle boucle convient.

Les deux points sont attribués au nom de la boucle et à la raison, dans les termes du barème : count-controlled, because the number of iterations is known before the loop starts; post-condition, because the loop body must be executed at least once; pre-condition, because the loop may not need to execute at all. Une boucle sur les quatre éléments d'un tableau écrit comme un WHILE avec un compteur est "pas la plus appropriée" : le compteur, quatre, est connu, donc une boucle FOR convient.

Exemple résolu. Quelle boucle convient à chaque tâche ? (a) imprimer la table de multiplication de 12 ; (b) continuer à lire des nombres jusqu'à ce que l'utilisateur entre 0 ; (c) demander un mot de passe jusqu'à ce qu'il soit correct. Choisissez en demandant combien de fois le corps s'exécute et quand le test a lieu. (a) Le compteur est connu à l'avance (12), donc utilisez une boucle FOR. (b) Le compteur est inconnu, et la toute première entrée pourrait déjà être 0 - donc le test doit venir avant le corps : une boucle WHILE, qui s'exécute zéro ou plus fois. (c) Le compteur est inconnu, mais vous devez toujours demander au moins une fois avant qu'il y ait quoi que ce soit à tester - donc le test vient après le corps : une REPEAT...UNTIL, qui s'exécute une ou plus fois. La question décisive est de savoir si le corps doit s'exécuter au moins une fois : WHILE peut s'exécuter zéro fois, REPEAT s'exécute toujours une fois.

Exécution manuelle avec une table de traçage

Une table de traçage 跟踪表 enregistre la valeur de chaque variable pendant que vous faites une exécution manuelle 手工跟踪 (passez en revue à la main) un algorithme. C'est comment vous testez une boucle sur papier, et c'est une question de six points sur la plupart des Paper 2s.

DECLARE Count, Total : INTEGER
Count ← 1
Total ← 0
WHILE Total < 10
    Total ← Total + Count * 2
    Count ← Count + 1
ENDWHILE
OUTPUT Count, Total

Règles qui rapportent les points : une colonne par variable, dans l'ordre donné par la question ; n'écrivez une valeur que lorsqu'elle change ; commencez une nouvelle ligne à chaque fois que la boucle se répète ; évaluez la condition avec les valeurs actuelles, et arrêtez-vous dès qu'elle est FALSE ; mettez la sortie dans sa propre colonne, exactement tel qu'elle apparaîtrait. Tracez l'algorithme tel qu'il est écrit, pas celui que vous pensez avoir été intendu — s'il ne s'arrête jamais, dites-le.

Exemple résolu. Quelles constructions utilise chaque ligne — sélection, itération ou appel de sous-routine ?

CALL Start()

FIN SI | FOR I ← 1 TO 20 ... NEXT I | | yes | | | WHILE NOT IsFull() ... ENDWHILE | | yes | yes | | CASE OF Key ... OTHERWISE ... ENDCASE | yes | | |

IF et CASE sont des sélections ; FOR, WHILE et REPEAT sont des itérations ; un nom suivi de parenthèses — Start(), IsFull() — est un appel à une procédure ou une fonction, partout où il apparaît, y compris dans une condition.

Programmation structurée 结构化编程 construit un programme à partir de petites sous-routines 子程序 nommées, chacune ayant une seule tâche.

Procédure

Une procédure 过程 est un bloc nommé qui exécute une action ; elle peut prendre des paramètres 参数 mais ne retourne pas de valeur.

PROCEDURE Greet(name : STRING)
    OUTPUT "Hello, ", name
ENDPROCEDURE

CALL Greet("Ada")

Fonction

Une fonction 函数 est semblable à une procédure mais elle retourne une valeur qui fait partie d'une expression.

FUNCTION Square(x : INTEGER) RETURNS INTEGER
    RETURN x * x
ENDFUNCTION

result ← Square(5) + 1     // result = 26

Utilisez une procédure lorsque la sous-routine effectue une action ; utilisez une fonction lorsqu'elle calcule une valeur pour l'appelant.

Le syllabus demande où, dans la construction d’un algorithme, chacun est approprié. Une procédure est appropriée lorsque le même groupe d’étapes est nécessaire à plusieurs endroits (valider une entrée, imprimer un menu, échanger deux valeurs) : les étapes sont écrites une fois et CALLées par nom. Une fonction est appropriée lorsqu’une seule valeur doit être calculée puis utilisée dans une expression — un total, un résultat TRUE/FALSE, le plus grand de deux nombres — car la valeur de retour 返回值 remplace l’appel : IF IsValid(Code) THEN.

Paramètres

Un paramètre est une variable qu'une sous-routine déclare pour recevoir une entrée ; les valeurs fournies par l'appelant sont des arguments 实参. Deux façons de les passer :

• passage par valeur 传值 — la routine reçoit une copie ; les modifications à l'intérieur n'affectent pas l'appelant. Utilisez pour les entrées qu'elle lit uniquement.
• passage par référence 传引用 — la routine reçoit une référence à la variable de l'appelant ; les modifications affectent l'appelant. Utilisez lorsqu'elle doit mettre à jour un paramètre.

PROCEDURE Swap(BYREF a : INTEGER, BYREF b : INTEGER)
    DECLARE temp : INTEGER
    temp ← a
    a ← b
    b ← temp
ENDPROCEDURE

Le pseudocode Cambridge écrit le mode dans l'en-tête, BYVAL ou BYREF, avant chaque paramètre. Si aucun n'est écrit, BYVAL est supposé, donc une routine qui doit modifier la variable de l'appelant — Swap, ou une procédure qui met à jour un total accumulé — nécessite BYREF dans son en-tête.

Exemple résolu. Quelle est la sortie ?

PROCEDURE Adjust(BYREF X : INTEGER, BYVAL Y : INTEGER)
    X ← X + Y
    Y ← Y * 2
ENDPROCEDURE

A ← 5
B ← 3
CALL Adjust(A, B)
OUTPUT A, B

X est une référence à A, donc A devient 8. Y est une copie de B, donc doubler Y laisse B à 3. La sortie est 8, 3. Si l'en-tête avait dit BYVAL X, A serait toujours 5.

Variables locales vs globales

Une variable locale 局部变量 est déclarée à l'intérieur d'une sous-routine et n'existe que tant qu'elle s'exécute. Une variable globale 全局变量 est déclarée à l'extérieur et est visible partout. Privilégiez les variables locales et les paramètres — une utilisation excessive des variables globales rend le code difficile à suivre et à tester. (La zone où un nom est visible est sa portée 作用域.)

La différence d'une ligne : une variable globale peut être accédée de n'importe où dans le programme, une variable locale uniquement à l'intérieur de la sous-routine qui la déclare. Avantages des variables locales acceptés par le barème : le même identificateur peut être utilisé dans une autre sous-routine sans conflit ; la valeur ne peut pas être changée accidentellement par d'autres parties du programme ; la mémoire est libérée lorsque la sous-routine se termine ; et la sous-routine est autonome, elle peut donc être testée individuellement et réutilisée dans un autre programme.

Une variable locale est créée chaque fois que la sous-routine est appelée et détruite lors du retour, elle ne peut donc pas conserver une valeur d'un appel à l'autre. Une procédure qui construit une chaîne sur des appels répétés a donc besoin que cette chaîne soit globale (ou passée BYREF). Si MyString est changée d'une variable globale à une variable locale déclarée à l'intérieur de MyOutput(), chaque appel commence avec une nouvelle MyString vide, le texte ajouté par les appels précédents est perdu, et la procédure "ne fonctionne pas comme prévu".

Quand utiliser une sous-routine

Utilisez une sous-routine lorsque :

• la même logique apparaît à plusieurs endroits — écrivez-la une fois, appelez-la plusieurs fois.
• un bloc a un but nommé clair — le nom documente ce qu'il fait.
• le programme est complexe — divisez-le en parties (décomposition 分解).
• vous voulez tester une partie isolément.

Ne les rendez pas si petites que le coût de l'appel dépense plus que le travail à l'intérieur.

Terminologie

• définition — le bloc PROCEDURE ... ENDPROCEDURE (ou fonction).
• appel — là où il est invoqué. argument — une valeur passée. paramètre — la variable qui le reçoit.
• valeur de retour — ce qu'une fonction renvoie.
• en-tête de procédure/fonction — la première ligne donnant le nom et les paramètres (PROCEDURE Name(params) ou FUNCTION Name(params) RETURNS type).
• interface de procédure/fonction / signature 签名 — nom + paramètres + type de retour : ce qu'un appelant doit savoir pour l'utiliser.

Exemple résolu. Décrivez chaque terme utilisé dans l'en-tête FUNCTION Pass2(Count : INTEGER) RETURNS BOOLEAN.

Les deux identifiants dans PROCEDURE MyProc(Count : INTEGER, Message : STRING) sont des paramètres : ils reçoivent les valeurs passées lors de l'appel de la procédure et sont utilisés à l'intérieur comme des variables locales.

Pour convertir une procédure en fonction : remplacez PROCEDURE par FUNCTION et ajoutez RETURNS <type> ; remplacez le OUTPUT (ou le paramètre BYREF qui transportait le résultat vers l'extérieur) par une instruction RETURN ; et modifiez chaque appel pour que la valeur retournée soit utilisée, Result ← Unpack(Text) au lieu de CALL Unpack(Text, Result). Pour une question « écrire l'en-tête », écrivez toute la ligne : FUNCTION Calculate(Expression : STRING) RETURNS INTEGER. Un paramètre tableau est passé par référence, donc une procédure qui écrit dans un tableau modifie le tableau de l'appelant.

Lorsqu'un programme acquiert un nouveau module, l'interface est d'abord agreed : le nom, les paramètres (combien, dans quel ordre, de quel type) et le type de retour, ainsi que toute donnée globale que le module lit ou écrit. Un module envoyant un rappel avant une date limite a besoin du record (ou de son index) comme paramètre et ne retourne rien, c'est donc une procédure ; le programme principal l'appelle une fois par record.

Écrire un module pour Paper 2

La moitié de Paper 2 est « écrire du pseudocode pour le module X ». Le barème attribue une marque par élément, donc un module inachevé obtient encore des points pour chaque bonne partie. Les éléments que l'examinateur recherche :

1. L'en-tête, tel que décrit par la question : PROCEDURE Name(Param : TYPE) ou FUNCTION Name(Param : TYPE) RETURNS TYPE, avec BYREF où la routine doit modifier l'argument.
2. Déclarations locales : DECLARE chaque variable locale avec son type, et initialisez les compteurs et totaux (Count ← 0).
3. La boucle visitant chaque élément : FOR Index ← 1 TO 50 pour un tableau dont la taille est donnée ; WHILE NOT EOF(...) pour un fichier.
4. La condition, avec la bonne comparaison et borne, sur le bon élément : IF Score[Index] > Limit THEN.
5. La mise à jour à l'intérieur de la branche : le compteur augmenté, la valeur stockée, ou le message affiché.
6. La fin : RETURN une fois, après la boucle, dans une fonction ; ENDFUNCTION ou ENDPROCEDURE ; et chaque IF, FOR et WHILE fermé.

Exemple résolu. Un tableau global Score : ARRAY[1:50] OF INTEGER contient les notes. Écrivez une fonction CountAbove(Limit : INTEGER) qui retourne combien de notes sont supérieures à Limit.

FUNCTION CountAbove(BYVAL Limit : INTEGER) RETURNS INTEGER
    DECLARE Index, Count : INTEGER
    Count ← 0
    FOR Index ← 1 TO 50
        IF Score[Index] > Limit THEN
            Count ← Count + 1
        ENDIF
    NEXT Index
    RETURN Count
ENDFUNCTION

Marques : l'en-tête avec son paramètre et RETURNS INTEGER ; Count déclaré et mis à 0 ; une boucle sur les 50 éléments ; la comparaison > Limit (pas >=) ; le compteur mis à jour à l'intérieur du IF ; RETURN Count après la boucle. Le programme principal utilise la valeur de retour dans une expression ou une sortie : OUTPUT "Above 70: ", CountAbove(70).

Exemple résolu. Écrivez une fonction IsValid(Code : STRING) qui retourne TRUE lorsque Code est deux lettres majuscules suivies de quatre chiffres — le format 格式 AB1234 — et FALSE sinon.

FUNCTION IsValid(BYVAL Code : STRING) RETURNS BOOLEAN
    DECLARE Index : INTEGER
    DECLARE Ch : STRING
    IF LENGTH(Code) <> 6 THEN
        RETURN FALSE
    ENDIF
    FOR Index ← 1 TO 6
        Ch ← MID(Code, Index, 1)
        IF Index <= 2 THEN
            IF Ch < "A" OR Ch > "Z" THEN
                RETURN FALSE
            ENDIF
        ELSE
            IF Ch < "0" OR Ch > "9" THEN
                RETURN FALSE
            ENDIF
        ENDIF
    NEXT Index
    RETURN TRUE
ENDFUNCTION

Le contrôle de longueur vient en premier, donc MID n'est jamais demandé pour une position inexistante. Une validation 验证 comme celle-ci retourne un BOOLEAN pour que l'appelant puisse écrire IF IsValid(Entry) THEN ... ELSE OUTPUT "Invalid code" ENDIF : un message à l'utilisateur est affiché par l'appelant, pas par la fonction — une fonction calcule, une procédure agit.

Exemple résolu. Écrivez une fonction IsPalindrome(Word : STRING) qui retourne TRUE lorsque Word se lit de la même manière à l'envers, comme "RACECAR".

Comparez les caractères des deux extrémités, en avançant vers l'intérieur : la position Index est appariée avec la position Len - Index + 1, et seule la première moitié doit être testée.

FUNCTION IsPalindrome(BYVAL Word : STRING) RETURNS BOOLEAN
    DECLARE Len, Index : INTEGER
    Len ← LENGTH(Word)
    FOR Index ← 1 TO Len DIV 2
        IF MID(Word, Index, 1) <> MID(Word, Len - Index + 1, 1) THEN
            RETURN FALSE
        ENDIF
    NEXT Index
    RETURN TRUE
ENDFUNCTION

Les mêmes trois outils — une FOR sur les positions, MID(s, i, 1) pour lire un caractère, et & pour construire une nouvelle chaîne — répondent à la plupart des modules de chaînes sur Paper 2 : compter combien de fois un caractère apparaît (IF MID(s, i, 1) = Ch THEN Count ← Count + 1), remplacer chaque instance d'un caractère (ajouter soit NewChar ou le caractère original à NewString à chaque position), masquer tout sauf les quatre derniers chiffres d'un numéro de carte (ajouter '*' pour chaque position jusqu'à Len - 4), ou écrire votre propre MID() en joignant les caractères de Start à Start + Length - 1. Demander MID pour une position beyond la fin de la chaîne est une erreur d'exécution, donc vérifiez LENGTH d'abord.

Fichiers. Les valeurs dans les variables disparaissent quand le programme se termine, donc un module qui doit conserver des données pour la prochaine exécution les écrit dans un fichier : OPENFILE "scores.txt" FOR WRITE, une WRITEFILE "scores.txt", NUM_TO_STR(Score[Index]) par ligne à l'intérieur de la boucle, et CLOSEFILE "scores.txt" une fois, après la boucle ; la lecture utilise FOR READ, READFILE et WHILE NOT EOF("scores.txt"). Topic 10 a la section complète sur les fichiers ; ici les marques sont pour l'ouverture dans le bon mode, la lecture ou l'écriture à l'intérieur de la boucle, et la fermeture une fois après celle-ci.

Trois caractéristiques qui facilitent la compréhension du pseudocode — la réponse à une question « énoncer trois caractéristiques » — sont les identifiants significatifs (Total, pas t), l'indentation des instructions à l'intérieur de chaque construction, et les commentaires (// ...) expliquant le but ; les mots-clés en majuscules, une instruction par ligne et des lignes vides entre les sections sont aussi acceptés. Le pseudocode efficace va plus loin :

• déplacer les invariants hors des boucles — si une valeur (un invariant 不变量) ne change pas avec le compteur de boucle, calculez-la une fois avant la boucle.
• sortir d'une boucle tôt lorsque la réponse est trouvée (arrêter une recherche linéaire 线性查找 dès que la cible apparaît).
• éviter le travail redondant — stocker un résultat et le réutiliser au lieu de recalculer.
• choisir la bonne structure de données — un tableau bat de nombreux variables séparées lorsque les éléments appartiennent ensemble.
• remplacer les IF imbriqués profonds par CASE lorsqu'on teste une valeur contre beaucoup.
• commenter l'intention, pas la mécanique (// validate the postcode, pas // loop 6 times).
• utiliser des noms significatifs (numberOfPupils, pas n) et initialiser les variables avant usage.

Trois types d'erreurs, chacun trouvé d'une manière différente :

Un IDE 集成开发环境 aide à trouver les deux derniers : un point d'arrêt 断point arrête le programme à une ligne choisie ; le pas à pas 单步执行 exécute ensuite une instruction à la fois ; et la fenêtre de rapport (ou surveillance) montre la valeur de chaque variable à cet instant, donc la ligne où une valeur devient erronée est vue directement. Les méthodes de test et les données de test sont dans le topic 12.

Une question de définition est notée selon un libellé fixe. Apprenez-le exactement.

• Distiguez une procédure (pas de valeur de retour) d'une fonction (renvoie une valeur) ; maîtrisez le passage par valeur vs par référence.
• Choisissez la bonne boucle : contrôlée par compteur (FOR) lorsque le nombre de répétitions est connu, contrôlée par condition (WHILE/REPEAT) sinon.
• Distiguez les variables locales vs globales et leur portée ; privilégiez les variables locales dans les modules réutilisables.
• Utilisez les noms exacts des routines et l'ordre des paramètres de l'insertion. VAL et STR sont des noms IGCSE et ne rapportent aucun point ; UCASE et LCASE sont de vraies routines 9618 du Guide de Pseudocode mais agissent sur un seul caractère, donc sur Paper 2, une chaîne entière prend TO_UPPER ou TO_LOWER.
• Dans une réponse « écrire du pseudocode », l'en-tête, les déclarations, la boucle, la condition, la mise à jour et la ⟨RETURN⟩ rapportent chacun un point : écrivez les six parties, même si l'une vous est incertaine.

Erreurs courantes

• Appeler une fonction sans utiliser ce qu’elle retourne. Assigner le résultat, ou l’utiliser dans l’expression ou la sortie : Sorted ← BubbleSort(MyArray, 7).
• Passer une longueur d'un : 6 pour un tableau de sept éléments, ou le dernier index où la longueur était souhaitée. Décidez si le paramètre est une longueur ou un index, et vérifiez que le dernier élément est visité.
• Fermer un fichier à l'intérieur de la boucle qui le lit. Ouvrez une fois, fermez une fois, après la boucle.
• Utiliser l'entrée directement comme nom de fichier. Ajoutez l'extension donnée par la question : FileName ← Choice & ".txt".
• Laisser des structures ouvertes. Chaque IF a son ENDIF, chaque FOR a son NEXT, chaque WHILE a son ENDWHILE, et chaque fonction a son RETURN ; le schéma prévoit une marque pour cela.
• Mauvaises bornes : > pour "au moins" (qui est >=), ou un FOR qui commence à 0 pour un tableau déclaré [1:50].
• Un compteur ou un total qui n'est jamais initialisé à 0 avant la boucle.
• Dans une table de traçage, réécrire toutes les variables à chaque ligne, ou modifier une valeur avant que la instruction qui la modifie ne se soit exécutée.
• Moitié de condition : IF x = 3 OR 4 — chaque côté de OR et AND doit être une comparaison complète. Et + ne joint pas les chaînes ; & le fait.
• Déclarer comme locale une valeur qui doit persister entre les appels. Un total cumulé ou une chaîne construite sur plusieurs appels est global ou BYREF.