Writing 0478 Pseudocode From Memory

邊玩邊學

回答這些題目賺取能量，接著就能釣魚、探索。不需要帳號。

給老師：為 Writing 0478 Pseudocode From Memory（Computer Science、CIE）準備好可直接使用的課程投影片, 複習筆記——用於你的課程，或把這個主題當成互動班級活動，讓學生以即時遊戲的方式進行。

課程筆記

Exam Context and Importance

Paper 2 (1h45m, 75 marks) requires pseudocode answers; programming-language code earns no marks.
The only exception is the final 15-mark scenario question, where pseudocode, Python, VB, or Java are accepted.
No pseudocode reference sheet is provided in the exam; you must reproduce constructs from memory.
Mark schemes are written in Cambridge pseudocode, so accuracy in syntax is vital to earn marks.
Focus on logic over syntax, but incorrect pseudocode loses marks even if logic is right.

General Style Rules

Keywords are in UPPER CASE (e.g., IF, THEN, ELSE, ENDIF, REPEAT, UNTIL, WHILE, DO, ENDWHILE, FOR, NEXT, CASE OF, OTHERWISE, ENDCASE, DECLARE, CONSTANT, INPUT, OUTPUT, PROCEDURE, ENDPROCEDURE, CALL, FUNCTION, RETURNS, RETURN, ENDFUNCTION, OPENFILE, READFILE, WRITEFILE, CLOSEFILE, ARRAY, OF, STEP).
Identifiers use Pascal case (e.g., NumberOfPlayers, TotalToPay); start with a capital letter, contain only letters/digits, no underscores or accented letters.
Identifiers are case-insensitive (Countdown = CountDown) and must not be keywords.
Single letters allowed only conventionally: i, j for indices, X, Y for coordinates.
Indentation: 4 spaces for block contents, 2 spaces for THEN/ELSE and CASE clauses.
Comments start with // and run to end of line; multi-line comments use // on each line.

Data Types, Declarations, and Constants

Five basic data types: INTEGER, REAL, CHAR, STRING, BOOLEAN.
Literals: integers (5, -3), reals always with digit both sides of point (4.7, 0.3, -4.0, 0.0), chars in single quotes ('x'), strings in double quotes ("text"), Booleans TRUE/FALSE.
Declaration syntax: `DECLARE <identifier> : <data type>` (e.g., `DECLARE Counter : INTEGER`).
Constant syntax: `CONSTANT <identifier> ← <value>` (e.g., `CONSTANT HourlyRate ← 6.50`).
Constant value must be a literal only; never a variable, constant, or expression.

Assignment and Operators

Assignment uses left arrow `←` (e.g., `Counter ← 0`); `=` is only for equality in conditions.
Arithmetic operators: `+`, `-`, `×`, `/`, `^` (power). Multiplication/division bind tighter than addition/subtraction; use parentheses for clarity.
Integer division: `DIV(x, y)` returns quotient with fraction discarded (e.g., `DIV(10,3)` = 3); `MOD(x, y)` returns remainder (e.g., `MOD(10,3)` = 1).
Relational operators: `=`, `<`, `≤`, `>`, `≥`, `<>` (not equal).
Logical operators: AND, OR, NOT; operands and results are BOOLEAN.

Input and Output

`INPUT <variable>` reads a single value into a variable (may be an array element).
`OUTPUT <value1>, <value2>, ...` outputs comma-separated values.
`INPUT` does not display a prompt; use a separate `OUTPUT` before it.
Example: `OUTPUT "You have ", Lives, " lives left"`.

Selection (IF and CASE)

IF syntax: `IF <condition> THEN <statements> ENDIF` (with optional ELSE).
THEN and ELSE clauses are indented 2 spaces; nested IFs continue this pattern.
CASE syntax: `CASE OF <identifier> <value> : <statement> ... OTHERWISE <statement> ENDCASE`.
Case clauses are tested in order; first match runs, then control jumps to after ENDCASE.
OTHERWISE must be last; each case should be a single value; complex logic better as IF.
Example: `CASE OF Move 'W' : Position ← Position - 10 'E' : Position ← Position + 10 OTHERWISE OUTPUT "Beep" ENDCASE`.

Iteration (Loops)

FOR loop: `FOR <identifier> ← <value1> TO <value2> <statements> NEXT <identifier>`; counter must be INTEGER.
FOR loop runs inclusive of end values; if start > end, body runs zero times; STEP can be added (e.g., `FOR Index ← 10 TO 1 STEP -1`).
REPEAT...UNTIL: `REPEAT <statements> UNTIL <condition>` — body always runs at least once, condition tested at bottom.
WHILE...DO...ENDWHILE: `WHILE <condition> DO <statements> ENDWHILE` — condition tested at top, body may run zero times.
Do not confuse REPEAT (post-condition) with WHILE (pre-condition).

Arrays

Declaration: `DECLARE <name> : ARRAY[<lower>:<upper>] OF <type>` (e.g., `DECLARE StudentNames : ARRAY[1:30] OF STRING`).
2D arrays: `DECLARE NoughtsAndCrosses : ARRAY[1:3, 1:3] OF CHAR`.
State lower bound explicitly (usually 1) because default varies.
Access elements with brackets: `StudentNames[1] ← "Ali"`, `NoughtsAndCrosses[2,3] ← 'X'`.
Fill arrays using loops: `FOR Index ← 1 TO 30 StudentNames[Index] ← "" NEXT Index`.

String and Library Routines

`LENGTH("Happy Days")` returns 10.
`SUBSTRING("Happy Days", 1, 5)` returns "Happy" (identifier, start, length).
`UCASE("Happy")` returns "HAPPY"; `LCASE('W')` returns 'w'.
`ROUND(<identifier>, <places>)` rounds a REAL to given decimal places.
`RANDOM()` returns a random number between 0 and 1 inclusive.
Example: `Value ← ROUND(RANDOM()×6, 0)` gives a whole number 0-6.

Procedures and Functions

Procedure definition: `PROCEDURE <name>(<params>) <statements> ENDPROCEDURE`; called with `CALL <name>(<args>)`.
Function definition: `FUNCTION <name>(<params>) RETURNS <type> <statements> RETURN <value> ENDFUNCTION`; called without CALL as part of an expression.
Example procedure: `PROCEDURE Line(Size : INTEGER) ... ENDPROCEDURE` then `CALL Line(60)`.
Example function: `FUNCTION SumSquare(Number1 : INTEGER, Number2 : INTEGER) RETURNS INTEGER RETURN Number1×Number1 + Number2×Number2 ENDFUNCTION`; used as `OUTPUT SumSquare(10,20)`.

File Handling

Open file: `OPENFILE "FileA.txt" FOR READ` or `FOR WRITE`.
Read: `READFILE "FileA.txt", <variable>`; Write: `WRITEFILE "FileB.txt", <variable>`.
Close: `CLOSEFILE "FileA.txt"`.
A file can be opened in one mode at a time; WRITE creates a new file (overwrites existing).
Always close files when done.

Common Mistakes to Avoid (Recall Checklist)

Using `=` instead of `←` for assignment.
Lower-case keywords, or identifiers with underscores or leading lower-case.
Missing closing keywords: ENDIF, ENDWHILE, NEXT <identifier>, ENDCASE, ENDPROCEDURE, ENDFUNCTION.
Writing conditions in words ("x is greater than y") instead of symbols (`x > y`).
Using CALL on a function, or omitting CALL on a procedure call.
Declaring arrays without bounds, or indexing out of bounds.
Using variable/expression as constant value.
Forgetting separate OUTPUT prompt before INPUT.
Confusing REPEAT...UNTIL with WHILE...DO...ENDWHILE.
Using undeclared variables or wrong data types.

投影片

Step through every slide for this topic — plus flashcards and revision notes — with a free account.

免費註冊登入

練習題

免費預覽——59 題中的 8 題。註冊即可查看全部。

1.Which of the following is the correct assignment operator in Cambridge 0478 pseudocode?
Easy
- A=
- B←
- C:=
- D→
2.In Cambridge 0478 pseudocode, keywords must be written in upper case (e.g., IF, THEN, ENDIF).
Easy
True or false?
3.Which of the following is the correct declaration of an integer variable named Counter?
Easy
- ADECLARE Counter : INTEGER
- BDECLARE Counter: Integer
- CINTEGER DECLARE Counter
4.In Cambridge 0478 pseudocode, identifiers may contain underscores (e.g., Total_Score).
Easy
True or false?
5.What is the value of MOD(10, 3) in Cambridge 0478 pseudocode?
Easy
- A3
- B1
- C0
- D3.33
6.A REPEAT...UNTIL loop always executes its body at least once.
Easy
True or false?
7.Which of the following is the correct way to declare a 1D array of 30 strings?
Medium
- ADECLARE StudentNames : ARRAY[1:30] OF STRING
- BDECLARE StudentNames : ARRAY[30] OF STRING
- CDECLARE StudentNames : ARRAY[1 TO 30] OF STRING
- DDECLARE StudentNames : ARRAY[1:30] STRING
8.A procedure must be called using the keyword CALL.
Easy
True or false?

複習筆記

## 0478 Pseudocode from Memory — Night-Before Notes **Why it matters:** Paper 2 (1h45, 75 marks) requires pseudocode answers. Programming languages earn no marks (except the final 15-mark scenario). Mark schemes use Cambridge pseudocode — half-remembering loses marks. **Style rules** - Keywords UPPER CASE: IF, THEN, ELSE, ENDIF, REPEAT, UNTIL, WHILE, DO, ENDWHILE, FOR, NEXT, CASE OF, OTHERWISE, ENDCASE, DECLARE, CONSTANT, INPUT, OUTPUT, PROCEDURE, ENDPROCEDURE, CALL, FUNCTION, RETURNS, RETURN, ENDFUNCTION, OPENFILE, READFILE, WRITEFILE, CLOSEFILE, ARRAY, OF, STEP. - Identifiers Pascal case (e.g., NumberOfPlayers), letters/digits only, start with capital, no underscores. Case-insensitive (Countdown = CountDown). - Indentation: 4 spaces per block; 2 spaces for THEN/ELSE and CASE clauses. - Comments: // ... **Data types & declarations** - Types: INTEGER, REAL, CHAR, STRING, BOOLEAN. - Literals: reals need digit both sides (4.7, 0.0); CHAR in single quotes ('x'); STRING in double quotes ("..."); Booleans TRUE/FALSE. - DECLARE <id> : <type> - CONSTANT <id> ← <literal> (only literal, never variable/expression). **Assignment & operators** - Use ←, not =. - Arithmetic: + - * / ^; DIV(x,y) quotient (discard fraction), MOD(x,y) remainder. - Relational: = < <= > >= <> - Logical: AND OR NOT (BOOLEAN operands). **Input/Output** - INPUT <var> (no prompt inside; use OUTPUT before). - OUTPUT can take multiple comma-separated values. **Selection** - IF <cond> THEN ... ENDIF / ELSE ... ENDIF (2-space indent for THEN/ELSE). - CASE OF <id>: <value> : <statement> ... OTHERWISE <statement> ENDCASE (first match runs; OTHERWISE last). **Iteration** - FOR <id> ← <start> TO <end> ... NEXT <id> (inclusive; STEP optional; counter INTEGER). - REPEAT ... UNTIL <cond> (post-condition, runs at least once). - WHILE <cond> DO ... ENDWHILE (pre-condition, may run zero times). **Arrays** - DECLARE <id> : ARRAY[<lower>:<upper>] OF <type> (state lower bound, usually 1). - Index with [i] or [i,j]. Fill with loop. **String/library routines** - LENGTH(string), SUBSTRING(string, start, length), UCASE, LCASE, ROUND(real, places), RANDOM() (0–1 inclusive). **Procedures & functions** - PROCEDURE <name>(params) ... ENDPROCEDURE; call with CALL. - FUNCTION <name>(params) RETURNS <type> ... RETURN <value> ENDFUNCTION; call without CALL in expression. **File handling** - OPENFILE "file" FOR READ/WRITE; READFILE/WRITEFILE "file", var; CLOSEFILE "file". WRITE overwrites. **Top 10 marks thrown away** 1. = instead of ← 2. Lower-case keywords or bad identifiers 3. Missing ENDIF/ENDWHILE/NEXT/ENDCASE/ENDPROCEDURE/ENDFUNCTION 4. Conditions in words not symbols 5. CALL on function or missing CALL on procedure 6. Array without bounds or out-of-range index 7. CONSTANT with variable/expression 8. No OUTPUT prompt before INPUT 9. Confusing REPEAT...UNTIL with WHILE...DO...ENDWHILE 10. Undeclared variable or wrong type

Pseudocode: A structured way of writing algorithms using English-like statements; in CIE 0478 it must follow specific conventions (keywords upper case, assignment arrow ←, etc.).
Assignment operator: The left arrow ← used to assign a value to a variable, e.g., Counter ← 0. Not the equals sign.
Pascal case: Identifiers with each word starting with a capital letter, e.g., NumberOfPlayers. No underscores, start with capital letter.
DECLARE: Statement to declare a variable with its data type, e.g., DECLARE Counter : INTEGER.
CONSTANT: Statement to define a constant with a literal value, e.g., CONSTANT HourlyRate ← 6.50. Value must be a literal.
DIV: Integer division routine: DIV(x, y) returns the quotient with fractional part discarded, e.g., DIV(10,3) = 3.
MOD: Modulo routine: MOD(x, y) returns the remainder of integer division, e.g., MOD(10,3) = 1.
CASE OF: Selection statement that tests an identifier against multiple values, executing the first matching branch; OTHERWISE optional and last.
FOR...NEXT: Count-controlled loop: FOR <id> ← <start> TO <end> ... NEXT <id>. Counter is INTEGER, inclusive, optional STEP.
REPEAT...UNTIL: Post-condition loop: body executes at least once, condition tested at the bottom.
WHILE...DO...ENDWHILE: Pre-condition loop: condition tested at the top, body may execute zero times.
PROCEDURE: A named block of code that performs a task; called with CALL. Declared with PROCEDURE ... ENDPROCEDURE.
FUNCTION: A named block that returns a single value; declared with FUNCTION ... RETURNS <type> ... RETURN ... ENDFUNCTION. Called without CALL in an expression.
ARRAY: Fixed-length structure holding elements of one data type, accessed by index. Declared with bounds, e.g., ARRAY[1:30] OF STRING.
OPENFILE: Opens a file for reading or writing: OPENFILE "filename" FOR READ/WRITE.
READFILE: Reads a line from an open file into a variable: READFILE "filename", variable.
WRITEFILE: Writes a value to an open file: WRITEFILE "filename", value.
CLOSEFILE: Closes an open file: CLOSEFILE "filename".
LENGTH: Built-in function returning the number of characters in a string, e.g., LENGTH("Happy Days") = 10.
SUBSTRING: Built-in function returning a substring: SUBSTRING(string, start, length), e.g., SUBSTRING("Happy Days",1,5) = "Happy".
UCASE/LCASE: Built-in functions converting a string/char to upper/lower case, e.g., UCASE("Happy") = "HAPPY".
ROUND: Built-in function rounding a REAL to a given number of decimal places: ROUND(identifier, places).
RANDOM: Built-in function returning a random number between 0 and 1 inclusive.

字卡

What is the assignment operator in Cambridge 0478 pseudocode?

The left arrow ←, e.g., Counter ← 0. An equals sign is only for equality in conditions.

How are keywords and identifiers formatted in 0478 pseudocode?

Keywords are in UPPER CASE (IF, THEN, ENDIF, etc.). Identifiers use Pascal case (e.g., NumberOfPlayers) and must start with a capital letter, containing only letters and digits, no underscores.

List the five basic data types in 0478 pseudocode.

INTEGER, REAL, CHAR, STRING, and BOOLEAN.

How do you declare a variable and a constant?

Variable: DECLARE <identifier> : <data type>. Constant: CONSTANT <identifier> ← <literal value>.

What is the rule for the value of a CONSTANT?

It must be a literal only – never a variable, another constant, or an expression.

How do you write a comment in 0478 pseudocode?

Start with // and run to the end of the line. For multi-line comments, repeat // on each line.

What is the correct syntax for an IF statement with an ELSE clause?

IF <condition> THEN <statements> ELSE <statements> ENDIF, with THEN/ELSE clauses indented two spaces.

What is the correct syntax for a CASE statement?

CASE OF <identifier> <value> : <statement> ... OTHERWISE <statement> ENDCASE. OTHERWISE must be last.

What is the correct syntax for a FOR loop?

FOR <identifier> ← <value1> TO <value2> ... NEXT <identifier>. The counter must be an INTEGER variable.

What is the correct syntax for a REPEAT loop?

REPEAT <statements> UNTIL <condition>. The condition is tested at the bottom, so the body always runs at least once.

What is the correct syntax for a WHILE loop?

WHILE <condition> DO <statements> ENDWHILE. The condition is tested at the top, so the body may run zero times.

How do you declare a 1D array and a 2D array?

DECLARE <identifier> : ARRAY[lower:upper] OF <data type>. For 2D: ARRAY[lower1:upper1, lower2:upper2] OF <data type>. Lower bound should be explicit, usually 1.

What is the syntax for a PROCEDURE and how do you call it?

PROCEDURE <name>(<parameters>) ... ENDPROCEDURE. Call it with CALL <name>(<arguments>).

What is the syntax for a FUNCTION and how do you call it?

FUNCTION <name>(<parameters>) RETURNS <data type> ... ENDFUNCTION. Call it without CALL, as part of an expression.

What are the built-in string routines and their purposes?

LENGTH(<string>) returns length; SUBSTRING(<string>, start, length) returns substring; UCASE(<string>) converts to uppercase; LCASE(<string>) converts to lowercase.

What do ROUND and RANDOM do?

ROUND(<real>, <places>) rounds a REAL to a given number of decimal places. RANDOM() returns a random number between 0 and 1 inclusive.

What do DIV and MOD return?

DIV(<x>, <y>) returns the integer quotient with fractional part discarded. MOD(<x>, <y>) returns the remainder. Both operands are integers.

What is the correct syntax for file operations?

OPENFILE "filename" FOR READ/WRITE, READFILE "filename", <variable>, WRITEFILE "filename", <value>, CLOSEFILE "filename".

How do you write a condition correctly?

Use relational operators: =, <, ≤, >, ≥, <>. Write x > y, never "x is greater than y".

What is the indentation rule for blocks and THEN/ELSE/CASE clauses?

Lines inside a block are indented four spaces. THEN/ELSE and CASE clauses are indented two spaces.

What are the common mistakes that lose marks in pseudocode?

Using = for assignment, lower-case keywords, missing closing keywords, writing conditions in words, using CALL on functions, omitting array bounds, using non-literal constants, missing OUTPUT prompt, confusing REPEAT/WHILE, and using undeclared variables.

What is the rule for identifiers regarding case sensitivity?

Identifiers are case insensitive, so Countdown and CountDown are the same variable and must not be used as two different variables.

What is the syntax for INPUT and OUTPUT?

INPUT <variable> takes a single variable. OUTPUT <value1>, <value2>, ... can take multiple comma-separated values. Prompts are separate OUTPUT statements before INPUT.

What is the rule for single-letter identifiers?

Single letters are acceptable only where conventional: i and j for array indices, X and Y for coordinates.

Unlock all 59 questions, flashcards & more

建立免費帳號，即可查看這個主題的所有題目、投影片、字卡與複習筆記。

免費註冊登入

歷屆試題

這個主題的歷屆試題練習即將推出。

即將推出