Programação

Do projeto ao código

Você deve ser capaz de transformar um projeto — um fluxograma 流程图 (program flowchart) ou inglês estruturado 结构化英语 — em pseudocódigo 伪代码, e depois em uma linguagem real:

1. encontre as variáveis 变量 e seus tipos de dados 数据类型.
2. transforme caixas de entrada/saída em INPUT / OUTPUT.
3. transforme losangos de decisão em IF...ELSE...ENDIF (ou CASE).
4. transforme setas de loop em WHILE, REPEAT...UNTIL ou FOR.
5. transforme caixas de processo em atribuições ou cálculos.
6. verifique traçando uma pequena entrada.

Constantes e variáveis

Uma constante 常量 armazena um valor que nunca muda; uma variável armazena um que pode mudar. Declare-os com um tipo:

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

Radius ← 5
Area ← Pi * Radius * Radius

Use constantes para valores fixos que se repetem (Pi, MaxScore); elas tornam o código mais claro e fácil de alterar em um único local.

Na prova, uma constante é a resposta para "identificar uma maneira mais apropriada de representar" um valor fixo, como uma taxa de imposto ou uma pontuação máxima, que aparece em vários lugares no pseudocódigo. Os benefícios listados pelo critério: o valor é definido uma vez e não pode ser alterado acidentalmente pelo programa; uma alteração é feita em um único local e alcança cada instrução que o utiliza; o identificador dá ao valor um significado (MaxScore em vez de 100), tornando o código mais fácil de ler e verificar; e há menos risco de erro de digitação em um valor longo como 3.14159. Uma questão "diga um valor que poderia ser substituído por uma constante" quer o literal do pseudocódigo (0.2, 40), não um novo nome.

Toda variável é declarada uma vez, com um identificador 标识符 (seu nome) e um tipo de dados, antes de ser usada. Os seis tipos no guia de pseudocódigo 9618:

Uma questão "dê o tipo de dados apropriado" é respondida a partir de como a variável é usada no pseudocódigo: um valor com ponto decimal é REAL; algo definido como TRUE ou FALSE é BOOLEAN; um valor entre aspas simples é CHAR; um valor usado como índice de array, ou com DIV e MOD, é INTEGER. Escreva o tipo em maiúsculas, grafado como o guia o faz.

Exemplo resolvido. Diga o tipo de dados apropriado para cada variável.

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

Found é BOOLEAN (ele contém FALSE); Initial é CHAR (um caractere entre aspas simples); Price é REAL (um valor decimal); Count é INTEGER (um contador que aumenta em um); Name é STRING (texto entre aspas duplas).

Atribuição e expressões

Use ← para atribuição 赋值:

Total ← Total + 1
Average ← Sum / Count

Expressões usam operadores 运算符:

• aritméticos + - * /, mais DIV (divisão inteira) e MOD (resto): 7 DIV 2 = 3; 7 MOD 2 = 1.
• comparações =, <>, <, >, <=, >=.
• lógicos AND, OR, NOT.

Precedência 优先级 (maior para menor): NOT → * / DIV MOD → + - → comparações → AND → OR. Use parênteses quando tiver dúvida.

Entrada e saída

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

Funções embutidas e rotinas de biblioteca

Muitas tarefas têm rotinas de biblioteca 库例程 prontas, então você não precisa escrevê-las. A folha inserir 附页 da Prova 2 lista aquelas que você pode usar, com seus nomes exatos, parâmetros e tipos de retorno; qualquer outra função que uma questão precise é dada na própria questão. Os nomes abaixo são os da insert. VAL e STR são nomes IGCSE e aparecem em nenhum documento 9618, então não valem nada. UCASE e LCASE são um caso diferente: eles são 9618, definidos no Guia de Pseudocódigo, mas recebem um único CHAR, e a insert não os lista de todo — para uma string inteira na Prova 2, a rotina é TO_UPPER.

Uma biblioteca de programas 程序库 contém rotinas que já foram escritas, compiladas e testadas; um programa as chama em vez de escrever as próprias. Os benefícios que o critério aceita, para uma questão "diga três benefícios": as rotinas estão já testadas, portanto são menos propensas a conter erros; economizam tempo de desenvolvimento; podem fazer coisas que o programador não conseguiria escrever (estatística complexa, gráficos); são escritas por especialistas e reutilizadas em muitos programas; e uma rotina com interface fixa pode ser chamada de qualquer lugar no programa.

Strings são unidas com & (concatenação 连接): "A" & "BC" é "ABC". Use os nomes exatos da inserção, com os parâmetros em sua ordem.

Datas e números aleatórios aparecem como declarações de uma linha. SETDATE(17, 11, 2007) cria 17 de novembro de 2007; 12 - MONTH(MyDOB) é o número de meses do mês de nascimento até o fim do ano; IF DAYINDEX(MyDOB) = 5 THEN testa por uma quinta-feira, porque domingo é o dia 1. RAND(n) retorna um número real de 0 até, mas sem incluir, n, então um inteiro aleatório de Low a High inclusive é INT(RAND(High - Low + 1)) + Low: INT(RAND(21)) - 10 dá um valor de -10 a 10.

Exemplo resolvido. Avalie cada expressão, dado Word ← "Program", Code ← 'Q' e N ← 7.

Trabalhe de dentro para fora, e mantenha as aspas: "7" é uma string e 7 é um número.

Exemplo resolvido. Cada declaração pode conter um erro em seu uso de uma função ou operador. Descreva o erro, ou escreva SEM ERRO. (Assuma que todas as variáveis têm o tipo correto.)

Todo operador funciona em tipos específicos: & em strings, + - * / DIV MOD em números, AND OR NOT em Booleans, e = <> em dois valores do mesmo tipo. Uma tabela "avalie cada expressão, ou escreva ERROR" é marcada da mesma forma: LENGTH(42) e "A" + 1 são ERROR, porque o tipo não corresponde à função ou ao operador.

Exemplo resolvido. Com Points ← 100, Active ← TRUE e Exempt ← FALSE, avalie cada expressão.

A última expressão simplifica: X OR NOT X é TRUE independente de X, então toda a expressão é apenas NOT Exempt. Avalie os parênteses primeiro, depois NOT, depois AND, depois OR.

Seleção 选择 escolhe quais etapas executam.

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

Para mais de dois casos, você pode usar um aninhado 嵌套 IF, mas aninhamentos profundos são difíceis de ler — um CASE é mais limpo ao testar um valor contra várias opções:

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

Cambridge CASE permite valores únicos, listas de valores (1, 2, 3:) e intervalos (1 TO 5:).

Um IF aninhado é um IF dentro de uma ramificação de outro IF. Cada IF precisa do seu próprio ENDIF, e o examinador verifica se cada construção está fechada:

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

Limites são onde se perdem marcas. "Uma nota de 50 ou mais passa" é Mark >= 50, não Mark > 50; a última CASE ramificação, para "qualquer outra coisa", é escrita como OTHERWISE, não uma condição como > 200. Uma comparação errada aqui é um erro lógico 逻辑错误: o programa executa, mas produz a saída incorreta para algumas entradas — e uma tabela de traço com um valor limite como 50 é como você o encontra.

Exemplo resolvido. Reescreva isto com a mesma funcionalidade, sem usar uma estrutura CASE.

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

Cada valor torna-se uma ramificação de uma cadeia de IFs, e OTHERWISE torna-se o último 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

Duas cláusulas que atribuem o mesmo valor são fundidas em uma única cláusula com uma lista de valores: 1, 2: ThisChar ← 'a'. As guardas são testadas na ordem: com intervalos como 1 TO 50: seguidos por 40 TO 60:, um valor de 45 toma a primeira ramificação que corresponde, então uma atribuição em uma ramificação posterior pode nunca ser executada — e quando as ramificações anteriores já cobrem todos os valores possíveis, a ramificação OTHERWISE também nunca é alcançada.

No sentido oposto, IFs aninhados que testam vários booleans são mais claros como uma condição por resultado: IF A AND B AND C THEN CALL Sub1(), depois IF A AND B AND NOT C THEN CALL Sub2(), e assim por diante. Unir testes com AND e OR remove o aninhamento, e IF A THEN é aceito no lugar de IF A = TRUE THEN.

Iteração 迭代 repete um bloco. Três laços diferem na quantidade de vezes que o corpo é executado.

Loop controlado por contagem (FOR)

Um laço controlado por contagem 计数循环 — use-o quando souber quantas vezes deve repetir:

FOR i ← 1 TO 10
    OUTPUT i
NEXT i

Um STEP pode alterar a contagem (ex. FOR i ← 10 TO 1 STEP -1). Ideal para um número fixo de repetições ou processar cada elemento de uma matriz 数组.

Laço de pré-condição (WHILE)

Um laço de pré-condição 前测循环 testa a condição antes de cada passagem, podendo executar zero vezes:

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

Laço de pós-condição (REPEAT...UNTIL)

Um laço de pós-condição 后测循环 testa a condição depois de cada passagem, executando sempre pelo menos uma vez:

REPEAT
    INPUT password
UNTIL password = correctPassword

Escolher o laço correto

• contagem conhecida de antemão → FOR.
• pode precisar de zero passagens → WHILE.
• pelo menos uma passagem obrigatória → REPEAT...UNTIL.

Justifique sua escolha pela contagem ser conhecida e se o corpo deve executar pelo menos uma vez. Uma questão típica apresenta um cenário ("pedir senha até estar correta, mas sempre pedir pelo menos uma vez") e pergunta qual laço se adapta.

As duas marcas são para o nome do laço e a razão, nas palavras do gabarito: controlado por contagem, porque o número de iterações é conhecido antes do início; pós-condição, porque o corpo deve ser executado pelo menos uma vez; pré-condição, porque o laço pode não precisar executar. Um laço sobre os quatro elementos de uma matriz escrito como um WHILE com um contador é "não o mais adequado": a contagem, quatro, é conhecida, então um laço FOR se encaixa.

Exemplo resolvido. Qual laço se adapta a cada tarefa? (a) imprimir a tabela de multiplicar por 12; (b) continuar lendo números até o usuário inserir 0; (c) pedir uma senha até estar correta. Escolha perguntando quantas vezes o corpo executa e quando o teste ocorre. (a) A contagem é conhecida adiante (12), use um laço FOR. (b) A contagem é desconhecida, e a própria primeira entrada pode já ser 0 — o teste deve vir antes do corpo: um laço WHILE, que executa zero ou mais vezes. (c) A contagem é desconhecida, mas você deve sempre pedir pelo menos uma vez antes de haver algo para testar — o teste vem depois do corpo: um REPEAT...UNTIL, que executa uma ou mais vezes. A pergunta decisiva é se o corpo deve executar pelo menos uma vez: WHILE pode executar zero vezes, REPEAT sempre executa uma vez.

Execução manual com tabela de traço

Uma tabela de traço 跟踪表 registra o valor de cada variável enquanto você faz execução manual 手工跟踪 (percorre à mão) um algoritmo. É como testar um laço no papel, e uma questão de seis marcas na maioria dos Paper 2s.

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

Regras que ganham marcas: uma coluna por variável, na ordem dada pela questão; escreva um valor apenas quando ele muda; inicie uma nova linha sempre que o laço repetir; avalie a condição com os valores atuais, e pare no momento em que for FALSE; coloque a saída em sua própria coluna, exatamente como apareceria. Rastreie o algoritmo conforme escrito, não aquele que você acha que foi pretendido — se nunca parar, diga isso.

Exemplo resolvido. Quais construções cada linha usa — seleção, iteração ou chamada de subrotina?

CALL Start()

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

IF e CASE são seleção; FOR, WHILE e REPEAT são iteração; um nome seguido por parênteses — Start(), IsFull() — é uma chamada a um procedimento ou função, onde quer que apareça, inclusive dentro de uma condição.

Programação estruturada 结构化编程 constrói um programa a partir de pequenas subrotinas 子程序 nomeadas, cada uma com uma única função.

Procedimento

Um procedimento 过程 é um bloco nomeado que realiza uma ação; pode receber parâmetros 参数 mas não retorna um valor.

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

CALL Greet("Ada")

Função

Uma função 函数 é semelhante a um procedimento, mas retorna um valor que se torna parte de uma expressão.

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

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

Use um procedimento quando a subrotina realizar uma ação; use uma função quando calcular um valor para quem a chama.

O programa de estudos pede onde na construção de um algoritmo cada um é apropriado. Um procedimento é apropriado onde o mesmo grupo de passos é necessário em vários pontos (validar uma entrada, imprimir um menu, trocar dois valores): os passos são escritos uma vez e CALL chamados por nome. Uma função é apropriada onde um único valor deve ser calculado e depois usado em uma expressão — um total, um resultado de TRUE/FALSE, o maior de dois números — porque o valor retornado 返回值 substitui a chamada: IF IsValid(Code) THEN.

Parâmetros

Um parâmetro é uma variável que uma subrotina declara para receber entrada; os valores que o chamador fornece são argumentos 实参. Duas formas de passá-los:

• pass by value 传值 — a rotina recebe uma cópia; alterações internas não afetam o chamador. Use para entradas que ela apenas lê.
• pass by reference 传引用 — a rotina recebe uma referência à variável do chamador; alterações afetam o chamador. Use quando deve atualizar um parâmetro.

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

O pseudocódigo Cambridge escreve o modo no cabeçalho, BYVAL ou BYREF, antes de cada parâmetro. Se nenhum for escrito, assume-se BYVAL, então uma rotina que deve alterar a variável do chamador — Swap, ou um procedimento que atualiza um total acumulado — precisa de BYREF em seu cabeçalho.

Exemplo resolvido. O que é impresso?

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 é uma referência a A, então A torna-se 8. Y é uma cópia de B, então dobrar Y deixa B em 3. A saída é 8, 3. Se o cabeçalho tivesse dito BYVAL X, A ainda seria 5.

Variáveis locais vs globais

Uma variável local 局部变量 é declarada dentro de uma subrotina e existe apenas enquanto esta roda. Uma variável global 全局变量 é declarada fora e é visível em toda parte. Prefira locais e parâmetros — uso intenso de globais torna o código difícil de seguir e testar. (A região onde um nome é visível é seu escopo 作用域.)

A diferença de uma linha: uma variável global pode ser acessada de qualquer lugar no programa, uma variável local apenas dentro da subrotina que a declara. Benefícios das variáveis locais aceitos pelo gabarito: o mesmo identificador pode ser usado em outra subrotina sem colisão; o valor não pode ser alterado acidentalmente por outras partes do programa; a memória é liberada quando a subrotina termina; e a subrotina é autônoma, podendo ser testada isoladamente e reutilizada em outro programa.

Uma variável local é criada cada vez que a subrotina é chamada e destruída ao retornar, não podendo carregar um valor de uma chamada para a próxima. Um procedimento que constrói uma string ao longo de chamadas repetidas, portanto, precisa que essa string seja global (ou passada BYREF). Se MyString for mudado de global para local declarado dentro de MyOutput(), toda chamada começa com um novo MyString vazio, o texto adicionado pelas chamadas anteriores é perdido, e o procedimento "não funciona como esperado".

Quando usar uma subrotina

Use uma subrotina quando:

• a mesma lógica aparece em mais de um lugar — escreva-a uma vez, chame-a várias vezes.
• um bloco tem um propósito nomeado claro — o nome documenta o que ele faz.
• o programa é complexo — divida-o em partes (decomposição 分解).
• você quer testar um trecho isoladamente.

Não as faça tão pequenas que o custo da chamada seja maior que o trabalho interno.

Terminologia

• definição — o bloco PROCEDURE ... ENDPROCEDURE (ou função).
• chamada — onde é invocada. argumento — um valor passado. parâmetro — a variável que o recebe.
• valor de retorno — o que uma função devolve.
• cabeçalho do procedimento/função — a primeira linha dando o nome e os parâmetros (PROCEDURE Name(params) ou FUNCTION Name(params) RETURNS type).
• interface/cabecalho do procedimento/função / assinatura 签名 — nome + parâmetros + tipo de retorno: o que um chamador precisa saber para usá-la.

Exemplo resolvido. Descreva cada termo usado no cabeçalho FUNCTION Pass2(Count : INTEGER) RETURNS BOOLEAN.

Os dois identificadores em PROCEDURE MyProc(Count : INTEGER, Message : STRING) são parâmetros: eles recebem os valores passados quando o procedimento é chamado, e são usados dentro dele como variáveis locais.

Para converter um procedimento em uma função: mude PROCEDURE para FUNCTION e adicione RETURNS <type>; substitua o OUTPUT (ou o BYREF parâmetro que carregava o resultado para fora) por uma instrução RETURN; e mude todas as chamadas para que o valor retornado seja usado, Result ← Unpack(Text) em vez de CALL Unpack(Text, Result). Para uma questão "escreva o cabeçalho", escreva a linha inteira: FUNCTION Calculate(Expression : STRING) RETURNS INTEGER. Um parâmetro de array é passado por referência, então um procedimento que escreve em um array altera o array do chamador.

Quando um programa ganha um novo módulo, a interface é o que é acordado primeiro: o nome, os parâmetros (quantos, em que ordem, de que tipo) e o tipo de retorno, além de quaisquer dados globais que o módulo lê ou escreve. Um módulo que envia um lembrete antes de uma data limite precisa do registro (ou seu índice) como parâmetro e não retorna nada, então é um procedimento; o programa principal o chama uma vez por registro.

Escrevendo um módulo para Paper 2

Metade do Paper 2 é "escrever pseudocódigo para o módulo X". O esquema atribui uma marca por recurso, então um módulo incompleto ainda pontua por cada parte correta. As partes que o examinador procura:

1. O cabeçalho, conforme descrito na questão: PROCEDURE Name(Param : TYPE) ou FUNCTION Name(Param : TYPE) RETURNS TYPE, com BYREF onde a rotina deve alterar o argumento.
2. Declarações locais: DECLARE cada variável local com seu tipo, e inicie contadores e totais (Count ← 0).
3. O loop que visita todos os elementos: FOR Index ← 1 TO 50 para um array cujo tamanho é dado; WHILE NOT EOF(...) para um arquivo.
4. A condição, com a comparação e o limite corretos, no item certo: IF Score[Index] > Limit THEN.
5. A atualização dentro do ramo: a contagem aumentada, o valor armazenado, ou a mensagem exibida.
6. O fim: RETURN uma vez, após o loop, em uma função; ENDFUNCTION ou ENDPROCEDURE; e todo IF, FOR e WHILE fechado.

Exemplo resolvido. Um array global Score : ARRAY[1:50] OF INTEGER contém notas de teste. Escreva uma função CountAbove(Limit : INTEGER) que retorne quantas notas são maiores que 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

Marcas: o cabeçalho com seu parâmetro e RETURNS INTEGER; Count declarado e definido como 0; um loop sobre todos os 50 elementos; a comparação > Limit (não >=); a contagem atualizada dentro da IF; RETURN Count após o loop. O programa principal usa o valor de retorno em uma expressão ou saída: OUTPUT "Above 70: ", CountAbove(70).

Exemplo resolvido. Escreva uma função IsValid(Code : STRING) que retorne TRUE quando Code for duas letras maiúsculas seguidas de quatro dígitos — o formato 格式 AB1234 — e FALSE caso contrário.

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

A verificação de comprimento vem primeiro, então MID nunca é solicitado para uma posição que não existe. Validação 验证 assim retorna um BOOLEAN para que o chamador possa escrever IF IsValid(Entry) THEN ... ELSE OUTPUT "Invalid code" ENDIF: uma mensagem ao usuário é exibida pelo chamador, não pela função — uma função calcula, um procedimento age.

Exemplo resolvido. Escreva uma função IsPalindrome(Word : STRING) que retorne TRUE quando Word for lido de trás para frente da mesma forma, como "RACECAR".

Compare os caracteres das duas extremidades, movendo-se para dentro: a posição Index é pareada com a posição Len - Index + 1, e apenas a primeira metade precisa ser testada.

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

As mesmas três ferramentas — um FOR sobre as posições, MID(s, i, 1) para ler um caractere, e & para construir uma nova string — respondem à maioria dos módulos de strings no Paper 2: contar quantas vezes um caractere ocorre (IF MID(s, i, 1) = Ch THEN Count ← Count + 1), substituir todas as instâncias de um caractere (adicionar ou NewChar ou o caractere original a NewString em cada posição), esconder tudo exceto os últimos quatro dígitos de um número de cartão (adicionar '*' para cada posição até Len - 4), ou escrever seu próprio MID() unindo os caracteres de Start a Start + Length - 1. Pedir MID para uma posição após o final da string é um erro de tempo de execução, então verifique LENGTH primeiro.

Arquivos. Os valores nas variáveis desaparecem quando o programa termina, então um módulo que deve manter dados para a próxima execução os grava em um arquivo: OPENFILE "scores.txt" FOR WRITE, um WRITEFILE "scores.txt", NUM_TO_STR(Score[Index]) por linha dentro do loop, e CLOSEFILE "scores.txt" uma vez, após o loop; ler novamente usa FOR READ, READFILE e WHILE NOT EOF("scores.txt"). O Tópico 10 tem a seção completa de arquivos; aqui as marcas são para abrir no modo correto, a leitura ou escrita dentro do loop, e fechar uma vez depois dele.

Três recursos que tornam o pseudocódigo mais fácil de entender — a resposta para uma questão "aponte três recursos" — são identificadores significativos (Total, não t), indentação das instruções dentro de cada construção, e comentários (// ...) que explicam o propósito; palavras-chave em maiúsculas, uma instrução por linha e linhas em branco entre seções também são aceitas. Pseudocódigo eficiente vai mais longe:

• mova invariantes para fora dos loops — se um valor (um invariante 不变量) não muda com o contador do loop, calcule-o uma vez antes do loop.
• saia de um loop cedo quando a resposta for encontrada (pare uma busca linear 线性查找 assim que o alvo aparecer).
• evite trabalho redundante — armazene um resultado e reutilize-o em vez de recalcular.
• escolha a estrutura de dados certa — um array supera muitas variáveis separadas quando os itens pertencem juntos.
• substitua IFs aninhadas profundas por CASE ao testar um valor contra muitos.
• comente a intenção, não a mecânica (// validate the postcode, não // loop 6 times).
• use nomes significativos (numberOfPupils, não n) e inicialize variáveis antes do uso.

Três tipos de erro, cada um encontrado de uma maneira diferente:

Um IDE 集成开发环境 ajuda a encontrar os últimos dois: um ponto de interrupção 断point para o programa em uma linha escolhida; execução passo a passo 单步执行 então roda uma instrução por vez; e a janela de relatório (ou monitor) mostra o valor de cada variável naquele momento, para que a linha onde um valor fica errado seja vista diretamente. Métodos de teste e dados de teste estão no tópico 12.

Uma questão de definição é marcada contra texto fixo. Aprenda estes exatamente.

• Diferencie um procedimento (sem valor de retorno) de uma função (devolve um valor); entenda passagem por valor vs. por referência.
• Escolha o laço certo: controlado por contagem (FOR) quando o número de repetições é conhecido, controlado por condição (WHILE/REPEAT) caso contrário.
• Diferencie variáveis locais vs. globais e escopo; prefira variáveis locais em módulos reutilizáveis.
• Use os nomes exatos das rotinas e ordem dos parâmetros do material didático. VAL e STR são nomes IGCSE e não pontuam; UCASE e LCASE são rotinas reais 9618 do Guia de Pseudocódigo, mas atuam sobre um caractere, então na Prova 2, toda uma string exige TO_UPPER ou TO_LOWER.
• Em uma resposta "escreva pseudocódigo", o cabeçalho, as declarações, o laço, a condição, a atualização e o RETURN valem cada um uma marca: escreva todas as seis partes, mesmo se uma for incerta.

Erros comuns

• Chamar uma função sem usar o que ela devolve. Atribua o resultado, ou use-o na expressão ou saída: Sorted ← BubbleSort(MyArray, 7).
• Passar um tamanho um: 6 para um array de sete elementos, ou o último índice onde o tamanho era desejado. Decida se o parâmetro é um tamanho ou um índice, e verifique se o último elemento é visitado.
• Fechar um arquivo dentro do laço que o lê. Abra uma vez, feche uma vez, depois do laço.
• Usar a entrada como um nome de arquivo diretamente. Adicione a extensão dada na questão: FileName ← Choice & ".txt".
• Deixar construtos abertos. Todo IF precisa de seu ENDIF, todo FOR seu NEXT, todo WHILE seu ENDWHILE, e toda função seu RETURN; o esquema tem um ponto para isso.
• Limites errados: > para "pelo menos" (que é >=), ou um FOR que começa em 0 para um array declarado [1:50].
• Um contador ou total que nunca é definido como 0 antes do laço.
• Em uma tabela de traçado, reescrever toda variável em cada linha, ou alterar um valor antes da declaração que o altera ter sido executada.
• Metade de uma condição: IF x = 3 OR 4 — cada lado de OR e AND deve ser uma comparação completa. E + não junta strings; & faz isso.
• Declarar como local um valor que deve sobreviver entre chamadas. Um total acumulado ou uma string construída ao longo de várias chamadas é global ou BYREF.