Cambridge Pseudocode Handout · ⁨Раздаточный материал псевдокода Cambridge⁩

Псевдокод — это язык, которым Cambridge пишет алгоритмы. Это не настоящий язык программирования — его не выполняет компьютер — но экзамен оценивает его так, будто он есть, поэтому форма имеет значение.

Каждое ключевое слово пишется заглавными буквами: IF, REPEAT, PROCEDURE, OUTPUT.

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

• Пишите IF, никогда не if и не If.
• Ключевое слово никогда нельзя использовать как имя: вы не можете назвать переменную FOR.

Распространенные ошибки

• Строчные ключевые слова. Схема оценивания ожидает заглавные буквы.
• Выдуманные ключевые слова. Только слова в этом раздаточном материале входят в программу.

Идентификатор — это имя, которое вы присваиваете переменной, константе, процедуре или функции.

DECLARE NumberOfPlayers : INTEGER
NumberOfPlayers ← 4
OUTPUT NumberOfPlayers

Четыре правила, все из программы:

• Оно должно начинаться с заглавной буквы: Count, а не count.
• Оно может содержать только буквы и цифры — без пробелов и знаков препинания.
• Оно не различает регистр, поэтому Count и COUNT — одно и то же имя. Выберите одну орфографию и придерживайтесь её.
• Придайте ему смысл. NumberOfPlayers заслуживает время читателя; N нет.

Распространенные ошибки

• count ← 0 — начало со строчной буквы. Для 0478 требуется заглавная буква.
• Number of players — пробелы внутри имени запрещены.

Комментарий начинается со // и идет до конца строки. Он предназначен для человеческого читателя; алгоритм его игнорирует.

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

Отступы показывают, какие операторы находятся внутри структуры. Программа требует четыре пробела на уровень, за исключением одного исключения, которое нужно знать:

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 и ELSE имеют отступ два пробела от своего IF.
• Операторы под ними имеют отступ четыре.
• Строки ENDIF выровнены со своим собственным IF.

Распространенные ошибки

• Размещение THEN на строке IF. Это макет A-Level 9618 — см. тему 11.
• Никаких отступов вообще. Эксперт должен видеть структуру, чтобы начислить баллы за нее.

В псевдокоде 0478 ровно пять типов данных. Выучите список — указание типа которого нет в нем, лишает балла.

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

• STRING пишется в двойных кавычках, а CHAR — в одинарных.
• TRUE и FALSE — ключевые слова, поэтому они пишутся заглавными буквами и не берутся в кавычки.

Распространенные ошибки

• Написание FLOAT, DOUBLE или BOOL. Это реальные языки, а не эта программа.
• 'Hello' для строки — одинарные кавычки удерживают только один символ.

DECLARE называет переменную и фиксирует её тип до использования.

DECLARE <identifier> : <data type>

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

Несколько имен одного типа помещаются на одной строке, разделенные запятыми:

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

• Объявите переменную до первого использования, в начале алгоритма.
• Переменная сохраняет свой тип на весь алгоритм — INTEGER никогда не хранит "Mei".

Распространенные ошибки

• Пропуск двоеточия: DECLARE Counter INTEGER.
• Использование переменной, которая никогда не была объявлена. На экзамене ожидается объявление.

Константа — это значение, которое неизменно на весь алгоритм — ставка налога, π, размер класса. Назначение имени означает, что изменение вносится в одном месте.

CONSTANT <identifier> ← <value>

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

• В 0478 используется стрелка, точно так же, как при присваивании.
• Значение должно быть литералом — числом, строкой, TRUE — никогда вычислением и никогда другой переменной.
• Константе никогда нельзя присвоить новое значение позже. В этом и состоит её суть.

Распространенные ошибки

• CONSTANT TaxRate = 0.20. Форма = — это написание A-Level 9618 — см. тему 11.
• Присваивание константе далее по алгоритму.

Оператор присваивания — это ←, стрелка влево. Она означает взять значение справа и поместить его в ячейку слева.

<identifier> ← <value>

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

Counter ← Counter + 1 выглядит невозможным как математика и является обычной инструкцией: вычислите правую часть со значением, которое сейчас содержит ячейка, затем сохраните результат обратно.

• Если вы не можете напечатать ←, напишите <-. Оба варианта принимаются здесь и на экзамене.
• Левая сторона должна быть одним идентификатором или одним элементом массива. Никогда вычисление.

Распространенные ошибки

• Counter = 0. В псевдокоде = — это сравнение, а не присваивание — и путаница между ними — единичная наиболее частая синтаксическая ошибка в этом экзамене.
• Counter + 1 ← Counter. Стрелка указывает на объект изменения.

INPUT считывает значение от пользователя в переменную. OUTPUT отображает одно или несколько значений.

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

• INPUT принимает ровно одну переменную, и эта переменная уже должна быть объявлена.
• OUTPUT принимает любое количество элементов, разделенных запятыми; они выводятся друг за другом, другим без ничего между ними.
• Буквальная строка в OUTPUT берётся в двойные кавычки; переменная — нет.

Запрос ввода от пользователя

Сама по себе команда INPUT не выводит ничего на экран, поэтому хорошо написанный алгоритм сначала печатает приглашение: сначала:

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

Распространенные ошибки

• INPUT "Enter a number", X — приглашение является отдельным оператором вывода ⟨OUTPUT⟩.
• OUTPUT "Total: " + Total. Команда 0478 соединяет элементы вывода через запятую; ⟨+⟩ — это арифметика и, ⟨&⟩ относится к программе A-Level 9618 (тема 11).
• Забывание кавычек: OUTPUT Hello ищет переменную с именем Hello.

Пять арифметических операторов в порядке их выполнения калькулятором.

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

Скобки выполняются первыми, затем ^, затем * и /, затем + и - — стандартный приоритет . Используйте скобки всякий раз, когда читателю пришлось бы остановиться и подумать.

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

Распространенные ошибки

• Ожидается, что / вернет целое число. 7 / 2 это 3.5, а не 3; для получения целого числа используйте DIV.
• Написание A x B или A ÷ B. Используйте ⟨*⟩ и ⟨/⟩.

Целочисленное деление отвечает на два разных вопроса, и 0478 записывает каждый из них как функцию, принимая два значения в скобках.

• ⟨DIV(a, b)⟩ — сколько раз целиком b помещается в a, частное.
• ⟨MOD(a, b)⟩ — что осталось, остаток.

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

Оба принимают целые числа и оба возвращают целое число.

Для чего они нужны

MOD — стандартная проверка делится без остатка, что позволяет спросить, является ли число четным:

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

DIV преобразует общую величину в целые единицы — секунды в минуты, пенни в фунты:

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

Распространенные ошибки

• ⟨10 MOD 3⟩. Это форма A-Level 9618; 0478 использует форму функции ⟨MOD(10, 3)⟩.
• Перепутать их местами. ⟨DIV⟩ дает целую часть; ⟨MOD⟩ дает то, что не поместилось.

Реляционный оператор сравнивает два значения и производит TRUE или FALSE.

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

Три логических оператора объединяют условия:

• ⟨AND⟩ — обе стороны должны быть TRUE.
• ⟨OR⟩ — хотя бы одна сторона должна быть TRUE.
• ⟨NOT⟩ — превращает TRUE в FALSE и обратно.

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

Распространенные ошибки

• ⟨<>⟩ здесь обозначает не равно — не ⟨!=⟩, который принадлежит другим языкам.
• ⟨IF Age >= 15 AND <= 18⟩. Каждая сторона ⟨AND⟩ требует своего собственного полного сравнения: Age >= 15 AND Age <= 18.
• Называть эти операторы операторами сравнения в ответе. Термин учебной программы — реляционный.

0478 публикует четыре строковые подпрограммы и никаких других. Три из них здесь.

LENGTH(<identifier>) возвращает количество символов, содержащихся в строке — включая пробелы.

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

UCASE(<identifier>) возвращает строку в верхнем регистре, ⟨LCASE(<identifier>)⟩ в нижнем регистре. Ни один из них не изменяет оригинал — каждый возвращает новое значение.

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

Эта последняя строка все еще выводит ⟨Happy⟩: чтобы сохранить изменение, нужно присвоить результат обратно.

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

Сравнение без учета регистра

Применение ⟨UCASE⟩ к обеим сторонам — стандартный способ принять ответ, независимо от того, как он был набран:

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

Распространенные ошибки

• Ожидание, что ⟨UCASE(Name)⟩ изменит ⟨Name⟩. Присвойте результат обратно.
• LENGTH считает символы, а не слова. LENGTH("Happy Days") это 10.

SUBSTRING(<identifier>, <start>, <length>) извлекает кусок из строки — начиная с позиции start, беря length символов.

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

⚠️ Нумерация начинается с 1, а не с 0. Первый символ ⟨"Happy Days"⟩ находится на позиции 1.

Извлечение одного символа и всего остального

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 внутри ⟨SUBSTRING⟩ — это то, благодаря чему последние две строки работают для слова любого размера — жесткая привязка ⟨8⟩ сломалась бы в тот момент, когда слово изменится.

Чтение строки по одному символу

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

Распространенные ошибки

• Начиная с 0. Позиция 1 — это первый символ.
• Чтение третьего аргумента как конечной позиции. Это счет — ⟨SUBSTRING(W, 2, 3)⟩ берет три символа, начиная со второго.
• Запрос большего количества символов, чем есть в строке.

Выбор (Selection) выполняет одну группу инструкций или другую в зависимости от условия.

IF <condition>
  THEN
    <statements>
ENDIF

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

Добавьте ⟨ELSE⟩ для другого случая. Точно одна из двух ветвей выполняется — никогда ни обе, ни ни одна. Макет — это та часть, которая приводит к потере баллов студентами, поэтому выучите его как форму:

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

Макет — это та часть, из-за которой студенты теряют баллы, поэтому выучите его как форму:

• IF и его условие на одной строке, ничего после условия.
• THEN и ELSE на отдельных строках, отступ два пробела.
• Инструктуи, отступ четыре пробела.
• ENDIF возвращается в колонку своего IF.

Вложенность

Конструкция IF внутри конструкции IF обрабатывает более двух вариантов. Каждый из них требует собственного оператора ENDIF.

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

Распространенные ошибки

• Забывание оператора ENDIF. Каждая конструкция IF закрывается, и отсутствие закрывающего элемента является синтаксической ошибкой, маркер заметит мгновенно.
• IF Mark >= 50 THEN OUTPUT "Pass" на одной строке. Такой формы не существует ни в одном из учебников; напишите три строки.
• IF Mark = 50 THEN записывается как IF Mark ← 50. Стрелка присваивает; = сравнивает.

яснее, чем стопка вложенных ⟨CASE OF⟩. яснее, чем стопка вложенных IF.

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

• Каждая ветвь — это значение, двоеточие, затем действия.
• OTHERWISE перехватывает всё, что пропустили перечисленные значения. Она необязательна, и написание одной является хорошей практикой — это то, что происходит, когда пользователь вводит неожиданные данные.
• Выполняется первая подходящая ветвь, остальные пропускаются.

Диапазон и символ

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

Распространенные ошибки

• Использование CASE OF для условия. Оно проверяет одну переменную на соответствие значениям; Mark >= 50 требует IF.
• Забывание про ENDCASE.
• Пропуск OTHERWISE, а затем недоумение, почему неожиданный результат ничего не дает.

Итерация повторяет операторы. Используйте цикл FOR, когда знаете до начала сколько раз — это цикл с управлением счетом.

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

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

Счетчик начинается с первого значения, и цикл выполняется один раз для каждого значения до и включая второе. 1 TO 5 выполняется пять раз.

STEP

STEP изменяет размер каждого шага. Отрицательный шаг означает обратный отсчет.

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

Накопленная сумма

Наиболее распространенное применение: переменная вне цикла, к которой цикл прибавляет значения.

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 должна находиться перед циклом. Внутри она бы сбрасывалась на каждой итерации.

Распространенные ошибки

• NEXT с неверным названием счетчика. Вложенные циклы должны завершаться в обратном порядке по отношению к тому, открытием: сначала внутренний NEXT.
• Предположение, что 1 TO 5 выполнится четыре раза. Оба конца включены.
• Изменение счетчика внутри цикла. Доверьте его FOR.

Цикл WHILE проверяет условие перед каждой итерацией, поэтому может выполниться ноль раз. Используйте его, когда количество повторений зависит от того, что происходит во время выполнения цикла.

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

Что-то внутри цикла со временем должно сделать условие ложным, иначе цикл никогда не закончится — это бесконечный цикл.

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

Распространенные ошибки

• Забыть изменить переменную, которую проверяет условие, что приводит к бесконечному циклу.
• Пропустить DO или ENDWHILE.
• Использовать WHILE, когда счет известен. Цикл FOR выражает смысл одной строкой.

Цикл REPEAT проверяет условие после каждой итерации, поэтому он всегда выполняется как минимум один раз.

REPEAT
    <statements>
UNTIL <condition>

Это «как минимум один раз» — причина выбора именно его: проверка ввода, где нужно запросить данные, прежде чем можно оценить ответ.

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

⚠️ UNTIL указывает условие, которое останавливает цикл; WHILE указывает то, которое продолжает его работу. Они противоположны, и их замена — классическая ошибка.

Распространенные ошибки

• Написать UNTIL Number < 100 вместо того, чтобы написать UNTIL Number >= 100.
• Использовать REPEAT там, где тело может выполнить ноль раз.
• Забыть, что UNTIL завершает структуру — нет ключевого слова ENDREPEAT.

Массив хранит множество значений одного типа под одним именем. Каждое значение находится по индексу.

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]

• Границы записываются lower:upper, и обе включены — [1:3] имеет три элемента.
• Массивы Cambridge обычно начинаются с 1, а не с 0.
• Каждый элемент имеет тот же тип, определяемый OF.

Заполнение и чтение с помощью цикла FOR

Массив и цикл с подсчетом идут вместе: счетчик является индексом.

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

Поиск наибольшего значения

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

Начните Largest с первого элемента, а не с 0 — при отрицательных данных 0 победил бы, и ответ был бы неверным.

Распространенные ошибки

• Чтение Scores[6] из массива, объявленного как [1:5]. Это выход за пределы границ.
• Запись Scores(3). Массивы используют квадратные скобки; круглые скобки вызывают функцию.
• Объявление [1:5] и последующий цикл 0 TO 4.

2-D массив — это таблица: строки и столбцы, два индекса.

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]

Первый индекс обозначает строку, второй — столбец.

Вложенные циклы обходят таблицу

По одному циклу на каждую размерность. Внутренний цикл завершает всю строку, прежде чем внешний перейдет дальше.

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

⚠️ Внутренний NEXT закрывает внутренний счетчик. NEXT Row перед NEXT Col пересекает циклы, и это бессмысленно — компилятор мгновенно это обнаружит.

Распространенные ошибки

• Поменять местами строку и столбец. Grid[2,3] означает строку 2, столбец 3.
• Grid[Row][Col]. Cambridge использует одну пару скобок с запятой внутри.
• Пересечение NEXT строк, как описано выше.

A procedure 过程 is a named block of statements. Writing one once and calling it from several places is decomposition 分解 — the idea the whole of paper 2 rests on.

PROCEDURE <identifier>
    <statements>
ENDPROCEDURE

A procedure is called by name, with the keyword CALL:

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

CALL DefaultLine
OUTPUT "Report"
CALL DefaultLine

• The definition 定义 does nothing on its own. Only CALL runs it.
• Control returns to the line after the CALL when the procedure ends.
• A procedure does not give a value back. If you need one, you want a function.

Common mistakes

• Writing DefaultLine on its own to run it. 0478 requires CALL.
• Leaving out ENDPROCEDURE.
• Expecting the procedure's own variables to exist outside it.

A function 函数 is a procedure that hands a value back. It is written where that value is needed — inside an OUTPUT, on the right of an assignment, inside a condition.

FUNCTION <identifier>(<parameters>) RETURNS <data type>
    <statements>
    RETURN <value>
ENDFUNCTION

FUNCTION SumSquare(Number1 : INTEGER, Number2 : INTEGER) RETURNS INTEGER
    RETURN Number1 * Number1 + Number2 * Number2
ENDFUNCTION

OUTPUT "Sum of squares = ", SumSquare(10, 20)

• RETURNS <data type> on the header says what type comes back. It is not optional.
• RETURN ends the function immediately — nothing after it runs.
• A function is never called with CALL; it is used wherever its value belongs.

A function inside a condition

FUNCTION IsEven(Number : INTEGER) RETURNS BOOLEAN
    RETURN MOD(Number, 2) = 0
ENDFUNCTION

DECLARE Index : INTEGER
FOR Index ← 1 TO 6
    IF IsEven(Index)
      THEN
        OUTPUT Index, " is even"
    ENDIF
NEXT Index

Common mistakes

• CALL SumSquare(10, 20) — that throws the answer away.
• A function with no RETURN on some path. Every route out must return a value.
• Leaving RETURNS INTEGER off the header.

A parameter 参数 is a value a procedure or function is given when it is called. Each one carries its own type.

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

CALL Line(5)
CALL Line(20)

Several parameters are separated by commas, and the order at the call must match the order in the definition:

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)

⚠️ In 0478 every parameter is passed by value 传值: the procedure works on a copy, so changing it inside changes nothing outside. To get a value back, use a FUNCTION and RETURN it. (A-Level 9618 adds BYREF for the other behaviour — topic 11.)

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

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

Common mistakes

• PROCEDURE Line(Size) with no type.
• Calling with the arguments in the wrong order — Greet(2, "Mei") is a type error.
• Expecting a procedure to change the variable you passed in. In 0478 it cannot.

Файл хранит данные после завершения программы. 0478 использует четыре команды, и каждая из них указывает на файл, с которым работает.

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"

Три режима работы с файлом:

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"

• Один WRITEFILE записывает одну строку.
• CLOSEFILE необязателен. Закрытый файл может потерять данные, все еще ожидающие записи. записать, и это стандартный ответ на экзамене.

Распространенные ошибки

• FOR WRITE, когда вы имели в виду FOR APPEND, который молча уничтожает старое содержимое.
• Забывание про CLOSEFILE.
• Открытие файла, который уже открыт.

READFILE считывает одну строку в переменную. Переменная должна быть объявлена заранее.

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

Обычно вы не знаете, сколько всего строк, поэтому читаете до конца файла — именно об этом сообщает функция EOF.

OPENFILE "names.txt" FOR WRITE
WRITEFILE "names.txt", "Mei"
WRITEFILE "names.txt", "Sam"
WRITEFILE "names.txt", "Ana"
CLOSEFILE "names.txt"

DECLARE Line : STRING
OPENFILE "names.txt" FOR READ
WHILE NOT EOF("names.txt") DO
    READFILE "names.txt", Line
    OUTPUT Line
ENDWHILE
CLOSEFILE "names.txt"

EOF("names.txt") становится TRUE, когда все строки прочитаны, поэтому WHILE NOT EOF(...) означает пока есть что-то для чтения.

Подсчет во время чтения

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

Распространенные ошибки

• Цикл WHILE EOF(...) — он выполняется только тогда, когда ничего не осталось. Вам нужен NOT.
• Чтение за пределами конца из-за отсутствия в циклеEOF проверки.
• Открытие FOR READ файла, который никогда не записывался.

Cambridge публикует две спецификации псевдокода, и они расходятся. Все в темах 1-10 относится к IGCSE 0478. A-Level 9618 меняет детали ниже — и студент, изучающий оба курса, теряет баллы, используя один вариант в билете другого.

Это форма 0478, и вот как она работает здесь:

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

Форма 9618 того же алгоритма пишется так — обратите внимание на THEN на строке IF, = в CONSTANT, и MOD между его двумя значениями:

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

⚠️ Правильный вариант зависит исключительно от того, какой билет вам достался. Ни один из них не является ошибкой; каждый представляет собой ошибку в экзамене другого формата. Песочница на этой странице использует правила 0478, поэтому конструкция 9618 будет отклонена с сообщением, указывающим на соответствующую программу — это быстрый способ проверить свои собственные привычки.

Распространенные ошибки

• Написание THEN на строке IF в ответе 0478, потому что это то, что учебник или веб-сайте. Это самая частая ошибка при пересечении программ.
• 10 MOD 3 в 0478. Там он MOD(10, 3).
• ROUND(3.14159, 2) в ответе 9618. 9618 вообще не имеет ROUND.

0478 передает каждый параметр по значению (тема 9). 9618 позволяет выбрать и указывает это в заголовке.

• BYVAL — процедура получает копию. Изменение её ничего не меняет снаружи. Это по умолчанию, если ни одно из слов не указано.
• BYREF — процедура работает с собственной переменной вызывающего кода, поэтому изменение видно после вызова.

Это касается только 9618. Здесь это не работает, и не принимается в ответе 0478:

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

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

Способ 0478 получить значение обратно

Используйте FUNCTION и присвойте возвращаемое значение. Это весь ответ 0478, и он работает:

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

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

Распространенные ошибки

• Написание BYREF в ответе 0478. Ключевое слово отсутствует в этой программе обучения.
• Ожидание, что простой параметр 9618 будет вести себя как BYREF. Без этого слова он является BYVAL.

9618 имеет структуры данных, которых нет в 0478. Вы встретите их только на уровне A-Level, и ни одна из них не работает по правилам 0478 этой страницы.

Запись группирует поля разных типов под одним именем (раздел 9618 раздел 4):

TYPE Student
    DECLARE Name : STRING
    DECLARE Mark : INTEGER
ENDTYPE

DECLARE Candidate : Student
Candidate.Name ← "Mei"
Candidate.Mark ← 91
OUTPUT Candidate.Name, " scored ", Candidate.Mark

Перечисляемый тип перечисляет единственные значения, которые может принимать переменная:

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

9618 также добавляет тип данных DATE, файлы с произвольным доступом (OPENFILE … FOR RANDOM), указатели, и классы с CLASS … ENDCLASS для его объектно-ориентированной части.

⚠️ 0478 имеет пять типов данных и массивов, и ничего больше (тема 2). Ответ на вопрос о 0478 объединенных общим индексом.

Распространенные ошибки

• Использование структуры в ответе на вопрос о 0478. Вместо этого используйте параллельные массивы — по одному массиву на каждое поле; создает переменную существующего типа.
• Считание того, что TYPE означает то же самое, что и DECLARE. TYPE определяет новый тип; DECLARE Python выполняет ваш код построчно. Каждая строка — это команда. Программа — это просто список команд, выполняемых сверху вниз.