Cambridge Pseudocode Handout · ⁨Anotação Cambridge Pseudocode⁩

Pseudocódigo 伪代码 é a linguagem com a qual a Cambridge escreve algoritmos 算法. Não é uma linguagem real linguagem de programação — nenhum computador a executa — mas o exame a marca como se fosse, assim que a forma importa.

Cada palavra-chave 关键字 é escrita em maiúsculas: IF, REPEAT, PROCEDURE, OUTPUT.

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

• Escreva IF, nunca if ou If.
• Uma palavra-chore nunca pode ser usada como um nome próprio: não pode chamar uma variável FOR.

Erros comuns

• Palavras-chave em minúsculas. O critério de correção espera maiúsculas.
• Inventar palavras-chave. Apenas as palavras desta folha estão no programa.

Um identificador 标识符 é o nome que dá a uma variável 变量, uma constante 常量, um procedimento 过程 ou função 函数.

DECLARE NumberOfPlayers : INTEGER
NumberOfPlayers ← 4
OUTPUT NumberOfPlayers

Quatro regras, todas do programa:

• Deve começar com letra maiúscula: Count, não count.
• Pode conter apenas letras e dígitos — sem espaços, sem pontuação.
• É insensível a maiúsculas/minúsculas 不区分大小写, logo Count e COUNT são o mesmo nome. Escolha uma grafia e mantenha-a.
• Dê-lhe significado. NumberOfPlayers ganha o tempo do leitor; N não.

Erros comuns

• count ← 0 — início em minúscula. O 0478 exige a maiúscula.
• Number of players — espaços não são permitidos dentro de um nome.

Um comentário 注释 começa com // e vai até ao fim da linha. Destina-se ao humano leitor; o algoritmo ignora-o.

// 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

Indentação 缩进 mostra quais instruções estão dentro de uma estrutura. O programa pede quatro espaços por nível, com uma exceção que deve saber:

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 e ELSE têm indentação de dois espaços em relação aos seus IF.
• As instruções abaixo deles têm indentação de quatro.
• Linhas de ENDIF alinham-se com os seus próprios IF.

Erros comuns

• Colocar THEN na linha de IF. Esse é o layout A-Level 9618 — veja o tópico 11.
• Sem indentação alguma. Um corretor precisa de ver a estrutura para atribuir os pontos da estrutura.

O pseudocódigo 0478 tem exatamente cinco tipos de dados 数据类型. Aprenda a lista — dar um nome a um tipo que não esteja nela perde pontos.

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

• Um STRING escreve-se entre aspas duplas, um CHAR entre aspas simples.
• TRUE e FALSE são palavras-chave, logo estão em maiúsculas e não levam aspas.

Erros comuns

• Escrever FLOAT, DOUBLE ou BOOL. Those são linguagens reais, não este programa.
• 'Hello' para uma string — aspas simples seguram apenas um caractere.

DECLARE nomeia uma variável 变量 e fixa o seu tipo antes de a usar.

DECLARE <identifier> : <data type>

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

Vários nomes de um mesmo tipo ficam numa única linha, separados por vírgulas:

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

• Declare uma variável antes do seu primeiro uso, perto do topo do algoritmo.
• Uma variável mantém o seu tipo durante todo o algoritmo — um INTEGER nunca segura um "Mei".

Erros comuns

• Deixar de fora os dois-pontos: DECLARE Counter INTEGER.
• Usar uma variável que nunca foi declarada. O exame espera a declaração.

Uma constante 常量 é um valor fixo para todo o algoritmo — uma taxa de imposto, π, o tamanho de uma turma. Nomeá-la uma vez significa fazer uma alteração num só lugar.

CONSTANT <identifier> ← <value>

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

• Em 0478 usa-se a seta, exatamente como para uma atribuição.
• O valor deve ser um literal 字面量 — um número, uma string, TRUE — nunca um cálculo e nunca outra variável.
• Uma constante nunca pode receber um novo valor mais tarde. Esse é o seu ponto central.

Erros comuns

• CONSTANT TaxRate = 0.20. A forma = é a grafia A-Level 9618 — veja o tópico 11.
• Atribuir a uma constante mais à frente no algoritmo.

O operador de atribuição 赋值 é ←, uma seta apontando para a esquerda. Significa pegue no valor na direita e coloque-o na caixa da esquerda.

<identifier> ← <value>

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

Counter ← Counter + 1 parece impossível como matemática e é comum como instrução: calcule o lado direito com o valor que a caixa tem agora, depois armazene o resultado de volta.

• Se não conseguir digitar ←, escreva <-. Ambas são aceites, aqui e no exame.
• O lado esquerdo deve ser um identificador único ou um elemento de array. Nunca um cálculo.

Erros comuns

• Counter = 0. No pseudocódigo = é uma comparação, não uma atribuição — e confundir os dois é o erro de sintaxe mais comum nesta prova.
• Counter + 1 ← Counter. A seta aponta para a coisa que está a ser alterada.

INPUT lê um valor do utilizador para uma variável. OUTPUT exibe um ou mais valores.

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

• INPUT recebe exatamente uma variável, e essa variável já deve estar declarada.
• OUTPUT recebe qualquer número de itens separados por vírgulas; são impressos um após outro sem nada entre eles.
• Uma string literal 字面量 num OUTPUT coloca-se entre aspas duplas; uma variável não.

Pedindo informação ao utilizador

Um INPUT sozinho não mostra nada no ecrã, logo um bem escrito algoritmo imprime um prompt 提示 primeiro:

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

Erros comuns

• INPUT "Enter a number", X — o prompt é uma instrução OUTPUT separada.
• OUTPUT "Total: " + Total. O 0478 junta itens de saída com vírgula; + é aritmética e & pertence ao A-Level 9618 (tópico 11).
• Esquecer as aspas: OUTPUT Hello procura uma variável chamada Hello.

Cinco operadores aritméticos 算术, pela ordem que uma calculadora os usa.

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

Parênteses vêm primeiro, depois ^, depois * e /, depois + e - — a precedência habitual 优先级. Use parênteses sempre que o leitor tivesse de parar e pensar.

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

Erros comuns

• Esperando que / retorne um número inteiro. 7 / 2 é 3.5, não 3; para um número inteiro use DIV.
• Escrever A x B ou A ÷ B. Use * e /.

A divisão inteira 整数除法 responde a duas perguntas diferentes, e o 0478 escreve cada uma delas como um procedimento 函数, com os dois valores entre parênteses.

• DIV(a, b) — quantas vezes inteiras b cabe em a, o quociente 商.
• MOD(a, b) — o que sobra, o resto 余数.

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

Ambos aceitam inteiros e ambos devolvem um inteiro.

Para que servem

MOD é o teste padrão para divide exatamente, o que o torna a forma de perguntar se um número é par 偶数:

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

DIV converte um total em unidades inteiras — segundos em minutos, pence em libras:

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

Erros comuns

• 10 MOD 3. Essa é a forma A-Level 9618; o 0478 usa a forma de procedimento MOD(10, 3).
• Misturar os dois. DIV devolve a parte inteira; MOD devolve o que não cabe.

Um operador relacional 关系运算符 compara dois valores e produz TRUE ou FALSE.

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

Os três operadores lógicos 逻辑运算符 unem condições:

• AND — ambos os lados devem ser booleanos TRUE.
• OR — pelo menos um lado deve ser TRUE.
• NOT — inverte TRUE para FALSE e 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

Erros comuns

• <> é o sinal de não igual aqui — não !=, que pertence a outras linguagens.
• IF Age >= 15 AND <= 18. Cada lado de AND precisa da sua própria comparação completa: Age >= 15 AND Age <= 18.
• Chamar estes operadores de comparação numa resposta. O termo do programa é relacional.

O 0478 publica quatro rotinas de string 字符串 e nenhuma outra. Três delas estão aqui.

LENGTH(<identifier>) devolve quantos caracteres 字符 uma string contém — incluindo espaços.

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

UCASE(<identifier>) devolve a string em maiúsculas 大写, LCASE(<identifier>) em minúsculas case 小写. Nenhuma altera o original 原值 — cada uma devolve um novo valor.

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

Essa última linha ainda imprime Happy: para manter a alteração deve atribuí-la de volta.

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

Comparar sem se preocupar com maiúsculas/minúsculas

UCASE em ambos os lados é a forma padrão de aceitar uma resposta independentemente de como foi digitada:

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

Erros comuns

• Esperar que UCASE(Name) altere Name. Atribua o resultado de volta.
• LENGTH conta caracteres, não palavras. LENGTH("Happy Days") é 10.

SUBSTRING(<identifier>, <start>, <length>) extrai um pedaço de uma string — começando na posição start, tirando length caracteres.

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

⚠️ A contagem começa em 1, não em 0. O primeiro caractere de "Happy Days" está na posição 1.

Tirar um caractere, e o resto

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 dentro de SUBSTRING é o que faz as últimas duas linhas funcionarem para uma palavra de qualquer tamanho — fixar 8 quebraria no momento em que a palavra mudasse.

Ler uma string um caractere de cada vez

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

Erros comuns

• Começando em 0. A posição 1 é o primeiro caractere.
• Lendo o terceiro argumento como uma posição final. É um contagem — SUBSTRING(W, 2, 3) pega três caracteres começando no segundo.
• Pedindo mais caracteres do que a string possui.

Seleção 选择 executa um grupo de instruções ou outro, dependendo de uma condição 条件.

IF <condition>
  THEN
    <statements>
ENDIF

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

Adicione ELSE para o outro caso. Exatamente um dos dois ramos 分支 roda — nunca ambos, nunca nenhum.

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

O layout é a única parte em que os alunos perdem pontos, então aprenda-o como uma forma:

• IF e sua condição em uma linha, nada após a condição.
• THEN e ELSE em linhas próprias, recuados dois espaços.
• As instruções recuadas quatro.
• ENDIF volta para a coluna do seu IF.

Aninhamento 嵌套

Um IF dentro de um IF lida com mais de dois resultados. Cada um precisa do seu próprio ENDIF.

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

Erros comuns

• Esquecer ENDIF. Todo IF fecha, e um faltante é um erro de sintaxe 语法错误 que o marcador verá de relance.
• IF Mark >= 50 THEN OUTPUT "Pass" em uma linha. Não existe tal forma em nenhum programa; escreva as três linhas.
• IF Mark = 50 THEN escrito como IF Mark ← 50. A seta atribui; = compara.

Quando uma variável é testada contra vários valores únicos, CASE OF diz isso muito mais claramente do que uma pilha de IFs aninhados.

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

• Cada ramo é um valor, dois-pontos, depois o que fazer.
• OTHERWISE captura tudo que os valores listados deixaram passar. É opcional, e escrever um é boa prática — é o que acontece quando o usuário digita algo inesperado.
• O primeiro ramo correspondente roda, e os demais são pulados.

Um intervalo, e um caractere

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

Erros comuns

• Usar CASE OF para uma condição. Ele testa uma variável contra valores; Mark >= 50 precisa de um IF.
• Esquecer ENDCASE.
• Deixar fora OTHERWISE e depois se perguntar por que um valor inesperado não faz nada.

Iteração 迭代 repete instruções. Use um loop FOR quando você souber antes de começar quantas vezes — um loop de controle de contagem 计数控制.

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

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

O contador 计数器 começa no primeiro valor, e o loop roda uma vez para cada valor até e incluindo o segundo. 1 TO 5 roda cinco vezes.

PASSO

STEP muda o tamanho de cada salto. Um passo negativo conta para baixo.

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

Totais acumulativos

O uso mais comum: uma variável fora do loop que o loop soma.

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 deve ficar antes do loop. Dentro dele, seria redefinido em cada passagem.

Erros comuns

• NEXT nomeando o contador errado. Loops aninhados devem fechar na ordem inversa em que abriram: o NEXT interno primeiro.
• Assumir que 1 TO 5 roda quatro vezes. Ambos os extremos são incluídos.
• Alterar o contador dentro do loop. Deixe FOR ser dono dele.

Um loop WHILE testa antes de cada passagem, então pode rodar zero vezes. Use-o quando o número de repetições depender de algo que acontece enquanto o loop roda.

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

Algo dentro do loop deve eventualmente tornar a condição falsa, ou o loop nunca termina — um loop infinito 无限循环.

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

Erros comuns

• Esquecer de alterar a variável que a condição testa, resultando em loop infinito.
• Esquecendo DO ou ENDWHILE.
• Usar WHILE quando a contagem é conhecida. Um FOR diz o que você quer em uma linha.

Um loop REPEAT testa depois de cada passagem, então sempre roda pelo menos uma vez.

REPEAT
    <statements>
UNTIL <condition>

Esse "pelo menos uma vez" é a razão para escolhê-lo: validando entrada, onde você precisa pedir antes de poder julgar a resposta.

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

⚠️ UNTIL declara a condição que para o loop; WHILE declara a que o mantém em execução. Eles são opostos, e trocá-los é o erro clássico.

Erros comuns

• Escrever UNTIL Number < 100 quando quer dizer UNTIL Number >= 100.
• Usar REPEAT onde o corpo pode precisar rodar zero vezes.
• Esquecer que UNTIL encerra a estrutura — não há ENDREPEAT.

Um array 数组 armazena muitos valores de um único tipo sob um nome. Cada valor fica em um índice 下标.

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]

• Os limites 边界 são escritos lower:upper, e ambos são incluídos — [1:3] tem três elementos 元素.
• Arrays do Cambridge geralmente começam em 1, não 0.
• Todo elemento tem o mesmo tipo, fixado por OF.

Preenchendo e lendo com um loop PARA

Um array e um loop contado pertencem juntos: o contador é o índice.

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

Encontrando o maior

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

Comece Largest no primeiro elemento, nunca em 0 — com dados negativos, 0 venceria e a resposta estaria errada.

Erros comuns

• Lendo Scores[6] de um array declarado [1:5]. Isso está fora dos limites 越界.
• Escrevendo Scores(3). Arrays usam colchetes quadrados; parênteses redondos chamam uma função.
• Declarar [1:5] e depois looping 0 TO 4.

Um array 2-D 二维数组 é uma tabela: linhas e colunas, dois índices.

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]

O primeiro índice é a linha 行, o segundo é a coluna 列.

Loops aninhados percorrem uma tabela

Um loop por dimensão 维度. O loop interno termina uma linha inteira antes do externo prosseguir.

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

⚠️ O NEXT interno fecha o contador interno. NEXT Row antes de NEXT Col cruza os loops e é sem sentido — um marcador nota isso instantaneamente.

Erros comuns

• Trocar linha e coluna. Grid[2,3] é linha 2, coluna 3.
• Grid[Row][Col]. O Cambridge escreve um par de colchetes com uma vírgula dentro.
• Cruzar as linhas do NEXT, como acima.

Um procedimento 过程 é um bloco nomeado de instruções. Escrevê-lo uma vez e chamá-lo de vários lugares é decomposição 分解 — a ideia sobre a qual todo o papel 2 se baseia.

PROCEDURE <identifier>
    <statements>
ENDPROCEDURE

Um procedimento é chamado por nome, com a palavra-chave CALL:

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

CALL DefaultLine
OUTPUT "Report"
CALL DefaultLine

• A definição 定义 não faz nada sozinha. Apenas CALL o executa.
• O controle retorna à linha após a CALL quando o procedimento termina.
• Um procedimento não devolve um valor. Se você precisa de um, quer uma função.

Erros comuns

• Escrever DefaultLine sozinho para executá-lo. 0478 requer CALL.
• Deixar fora ENDPROCEDURE.
• Esperar que as variáveis próprias do procedimento existam fora dele.

Uma função 函数 é um procedimento que devolve um valor. Ela é escrita onde esse valor é necessário — dentro de um OUTPUT, à direita de uma atribuição, dentro de uma condição.

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> no cabeçalho diz que tipo vem de volta. Não é opcional.
• RETURN encerra a função imediatamente — nada depois dela roda.
• Uma função nunca é chamada com CALL; ela é usada onde seu valor pertence.

Uma função dentro de uma condição

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

Erros comuns

• CALL SumSquare(10, 20) — que joga a resposta fora.
• Uma função sem return RETURN em algum caminho. Todas as rotas de saída devem retornar um valor.
• Deixar RETURNS INTEGER fora do cabeçalho.

Um parâmetro 参数 é um valor dado a um procedimento ou função quando ele é chamado. Cada um carrega seu próprio tipo.

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

CALL Line(5)
CALL Line(20)

Vários parâmetros são separados por vírgulas, e a ordem na chamada deve corresponder à ordem na definição:

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)

⚠️ Em 0478 todos os parâmetros são passados por valor 传值: o procedimento trabalha em uma cópia, então alterá-lo dentro não altera nada fora. Para obter um valor de volta, use uma FUNCTION e RETURN ele. (A-Level 9618 adiciona BYREF para o outro comportamento — tópico 11.)

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

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

Erros comuns

• PROCEDURE Line(Size) sem tipo.
• Chamar com os argumentos na ordem errada — Greet(2, "Mei") é um erro de tipo.
• Esperar que um procedimento altere a variável que você passou. No 0478 ele não pode.

Um arquivo 文件 mantém dados após o programa terminar. 0478 usa quatro comandos, e cada um nomeia o arquivo em que atua.

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"

Três modos de arquivo 文件模式:

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"

• Um WRITEFILE escreve uma linha.
• O close CLOSEFILE não é opcional. Um arquivo fechado incorretamente pode perder os dados ainda aguardando serem serem escritos, e isso é uma resposta clássica de prova.

Erros comuns

• FOR WRITE quando queria FOR APPEND, o que destrói silenciosamente o conteúdo antigo.
• Esquecer CLOSEFILE.
• Abrir um arquivo que já está aberto.

READFILE pega uma linha em uma variável. A variável deve ser declarada antes.

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

Normalmente você não sabe quantas linhas existem, então lê-se até o fim do arquivo — que é o que a função EOF reporta.

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") é TRUE após cada linha ser lida, então WHILE NOT EOF(...) significa enquanto houver algo a ler.

Contando enquanto lê

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

Erros comuns

• Um loop WHILE EOF(...) — que roda apenas quando não há mais nada. Você quer NOT.
• Ler além do final porque o loop não tem guarda EOF.
• Abrir FOR READ um arquivo que nunca foi escrito.

A Cambridge publica duas especificações de pseudocódigo, e elas discordam. Tudo em tópicos 1-10 é IGCSE 0478. A-Level 9618 altera os detalhes abaixo — e um aluno que estuda ambos perde pontos ao escrever um no papel do outro.

Esta é a forma 0478, e ela roda aqui:

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

A forma 9618 do mesmo algoritmo é escrita assim — note THEN na IF linha, = no CONSTANT, e MOD entre seus dois valores:

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

⚠️ Qual está certo depende apenas de qual prova você está fazendo. Nenhuma é um erro; cada uma é um erro no outro exame. O playground nesta página usa as regras 0478, portanto uma construção 9618 é rejeitada com uma mensagem citando o programa ao qual pertence — que é uma maneira rápida de verificar seus próprios hábitos.

Erros comuns

• Escrever THEN na IF linha em uma resposta 0478, porque isso é o que um livro didático ou um site mostrou. É o erro cruzado de programa mais comum.
• 10 MOD 3 em 0478. Lá ele é MOD(10, 3).
• ROUND(3.14159, 2) em uma resposta 9618. 9618 não tem ROUND nenhum.

0478 passa todos os parâmetros por valor 传值 (tópico 9). 9618 permite escolher, e diz isso no cabeçalho.

• BYVAL — o procedimento recebe uma cópia. Alterá-lo não muda nada fora. Este é o padrão quando nenhuma das palavras é escrita.
• BYREF — o procedimento opera sobre a própria variável 引用 do chamador, então uma mudança é visível após a chamada.

Isto é só 9618. Não roda aqui, e não é aceito em uma resposta 0478:

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

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

A forma 0478 de retornar um valor

Use um FUNCTION e atribua o que ele retorna. Esta é toda a resposta 0478, e ela roda:

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

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

Erros comuns

• Escrever BYREF em uma resposta 0478. A palavra-chave não está naquele programa.
• Esperar que um parâmetro simples 9618 se comporte como BYREF. Sem a palavra, ele é BYVAL.

9618 possui estruturas de dados 数据结构 que 0478 não tem. Você as encontrará apenas no A-Level, e nenhuma delas roda sob as regras 0478 desta página.

Um registro 记录 agrupa campos de diferentes tipos sob um único nome (9618 seção 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

Um tipo enumerado 枚举类型 lista os únicos valores que uma variável pode assumir:

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

9618 também adiciona um tipo de dado DATE, arquivos de acesso aleatório (OPENFILE … FOR RANDOM), ponteiros, e classes com CLASS … ENDCLASS para sua prova orientada a objetos.

⚠️ 0478 tem cinco tipos de dados e arrays, e nada mais (tópico 2). Uma resposta 0478 que declara um registro está respondendo a um programa diferente.

Erros comuns

• Usar um registro em uma resposta 0478. Use arrays paralelos em vez disso — um array por campo, compartilhando um índice.
• Pensar que TYPE significa o mesmo que DECLARE. TYPE define um novo tipo; DECLARE cria uma variável de um existente.