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

シラバスからの4つのルール：

• 大文字で始めなければなりません：Count が正しく、count は誤りです。
• 文字と数字のみを含めることができ、スペースや記号は使えません。
• 大文字・小文字の区別はしないため、Count と COUNT は同じ名前として扱われます。 正しいスペルを1つ選び、一貫して使い続けてください。
• 意味を持たせる。 NumberOfPlayers は読者の時間を獲得しますが、 N は得ません。

** 一般的なミス **

• count ← 0 — 小文字での開始は誤りです。0478 は大文字での開始が必要です。
• Number of players — 名前の内部にスペースは許容されません。

コメントは // で始まり、その行の末尾まで続きます。これは人間用であり、アルゴリズムは無視します。 reader；アルゴリズムは無視する。

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

インデントは、どの文が構造の内部にあるかを示す。カリキュラムでの要求事項は 各レベルで4つのスペースを使用しますが、例外として1つだけ知っておく必要があります：

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 に対して2つのスペースインデントされます。
• インデントを一切置かない。採点者が構造を認識して構造点数を与えなければなりません。
• ENDIF は自身の IF と同じ位置に配置されます。

** 一般的なミス **

• THENをIF行に配置する。これがA-Levelの9618フォーマットである——テーマ11を参照のこと。
• インデントを一切行わない。採点者が構造を確認できるために、構造点数が与えられる必要がある。

0478の擬似コードには5つのデータ型がある。リストを覚える——その中にない名前は类型を答えたとしても点数は失われる。 それがリストに含まれていないと点数が失われる。

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

同じ型の変数名を1行に複数書き、コンマで区切る：

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は1つ以上の値を表示する。

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

• INPUT は1つの変数を正確に受け取り、その変数はすでに宣言されている必要があります。
• OUTPUT はコンマで区切られた任意の数の項目を受け取ります；これらは1つずつ順に印刷されます。 互いに何もない状態で。
• 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 を探します。

Five arithmetic 算术 operators, in the order a calculator uses them.

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

Brackets come first, then ^, then * and /, then + and - — the usual precedence 优先级. Use brackets whenever the reader would have to stop and think.

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

Common mistakes

• Expecting / to give a whole number. 7 / 2 is 3.5, not 3; for a whole number use DIV.
• Writing A x B or A ÷ B. Use * and /.

Integer division 整数除法 answers two different questions, and 0478 writes each of them as a function 函数, with the two values in brackets.

• DIV(a, b) — how many whole times b goes into a, the quotient 商.
• MOD(a, b) — what is left over, the remainder 余数.

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

Both take integers, and both return an integer.

What they are for

MOD is the standard test for divides exactly, which makes it the way to ask whether a number is even 偶数:

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

DIV converts a total into whole units — seconds into minutes, pence into pounds:

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

Common mistakes

• 10 MOD 3. That is the A-Level 9618 form; 0478 uses the function form MOD(10, 3).
• Mixing the two up. DIV gives the whole part; MOD gives what does not fit.

A relational operator 关系运算符 compares two values and produces TRUE or FALSE.

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

The three logic operators 逻辑运算符 join conditions:

• AND — both sides must be TRUE.
• OR — at least one side must be TRUE.
• NOT — turns TRUE into FALSE and back.

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

Common mistakes

• <> is the not equal sign here — not !=, which belongs to other languages.
• IF Age >= 15 AND <= 18. Each side of AND needs its own complete comparison: Age >= 15 AND Age <= 18.
• Calling these comparison operators in an answer. The syllabus term is relational.

0478 publishes four string 字符串 routines and no others. Three of them are here.

LENGTH(<identifier>) returns how many characters 字符 a string holds — spaces included.

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

UCASE(<identifier>) returns the string in upper case 大写, LCASE(<identifier>) in lower case 小写. Neither changes the original 原值 — each hands back a new value.

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

That last line still prints Happy: to keep the change you must assign it back.

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

Comparing without worrying about case

UCASE on both sides is the standard way to accept an answer however it was typed:

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

Common mistakes

• Expecting UCASE(Name) to change Name. Assign the result back.
• LENGTH counts characters, not words. LENGTH("Happy Days") is 10.

Selection 选择 runs one group of statements or another, depending on a condition 条件.

IF <condition>
  THEN
    <statements>
ENDIF

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

Add ELSE for the other case. Exactly one of the two branches 分支 runs — never both, never neither.

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

The layout is the one part students lose marks on, so learn it as a shape:

• IF and its condition on one line, nothing after the condition.
• THEN and ELSE on their own lines, indented two spaces.
• The statements indented four.
• ENDIF back at the column of its IF.

Nesting 嵌套

An IF inside an IF handles more than two outcomes. Each one needs its own ENDIF.

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

Common mistakes

• Forgetting ENDIF. Every IF closes, and a missing one is a syntax error 语法错误 the marker will see at a glance.
• IF Mark >= 50 THEN OUTPUT "Pass" on one line. No such form exists in either syllabus; write the three lines.
• IF Mark = 50 THEN written as IF Mark ← 50. The arrow assigns; = compares.

Iteration 迭代 repeats statements. Use a FOR loop when you know before you start how many times — a count-controlled 计数控制 loop.

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

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

The counter 计数器 starts at the first value, and the loop runs once for every value up to and including the second. 1 TO 5 runs five times.

STEP

STEP changes the size of each jump. A negative step counts down.

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

Running totals

The commonest use: a variable outside the loop that the loop adds to.

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 must sit before the loop. Inside, it would reset on every pass.

Common mistakes

• NEXT naming the wrong counter. Nested loops must close in the reverse order they opened: the inner NEXT first.
• Assuming 1 TO 5 runs four times. Both ends are included.
• Changing the counter inside the loop. Let FOR own it.

A WHILE loop tests before each pass, so it can run zero times. Use it when the number of repeats depends on something that happens while the loop runs.

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

Something inside the loop must eventually make the condition false, or the loop never ends — an infinite loop 无限循环.

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

Common mistakes

• Forgetting to change the variable the condition tests, giving an infinite loop.
• Leaving out DO or ENDWHILE.
• Using WHILE where the count is known. A FOR says what you mean in one line.

A REPEAT loop tests after each pass, so it always runs at least once.

REPEAT
    <statements>
UNTIL <condition>

That "at least once" is the reason to choose it: validating 验证 input, where you must ask before you can judge the answer.

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

⚠️ UNTIL states the condition that stops the loop; WHILE states the one that keeps it going. They are opposites, and swapping them is the classic error.

Common mistakes

• Writing UNTIL Number < 100 when you mean UNTIL Number >= 100.
• Using REPEAT where the body must be able to run zero times.
• Forgetting that UNTIL ends the structure — there is no ENDREPEAT.

An array 数组 holds many values of one type under one name. Each value sits at an index 下标.

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]

• The bounds 边界 are written lower:upper, and both are included — [1:3] has three elements 元素.
• Cambridge arrays normally start at 1, not 0.
• Every element has the same type, fixed by OF.

Filling and reading with a FOR loop

An array and a counted loop belong together: the counter is the index.

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

Finding the largest

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

Start Largest at the first element, never at 0 — with negative data, 0 would win and the answer would be wrong.

Common mistakes

• Reading Scores[6] from an array declared [1:5]. That is out of bounds 越界.
• Writing Scores(3). Arrays use square brackets; round brackets call a function.
• Declaring [1:5] and then looping 0 TO 4.

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]

The first index is the row 行, the second the column 列.

Nested loops walk a table

One loop per dimension 维度. The inner loop finishes a whole row before the outer moves on.

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

⚠️ The inner NEXT closes the inner counter. NEXT Row before NEXT Col crosses the loops over and is nonsense — a marker spots it instantly.

Common mistakes

• Swapping row and column. Grid[2,3] is row 2, column 3.
• Grid[Row][Col]. Cambridge writes one pair of brackets with a comma inside.
• Crossing the NEXT lines over, as above.

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.

A file 文件 keeps data after the program ends. 0478 uses four commands, and every one names the file it works on.

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"

Three file modes 文件模式:

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"

• One WRITEFILE writes one line.
• CLOSEFILE is not optional. An unclosed file can lose the data still waiting to be written, and that is a stock exam answer.

Common mistakes

• FOR WRITE when you meant FOR APPEND, which silently destroys the old contents.
• Forgetting CLOSEFILE.
• Opening a file that is already open.

Cambridge publishes two pseudocode specifications, and they disagree. Everything in topics 1-10 is IGCSE 0478. A-Level 9618 changes the details below — and a student who studies both loses marks by writing one in the other's paper.

This is the 0478 form, and it runs here:

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

The 9618 form of the same algorithm is written like this — note THEN on the IF line, = in the CONSTANT, and MOD between its two values:

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

⚠️ Which one is right depends only on which paper you are sitting. Neither is a mistake; each is a mistake in the other's exam. The playground on this page runs the 0478 rules, so a 9618 construct is refused with a message naming the syllabus it belongs to — which is a quick way to check your own habits.

Common mistakes

• Writing THEN on the IF line in an 0478 answer, because that is what a textbook or a website showed. It is the single commonest cross-syllabus slip.
• 10 MOD 3 in 0478. There it is MOD(10, 3).
• ROUND(3.14159, 2) in a 9618 answer. 9618 has no ROUND at all.

0478 passes every parameter by value 传值 (topic 9). 9618 lets you choose, and says so in the header.

• BYVAL — the procedure gets a copy. Changing it changes nothing outside. This is the default when neither word is written.
• BYREF — the procedure works on the caller's own variable 引用, so a change is visible after the call.

This is 9618 only. It does not run here, and it is not accepted in an 0478 answer:

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

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

The 0478 way to get a value back

Use a FUNCTION and assign what it returns. This is the whole of the 0478 answer, and it runs:

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

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

Common mistakes

• Writing BYREF in an 0478 answer. The keyword is not in that syllabus.
• Expecting a plain 9618 parameter to behave like BYREF. Without the word it is BYVAL.

9618 has data structures 数据结构 that 0478 does not. You will meet them only at A-Level, and none of them runs under the 0478 rules of this page.

A record 记录 groups fields of different types under one name (9618 section 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

An enumerated type 枚举类型 lists the only values a variable may take:

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

9618 also adds a DATE data type, random-access files (OPENFILE … FOR RANDOM), pointers, and classes with CLASS … ENDCLASS for its object-oriented paper.

⚠️ 0478 has five data types and arrays, and nothing else (topic 2). A 0478 answer that declares a record is answering a different syllabus.

Common mistakes

• Using a record in an 0478 answer. Use parallel arrays instead — one array per field, sharing an index.
• Thinking TYPE means the same as DECLARE. TYPE defines a new type; DECLARE creates a variable of an existing one.