Pular para o conteúdo
Matérias
  • 1 Estilo e layout
    1.1

    Palavras-chave e case

    Pseudocódigo é a linguagem que Cambridge usa para escrever algoritmos. Descreve algoritmos sem exigir uma linguagem de programação de propósito geral. Este site interpreta um subconjunto definido no estilo Cambridge para que você possa executar exemplos; uma resposta de exame deve seguir a notação especificada para aquela prova.

    Toda palavra-chave está escrita em CAIXA ALTA: 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.
    1.2

    Identificadores

    Um identificador é o nome dado a uma variável, uma constante, um procedimento ou uma 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.
    • Ele não é sensível a maiúsculas e minúsculas, então 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.
    1.3

    Comentários e indentação

    Um comentário começa com // e se estende até o final da linha. É destinado ao ser 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
    

    A indentação mostra quais instruções estão dentro de uma estrutura. O programa escolar exige 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.
    Um bloco SE-ENTÃO-SENÃO com barras de recuo sombreadas: SE e FIMSE na margem, ENTÃO e SENÃO dois espaços à direita, cada SAÍDA quatro espaços à direita
    Contando os espaços: 0, 2, 4

    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.
  • 2 Variáveis, constantes e tipos
    2.1

    Os cinco tipos de dados

    O pseudocódigo 0478 tem exatamente cinco tipos de dados. Aprenda a lista — nomear um tipo que não esteja nela perde pontos.

    Type Holds Example
    INTEGER um número inteiro 42, -7
    REAL um número que pode ter parte fracionária 3.14, -0.5
    CHAR um único caractere 'A'
    STRING uma sequência de caracteres "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
    
    • 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.
    Os cinco tipos de dados: INTEGER, REAL, CHAR, STRING e BOOLEAN
    Os cinco tipos de dados: INTEGER, REAL, CHAR, STRING e BOOLEAN
    2.2

    DECLARE

    O DECLARE nomeia uma variável e fixa seu tipo antes de usá-la.

    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 RoomLength, Width, Area : INTEGER
    RoomLength ← 6
    Width ← 4
    Area ← RoomLength * 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.
    DECLARE nomeia uma variável e fixa o tipo de valor que ela pode armazenar
    DECLARE nomeia uma variável e fixa o tipo de valor que ela pode armazenar
    2.3

    CONSTANT

    Uma constante é um valor fixo durante 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.
  • 3 Atribuição, entrada e saída
    3.1

    A seta de atribuição

    O operador de atribuição é ←, uma seta apontando para a esquerda. Significa pegar o 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.

    Três linhas de atribuição ao lado da caixa do Contador: 0 é armazenado, depois 0 + 1 é calculado e 1 armazenado, depois 1 + 1 é calculado e 2 armazenado
    Lado direito primeiro, depois armazene na caixa
    • 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.
    3.2

    INPUT e OUTPUT

    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 em um OUTPUT vai 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 primeiramente:

    DECLARE Radius : REAL
    OUTPUT "Enter the radius: "
    INPUT Radius
    OUTPUT "The diameter is ", Radius * 2
    
    Três instruções executadas de cima para baixo, OUTPUT exibe um prompt, INPUT Name, OUTPUT exibe uma saudação, ao lado da tela produzida
    O prompt aparece primeiro, depois a resposta digitada, depois a resposta

    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.
  • 4 Aritmética e lógica
    4.1

    Operadores aritméticos

    Cinco operadores aritméticos; sua precedência está listada abaixo da tabela.

    Operador Significado Se A for 7, B for 2
    + somar A + B é 9
    - subtrair A - B é 5
    * multiplicar A * B é 14
    / dividir A / B é 3.5
    ^ elevar a uma potência A ^ B é 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
    

    Parênteses vêm primeiro, depois ^, depois * e /, depois + e - — a precedência habitual . Use parênteses sempre que o leitor precisaria 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 /.
    4.2

    DIV e MOD

    A divisão inteira responde duas perguntas diferentes, e 0478 escreve cada uma delas como uma função, com os dois valores entre colchetes.

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

    17 dividido em grupos de 5: DIV dá 3 grupos inteiros, MOD o 2 restante
    17 dividido em grupos de 5: DIV dá 3 grupos inteiros, MOD o 2 restante

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

    Operadores relacionais e lógicos

    Um operador relacional compara dois valores e produz TRUE ou FALSE.

    Operador Significado
    = é igual a
    <> não é igual a
    > é maior que
    < é menor que
    >= é maior ou igual a
    <= é menor ou igual a
    DECLARE Mark : INTEGER
    Mark ← 55
    OUTPUT "Pass: ", Mark >= 50
    OUTPUT "Perfect: ", Mark = 100
    OUTPUT "Not zero: ", Mark <> 0
    

    Os três operadores lógicos combinam 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.
    AND exige ambos os testes VERDADEIROS: idade 14 passa ambos, idade 10 falha no primeiro
    AND exige ambos os testes VERDADEIROS: idade 14 passa ambos, idade 10 falha no primeiro
  • 5 Operações com strings
    5.1

    LENGTH, UCASE e LCASE

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

    LENGTH(<identifier>) retorna quantos caracteres uma string contém — espaços incluídos.

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

    UCASE(<identifier>) retorna a string em maiúsculas, LCASE(<identifier>) em minúsculas Nenhuma altera a original — cada 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.
    5.2

    SUBSTRING

    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.

    Contagem de caracteres de 1: SUBSTRING("Computador", 1, 4) retorna "Compu"
    Caracteres contam a partir de 1: SUBSTRING("Computer", 1, 4) resulta "Comp"

    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.
  • 6 Seleção
    6.1

    SE, ENTAO, SENAO, FIMSE

    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 ramos é executado — 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.
    IF escolhe um dos dois caminhos; ambos se unem em ENDIF
    IF escolhe um dos dois caminhos; ambos se unem em ENDIF

    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

    • Esquecimento ENDIF. Todo IF é fechado, e um que falta é erro de sintaxe 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.
    6.2

    CASO DE

    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.
    CASE compara o valor com cada opção sequencialmente; Grade = 2 corresponde à segunda
    CASE compara o valor com cada opção sequencialmente; Grade = 2 corresponde à segunda

    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.
  • 7 Iteração
    7.1

    PARA, o loop contado

    Iteração repete instruções. Use um laço FOR quando souber antes de começar quantas vezes — um laço controlado por contagem.

    FOR <identifier> ← <value1> TO <value2>
        <statements>
    NEXT <identifier>
    
    DECLARE Index : INTEGER
    FOR Index ← 1 TO 5
        OUTPUT "Line ", Index
    NEXT Index
    

    O contador inicia no primeiro valor, e o laço executa uma vez para cada valor até e incluindo o segundo. 1 TO 5 roda cinco vezes.

    FOR Contador ← 1 ATÉ 4 executa quatro iterações, e ambos 1 e 4 são incluídos
    FOR Contador ← 1 ATÉ 4 executa quatro iterações, e ambos 1 e 4 são incluídos

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

    ENQUANTO, o loop de pré-condição

    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 laço 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.
    7.3

    REPETIR, o loop de pós-condição

    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ê deve solicitar 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.

    Testa Roda pelo menos uma vez? Significado da condição
    FOR um contador não (um intervalo vazio roda zero vezes) —
    WHILE antes não continue enquanto isso for verdadeiro
    REPEAT depois sim pare quando isso se tornar verdadeiro

    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.
    WHILE testa primeiro e pode executar zero vezes; REPEAT testa por último e executa pelo menos uma vez
    WHILE testa primeiro e pode executar zero vezes; REPEAT testa por último e executa pelo menos uma vez
  • 8 Matrizes
    8.1

    Arrays unidimensionais

    Uma matriz armazena muitos valores de um único tipo sob um mesmo nome. Cada valor está em uma í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.
    Uma matriz 1-D: um nome, muitos valores, cada um encontrado pelo seu índice
    Uma matriz 1-D: um nome, muitos valores, cada um encontrado pelo seu índice

    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 uma matriz declarada como [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.
    8.2

    Arrays bidimensionais

    A 2-D array is a table: rows and columns, two indexes.

    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.

    Uma matriz 2-D é uma grade: G[1, 2] representa a linha 1, coluna 2
    Uma matriz 2-D é uma grade: G[1, 2] representa a linha 1, coluna 2

    Loops aninhados percorrem uma tabela

    Um laço por dimensão. O laço interno termina toda uma linha antes que o externo prossiga.

    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.
  • 9 Procedimentos e funções
    9.1

    PROCEDIMENTO e CHAMADA

    Um procedimento é um bloco nomeado de instruções. Escrevê-lo uma vez e chamá-lo de vários lugares é decomposição — a ideia de que o todo do 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 a 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.
    9.2

    FUNÇÃO e RETORNO

    Uma função é uma rotina nomeada que retorna 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.
    Um procedimento é CHAMADO para fazer um trabalho; uma função retorna um valor para usar
    Um procedimento é CHAMADO para fazer um trabalho; uma função retorna um valor para usar

    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) — CALL invoca um procedimento, não uma função. Use a função em uma expressão, como Answer ← SumSquare(10, 20).
    • 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.
    9.3

    Parâmetros

    Um parâmetro é um valor dado a um procedimento ou função quando 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 usa 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.
  • 10 Manipulação de arquivos
    10.1

    Escrevendo em um arquivo

    Um arquivo armazena dados após o término do programa. 0478 utiliza 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:

    Modo O que faz
    WRITE iniciar um novo arquivo — qualquer coisa já lá está perdida
    APPEND adiciona ao final do conteúdo existente
    READ ler do início
    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.
    10.2

    Lendo um arquivo até o fim

    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.

    Abrir um arquivo para ESCREVER ou LER, usá-lo linha por linha e depois fechá-lo
    Abrir um arquivo para ESCREVER ou LER, usá-lo linha por linha e depois fechá-lo

    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.
  • 11 A-Level 9618: o que mudou
    11.1

    Layout e operadores

    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.

    IGCSE 0478 A-Level 9618
    THEN na sua própria linha, indentado 2 na IF linha
    constantes CONSTANT Pi ← 3.142 CONSTANT Pi = 3.142
    DIV / MOD funções: DIV(10, 3) operadores: 10 DIV 3
    unir strings vírgulas em OUTPUT o operador &
    identificadores devem começar com maiúscula caso misto permitido
    NEXT deve nomear seu contador boa prática
    ROUND, RANDOM() ambos publicados nenhum existe

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

    Parâmetros: BYVAL e BYREF

    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 atua na variável própria do chamador por referência, então uma alteração é 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
    
    BYVAL passa uma cópia; BYREF permite ao procedimento alterar a variável do chamador
    BYVAL passa uma cópia; BYREF permite ao procedimento alterar a variável do chamador

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

    Registros e outros tipos

    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 tipos diferentes sob um único nome (seção 4 de 9618):

    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.
    Um registro agrupa campos de tipos diferentes; a notação por ponto acessa cada um
    Um registro agrupa campos de tipos diferentes; a notação por ponto acessa cada um

Entrar ou criar conta

IGCSE, A-Level & AP