Cambridge Pseudocode Handout · ⁨Catatan Tangan Pseudocode Cambridge⁩

Pseudocode adalah bahasa yang digunakan Cambridge dalam menulis algoritma. Ini bukan bahasa pemrograman sungguhan — tidak ada komputer yang menjalankannya — tetapi ujian memberinya nilai seolah-olah itu nyata, sehingga bentuknya sangat penting.

Setiap kata kunci ditulis dengan huruf kapital: IF, REPEAT, PROCEDURE, OUTPUT.

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

• Tulis IF, jangan pernah if atau If.
• Kata kunci tidak boleh digunakan sebagai nama sendiri: Anda tidak boleh menyebut variabel FOR.

Kesalahan umum

• Kata kunci huruf kecil. Skema penilaian mengharapkan huruf kapital.
• Menciptakan kata kunci. Hanya kata-kata dalam lembar kerja ini yang termasuk dalam silabus.

Sebuah identifikator adalah nama yang Anda berikan kepada variabel, konstanta, prosedur atau fungsi.

DECLARE NumberOfPlayers : INTEGER
NumberOfPlayers ← 4
OUTPUT NumberOfPlayers

Empat aturan, semuanya berasal dari silabus:

• Harus dimulai dengan huruf kapital: Count, bukan count.
• Hanya boleh berisi huruf dan angka — tanpa spasi, tanpa tanda baca.
• Tidak peka huruf besar/kecil, jadi Count dan COUNT adalah nama yang sama. Pilih satu ejaan dan pertahankan itu.
• Berikan makna pada nama tersebut. NumberOfPlayers menghargai waktu pembaca; N tidak.

Kesalahan umum

• count ← 0 — awal huruf kecil. 0478 mengharuskan huruf kapital.
• Number of players — spasi tidak diperbolehkan di dalam nama.

Sebuah komentar dimulai dengan // dan berjalan hingga akhir baris. Ini untuk pembaca manusia; algoritma mengabaikannya.

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

Indentasi menunjukkan pernyataan mana yang berada di dalam struktur. Silabus meminta empat spasi per tingkat, dengan satu pengecualian yang harus Anda ketahui:

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 dan ELSE diindentasi dua spasi dari IF mereka.
• Pernyataan di bawahnya diindentasi empat spasi.
• ENDIF sejajar dengan IF miliknya sendiri.

Kesalahan umum

• Menaruh THEN pada baris IF. Itu adalah tata letak A-Level 9618 — lihat topik 11.
• Tidak ada indentasi sama sekali. Penilai harus melihat strukturnya untuk memberikan nilai struktur.

Pseudocode 0478 memiliki tepat lima tipe data. Hafalkan daftarnya — menyebut tipe yang tidak ada di dalamnya akan kehilangan nilai.

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 ditulis dalam tanda kutip ganda, CHAR dalam tanda kutip tunggal.
• TRUE dan FALSE adalah kata kunci, sehingga ditulis huruf kapital dan tanpa tanda kutip.

Kesalahan umum

• Menulis FLOAT, DOUBLE atau BOOL. Itu adalah bahasa sungguhan, bukan silabus ini.
• 'Hello' untuk string — tanda kutip tunggal hanya memuat satu karakter.

DECLARE memberi nama variabel dan menetapkan tipenya sebelum Anda menggunakannya.

DECLARE <identifier> : <data type>

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

Beberapa nama dengan satu tipe dapat diletakkan dalam satu baris, dipisahkan oleh koma:

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

• Deklarasikan variabel sebelum penggunaan pertamanya, di dekat atas algoritma.
• Variabel mempertahankan tipenya sepanjang algoritma — sebuah INTEGER tidak pernah menyimpan "Mei".

Kesalahan umum

• Melewatkan titik dua: DECLARE Counter INTEGER.
• Menggunakan variabel yang tidak pernah dideklarasikan. Ujian mengharapkan deklarasinya.

Sebuah konstanta adalah nilai yang tetap sepanjang algoritma — tarif pajak, π, ukuran kelas. Memberi nama sekali berarti perubahan dilakukan di satu tempat saja.

CONSTANT <identifier> ← <value>

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

• Dalam 0478 panah digunakan, persis seperti untuk penugasan.
• Nilainya harus berupa literal — angka, string, TRUE — tidak pernah perhitungan dan tidak pernah variabel lain.
• Konstanta tidak pernah bisa diberi nilai baru kemudian. Itulah tujuan utamanya.

Kesalahan umum

• CONSTANT TaxRate = 0.20. Bentuk = adalah ejaan A-Level 9618 — lihat topik 11.
• Menugaskan ke konstanta lebih jauh di dalam algoritma.

Operator penugasan adalah ←, panah yang menunjuk ke kiri. Artinya ambil nilai di sisi kanan dan masukkan ke dalam kotak di sisi kiri.

<identifier> ← <value>

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

Counter ← Counter + 1 terlihat mustahil sebagai matematika dan biasa sebagai instruksi: hitung sisi kanan dengan nilai yang sedang dimiliki kotak itu, lalu simpan hasilnya kembali.

• Jika Anda tidak bisa mengetik ←, tulis <-. Keduanya diterima, di sini maupun dalam ujian.
• Sisi kiri harus berupa satu identifikator atau satu elemen array. Jangan pernah perhitungan.

Kesalahan umum

• Counter = 0. Dalam pseudocode = adalah perbandingan, bukan penugasan — dan bingung keduanya adalah kesalahan sintaks paling umum dalam kertas ini.
• Counter + 1 ← Counter. Panah menunjuk ke hal yang diubah.

INPUT membaca nilai dari pengguna ke dalam variabel. OUTPUT menampilkan satu atau lebih nilai.

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

• INPUT menerima tepat satu variabel, dan variabel itu harus sudah dideklarasikan.
• OUTPUT menerima sejumlah item apa pun yang dipisahkan oleh koma; mereka dicetak satu demi lain dengan tidak ada spasi di antaranya.
• String literal dalam OUTPUT harus menggunakan tanda kutip ganda; variabel tidak.

Meminta input pengguna

Perintah INPUT yang berdiri sendiri tidak menampilkan apa pun di layar, sehingga algoritma yang baik mencetak pesan permintaan terlebih dahulu:

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

Kesalahan umum

• INPUT "Enter a number", X — pesan permintaan adalah perintah OUTPUT terpisah.
• OUTPUT "Total: " + Total. 0478 menggabungkan item output dengan koma; + adalah aritmatika dan & termasuk A-Level 9618 (topik 11).
• Melupakan tanda kutip: OUTPUT Hello mencari variabel bernama Hello.

Lima operator aritmatika, sesuai urutan yang digunakan kalkulator.

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

Tanda kurung muncul pertama, lalu ^, kemudian * dan /, lalu + dan - — tingkat prioritas standar. Gunakan tanda kurung setiap kali pembaca harus berhenti dan berpikir.

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

Kesalahan umum

• Mengharapkan / menghasilkan bilangan bulat. 7 / 2 adalah 3.5, bukan 3; untuk bilangan bulat gunakan DIV.
• Menulis A x B atau A ÷ B. Gunakan * dan /.

Pembagian bilangan bulat menjawab dua pertanyaan berbeda, dan 0478 menuliskan masing-masing sebagai sebuah fungsi, dengan dua nilai dalam kurung.

• DIV(a, b) — berapa kali bilangan bulat b masuk ke dalam a, yaitu hasil bagi.
• MOD(a, b) — sisa yang tersisa, yaitu sisa hasil bagi.

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

Keduanya menerima bilangan bulat, dan keduanya mengembalikan bilangan bulat.

Kegunaannya

MOD adalah uji standar untuk habis dibagi, yang menjadikannya cara menanyakan apakah sebuah bilangan genap:

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

DIV mengonversi total menjadi satuan utuh — detik menjadi menit, sen menjadi pound:

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

Kesalahan umum

• 10 MOD 3. Itu adalah bentuk A-Level 9618; 0478 menggunakan bentuk fungsi MOD(10, 3).
• Mencampuradukkan keduanya. DIV memberikan bagian bulat; MOD memberikan sisa yang tidak muat.

Sebuah operator relasional membandingkan dua nilai dan menghasilkan TRUE atau FALSE.

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

Tiga operator logika menggabungkan kondisi:

• AND — kedua sisi harus TRUE.
• OR — setidaknya satu sisi harus TRUE.
• NOT — mengubah TRUE menjadi FALSE dan kembali.

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

Kesalahan umum

• <> adalah tanda tidak sama di sini — bukan !=, yang merupakan bagian dari bahasa pemrograman lain.
• IF Age >= 15 AND <= 18. Setiap sisi dari AND memerlukan perbandingan lengkapnya sendiri: Age >= 15 AND Age <= 18.
• Menyebut ini sebagai operator perbandingan dalam jawaban. Istilah dalam kurikulum adalah relasional.

0478 menerbitkan empat rutinitas string dan tidak ada lainnya. Tiga di antaranya ada di sini.

LENGTH(<identifier>) mengembalikan jumlah karakter yang disimpan sebuah string — termasuk spasi.

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

UCASE(<identifier>) mengembalikan string dalam huruf kapital, LCASE(<identifier>) dalam huruf kecil huruf kecil. Keduanya tidak mengubah asli — masing-masing mengembalikan nilai baru.

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

Baris terakhir tersebut tetap mencetak Happy: untuk menyimpan perubahan Anda harus assignsnya kembali.

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

Membandingkan tanpa khawatir tentang huruf besar/kecil

UCASE pada kedua sisi adalah cara standar untuk menerima jawaban bagaimanapun diketiknya:

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

Kesalahan umum

• Mengharapkan UCASE(Name) mengubah Name. Assign hasilnya kembali.
• LENGTH menghitung karakter, bukan kata. LENGTH("Happy Days") adalah 10.

SUBSTRING(<identifier>, <start>, <length>) mengambil sebagian dari string — mulai dari posisi start, mengambil length karakter.

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

⚠️ Penghitungan dimulai dari 1, bukan 0. Karakter pertama dari "Happy Days" berada di posisi 1.

Mengambil satu karakter, dan sisanya

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 di dalam SUBSTRING adalah alasan mengapa dua baris terakhir bekerja untuk kata berukuran apa pun — mengkode keras 8 akan merusak saat kata berubah.

Membaca string satu karakter pada satu waktu

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

Kesalahan umum

• Dimulai dari 0. Posisi 1 adalah karakter pertama.
• Membaca argumen ketiga sebagai posisi akhir. Itu adalah jumlah — SUBSTRING(W, 2, 3) mengambil tiga karakter dimulai dari yang kedua.
• Meminta lebih banyak karakter daripada yang dimiliki string.

Pemilihan menjalankan satu kelompok pernyataan atau kelompok lain, tergantung pada suatu kondisi.

IF <condition>
  THEN
    <statements>
ENDIF

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

Tambahkan ELSE untuk kasus lainnya. Tepat salah satu dari dua cabang berjalan — tidak pernah keduanya, tidak pernah tidak satupun.

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

Layout adalah bagian yang membuat siswa kehilangan poin, jadi pelajari sebagai bentuk:

• IF dan kondisinya pada satu baris, tidak ada apa pun setelah kondisi.
• THEN dan ELSE pada baris tersendiri, menjorok dua spasi.
• Pernyataan menjorok empat.
• ENDIF kembali ke kolom IF-nya.

Bersarang

Sebuah IF di dalam IF menangani lebih dari dua hasil. Masing-masing membutuhkan ENDIF-nya sendiri.

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

Kesalahan umum

• Melupakan ENDIF. Setiap IF ditutup, dan yang hilang adalah kesalahan sintaks yang penanda akan lihat seketika.
• IF Mark >= 50 THEN OUTPUT "Pass" pada satu baris. Tidak ada bentuk seperti itu dalam kurikulum mana pun; tulis tiga barisnya.
• IF Mark = 50 THEN ditulis sebagai IF Mark ← 50. Panah melakukan assign; = membandingkan.

Ketika satu variabel diuji terhadap beberapa nilai tunggal, CASE OF menyatakannya jauh lebih jelas daripada tumpukan IF yang bersarang.

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

• Setiap cabang adalah nilai, titik dua, lalu apa yang harus dilakukan.
• OTHERWISE menangkap semua yang dilewati oleh nilai yang terdaftar. Itu opsional, dan menulis satu adalah praktik baik — itu yang terjadi ketika pengguna mengetik sesuatu yang tidak terduga.
• Cabang yang cocok pertama kali berjalan, dan yang lainnya dilewati.

Rentang, dan karakter

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

Kesalahan umum

• Menggunakan CASE OF untuk kondisi. Ia menguji satu variabel terhadap nilai; Mark >= 50 membutuhkan IF.
• Melupakan ENDCASE.
• Melewatkan OTHERWISE dan kemudian bertanya-tanya mengapa nilai tak terduga tidak memberikan hasil apa pun.

Iterasi mengulang pernyataan. Gunakan loop FOR ketika Anda tahu sebelum memulai berapa kali — sebuah loop terkendali oleh hitungan.

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

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

Penghitung dimulai dari nilai pertama, dan loop berjalan sekali untuk setiap nilai hingga dan termasuk nilai kedua. 1 TO 5 berjalan lima kali.

STEP

STEP mengubah ukuran setiap lompatan. Step negatif menghitung mundur.

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

Total berjalan

Penggunaan paling umum: variabel di luar loop yang ditambahkan oleh loop tersebut.

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 harus berada sebelum loop. Di dalamnya, itu akan direset pada setiap lemparan.

Kesalahan umum

• NEXT menamai penghitung yang salah. Loop bersarang harus ditutup dengan urutan terbalik mereka dibuka: NEXT bagian dalam terlebih dahulu.
• Menganggap 1 TO 5 berjalan empat kali. Kedua ujungnya termasuk.
• Mengubah penghitung di dalam loop. Biarkan FOR memilikinya.

Loop WHILE menguji sebelum setiap lemparan, sehingga bisa berjalan nol kali. Gunakan jika jumlah pengulangan bergantung pada sesuatu yang terjadi saat loop berjalan.

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

Sesuatu di dalam loop harus akhirnya membuat kondisi menjadi false, atau loop tidak pernah berakhir — sebuah infinite loop (loop tak terhingga).

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

Kesalahan umum

• Lupa mengubah variabel yang diuji kondisinya, menyebabkan infinite loop.
• Melewatkan DO atau ENDWHILE.
• Menggunakan WHILE di mana hitungan diketahui. A FOR mengatakan maksud Anda dalam satu baris.

Loop REPEAT menguji setelah setiap lemparan, sehingga selalu berjalan setidaknya sekali.

REPEAT
    <statements>
UNTIL <condition>

Itu "setidaknya sekali" adalah alasan memilihnya: memvalidasi input, di mana Anda harus meminta sebelum Anda dapat menilai jawabannya.

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

⚠️ UNTIL menyatakan kondisi yang menghentikan loop; WHILE menyatakan satu yang membiarkannya terus berjalan. Mereka berlawanan, dan menukar keduanya adalah kesalahan klasik.

Kesalahan umum

• Menulis UNTIL Number < 100 padahal bermaksud UNTIL Number >= 100.
• Menggunakan REPEAT di mana tubuh harus mampu berjalan nol kali.
• Lupa bahwa UNTIL mengakhiri struktur — tidak ada ENDREPEAT.

Sebuah array menyimpan banyak nilai satu tipe di bawah satu nama. Setiap nilai duduk pada indeks.

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]

• Batas ditulis lower:upper, dan keduanya termasuk — [1:3] memiliki tiga elemen.
• Array Cambridge biasanya dimulai dari 1, bukan 0.
• Setiap elemen memiliki tipe yang sama, ditetapkan oleh OF.

Mengisi dan membaca dengan loop FOR

Array dan loop terhitung saling berkaitan: penghitung adalah indeks.

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

Menemukan nilai terbesar

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

Mulai Largest dari elemen pertama, jangan di 0 — dengan data negatif, 0 akan menang dan jawabannya akan salah.

Kesalahan umum

• Membaca Scores[6] dari array yang dideklarasikan [1:5]. Itu di luar batas.
• Menulis Scores(3). Array menggunakan kurung siku; kurung bulat memanggil fungsi.
• Mendeklarasikan [1:5] dan kemudian melakukan looping 0 TO 4.

A 2-D array adalah tabel: baris dan kolom, dua indeks.

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]

Indeks pertama adalah baris, yang kedua adalah kolom.

Loop bersarang menelusuri tabel

Satu loop per dimensi. Loop dalam menyelesaikan seluruh baris sebelum yang luar berlanjut.

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

⚠️ Loop dalam NEXT menutup penghitung dalam. NEXT Row sebelum NEXT Col melintasi loop dan tidak masuk akal — penanda mendeteksinya seketika.

Kesalahan umum

• Menukar baris dan kolom. Grid[2,3] adalah baris 2, kolom 3.
• Grid[Row][Col]. Cambridge menulis satu pasangan kurung dengan koma di dalamnya.
• Melintasi garis NEXT seperti di atas.

Sebuah procedure adalah blok pernyataan bernama. Menulisnya sekali dan memanggilnya dari beberapa tempat adalah dekomposisi — ide yang mendasari seluruh kertas 2.

PROCEDURE <identifier>
    <statements>
ENDPROCEDURE

Prosedur dipanggil dengan nama, dengan kata kunci CALL:

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

CALL DefaultLine
OUTPUT "Report"
CALL DefaultLine

• Definisi itu sendiri tidak melakukan apa-apa. Hanya CALL yang menjalankannya.
• Kontrol kembali ke baris setelah CALL ketika prosedur berakhir.
• Prosedur tidak mengembalikan nilai. Jika Anda membutuhkannya, Anda menginginkan fungsi.

Kesalahan umum

• Menulis DefaultLine sendirian untuk menjalankannya. 0478 memerlukan CALL.
• Melewatkan ENDPROCEDURE.
• Mengharapkan variabel milik prosedur itu ada di luarnya.

Sebuah fungsi adalah prosedur yang mengembalikan nilai. Ditulis di mana nilai dibutuhkan — di dalam OUTPUT, di sebelah kanan assignment, di dalam kondisi.

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> pada header mengatakan tipe apa yang kembali. Itu tidak opsional.
• RETURN mengakhiri fungsi langsung — tidak ada yang setelahnya berjalan.
• Fungsi tidak pernah dipanggil dengan CALL; digunakan di mana pun nilainya sesuai.

Fungsi di dalam kondisi

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

Kesalahan umum

• CALL SumSquare(10, 20) — yang membuang jawaban.
• Fungsi tanpa RETURN pada beberapa jalur. Setiap rute keluar harus mengembalikan nilai.
• Melewatkan RETURNS INTEGER dari header.

Sebuah parameter adalah nilai yang diberikan kepada prosedur atau fungsi saat dipanggil. Masing-masing membawa tipenya sendiri.

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

CALL Line(5)
CALL Line(20)

Beberapa parameter dipisahkan oleh koma, dan urutan pada pemanggilan harus sesuai dengan urutan di definisi:

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)

⚠️ Di 0478 setiap parameter diteruskan oleh nilai: prosedur bekerja pada salinan, jadi mengubahnya di dalam tidak mengubah apa pun di luar. Untuk mendapatkan nilai kembali, gunakan FUNCTION dan RETURN it. (A-Level 9618 menambahkan BYREF untuk perilaku lainnya — topik 11.)

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

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

Kesalahan umum

• PROCEDURE Line(Size) tanpa tipe.
• Memanggil dengan argumen dalam urutan yang salah — Greet(2, "Mei") adalah kesalahan tipe.
• Mengharapkan prosedur untuk mengubah variabel yang Anda berikan. Di 0478, hal itu tidak dapat dilakukan.

Sebuah file menyimpan data setelah program berakhir. 0478 menggunakan empat perintah, dan setiap satu dinamai file yang bekerja dengannya.

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"

Tiga mode file:

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"

• Satu WRITEFILE menulis satu baris.
• CLOSEFILE tidak opsional. File yang tidak ditutup dapat kehilangan data yang masih menunggu untuk ditulis, dan itu adalah jawaban ujian standar.

Kesalahan umum

• FOR WRITE ketika Anda bermaksud FOR APPEND, yang secara diam-diam menghancurkan isi lama.
• Melupakan CLOSEFILE.
• Membuka file yang sudah terbuka.

READFILE mengambil satu baris ke dalam variabel. Variabel harus dideklarasikan terlebih dahulu.

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

Biasanya Anda tidak tahu berapa banyak barisnya, jadi Anda membaca hingga akhir dari file — yang merupakan apa yang dilaporkan oleh fungsi 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") menjadi TRUE sekali setiap baris telah dibaca, sehingga WHILE NOT EOF(...) berarti selama masih ada sesuatu untuk dibaca.

Menghitung saat membaca

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

Kesalahan umum

• Perulangan WHILE EOF(...) — yang hanya berjalan ketika tidak ada lagi yang tersisa. Anda menginginkan NOT.
• Membaca melebihi akhir karena perulangan tidak memiliki pengaman EOF.
• Membuka FOR READ file yang belum pernah ditulis.

Cambridge menerbitkan dua spesifikasi pseudocode, dan mereka berbeda. Segalanya dalam topik 1-10 adalah IGCSE 0478. A-Level 9618 mengubah detail di bawah ini — dan seorang siswa yang mempelajari keduanya kehilangan nilai dengan menulis satu di kertas ujian yang lain.

Ini adalah bentuk 0478, dan ini berjalan di sini:

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

Bentuk 9618 dari algoritma yang sama ditulis seperti ini — perhatikan THEN pada IF baris, = di dalam CONSTANT, dan MOD di antara dua nilainya:

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

⚠️ Mana yang benar hanya bergantung pada kertas ujian mana yang Anda kerjakan. Tidak ada yang merupakan kesalahan; setiapnya merupakan kesalahan dalam ujian yang lain. Playground di halaman ini menjalankan aturan 0478, sehingga konstruk 9618 ditolak dengan pesan yang menyebutkan kurikulum yang dimilikinya — yang merupakan cara cepat untuk memeriksa kebiasaan Anda sendiri.

Kesalahan umum

• Menulis THEN pada IF baris dalam jawaban 0478, karena itulah yang ditunjukkan buku teks atau situs web. Ini adalah kesalahan lintas-kurikulum tunggal yang paling umum.
• 10 MOD 3 dalam 0478. Di sana itu adalah MOD(10, 3).
• ROUND(3.14159, 2) dalam jawaban 9618. 9618 tidak memiliki ROUND sama sekali.

0478 meneruskan setiap parameter berdasarkan nilai (topik 9). 9618 membiarkan Anda memilih, dan mengatakannya di bagian header.

• BYVAL — prosedur mendapatkan salinan. Mengubahnya tidak mengubah apa pun di luar. Ini adalah default ketika tidak ada kata yang ditulis.
• BYREF — prosedur bekerja pada variabel pemanggil sendiri, sehingga perubahan terlihat setelah panggilan.

Ini hanya 9618. Ini tidak berjalan di sini, dan tidak diterima dalam jawaban 0478:

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

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

Cara 0478 untuk mendapatkan nilai kembali

Gunakan FUNCTION dan tetapkan apa yang dikembalikan. Ini adalah keseluruhan jawaban 0478, dan ini berjalan:

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

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

Kesalahan umum

• Menulis BYREF dalam jawaban 0478. Kata kunci ini tidak ada dalam kurikulum tersebut.
• Mengharapkan parameter 9618 biasa berperilaku seperti BYREF. Tanpa kata itu, ia adalah BYVAL.

9618 memiliki struktur data yang tidak dimiliki 0478. Anda akan menemuinya hanya di A-Level, dan tidak satupun dari mereka berjalan di bawah aturan 0478 halaman ini.

Catatan record mengelompokkan medan dengan tipe berbeda di bawah satu nama (bagian 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

Sebuah tipe terenumerasi mencantumkan hanya nilai yang mungkin diambil oleh sebuah variabel:

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

9618 juga menambahkan tipe data DATE, file akses acak (OPENFILE … FOR RANDOM), pointer, dan kelas dengan CLASS … ENDCLASS untuk kertas berorientasi objeknya.

⚠️ 0478 memiliki lima tipe data dan array, dan tidak ada yang lain (topik 2). Jawaban 0478 yang mendeklarasikan record sedang menjawab kurikulum yang berbeda.

Kesalahan umum

• Menggunakan record dalam jawaban 0478. Gunakan array paralel sebagai gantinya — satu array per field, berbagi indeks.
• Berpikir TYPE berarti sama dengan DECLARE. TYPE mendefinisikan tipe baru; DECLARE membuat variabel dari yang sudah ada.