Exam tips 2026-08-16 8 min read

10 Common Mistakes in HKDSE ICT Paper 1 (and How to Fix Them)

After grading hundreds of HKDSE ICT papers, the same mistakes destroy scores year after year. These aren’t gaps in knowledge — they’re avoidable errors that students repeat even after studying the syllabus.

The pattern is brutal: you know the concept, but you lose 2-3 marks per mistake. Over 40 MC questions and structured questions, that’s the difference between Level 4 and Level 5.

Here are the 10 most common Paper 1 mistakes, why they cost marks, and exactly how to fix each one.

Mistake 1: Confusing validation with verification

The mistake: You mix up validation (checking data reasonableness) with verification (checking data accuracy). When asked for examples of each, you swap them.

Why it costs marks: This is a core HA1 Information Processing concept. Questions often ask: “State one validation method AND one verification method.” If you swap them, you earn 0 marks — even if you correctly described both methods. The examiner tests whether you understand the distinction, not just whether you can list techniques.

The fix: Learn this hierarchy:

Validation checks whether data is reasonable: type check, range check, presence check, length check, format check, check digit. Examples: “Is age between 1-120?” (range), “Does phone number have 8 digits?” (length), “Does HKID match the check digit algorithm?” (check digit).
Verification checks whether data is accurate: double entry, visual check, proofreading, cross-referencing with source documents. Examples: “Confirm phone number via SMS,” “Compare data to original form.”

Memory trick: Validation = “Is this data reasonable?” Verification = “Is this data accurate?” The validation question is about the data itself; verification requires comparing to an external source.

Mistake 2: Two’s complement ordering errors

The mistake: When converting decimal to two’s complement binary, you write bits in the wrong order. For example, for -5 in 4-bit two’s complement, you write “0101” instead of “1011” — you got the magnitude right but the bit sequence backwards.

Why it costs marks: This appeared in DSE 2015 Paper 1 Q2, and similar patterns recur. MC questions often show 4-bit two’s complement numbers in the wrong order to test whether you understand the positional weighting. Structured questions ask you to convert decimal to binary — if your bit order is wrong, the entire answer earns 0 marks.

The fix: Practise 4-bit two’s complement until it’s automatic:

Start with the positive binary representation. For +5: 0101
Invert all bits (one’s complement): 1010
Add 1 to get two’s complement: 1011

Position check: In a 4-bit two’s complement number, the leftmost bit is the sign bit (-8), then positions represent -4, -2, -1. So “1011” = -8 + 0 + 2 + 1 = -5. Always verify by positional weighting before finalizing your answer.

Mistake 3: Forgetting to round up in minimum-storage-size questions

The mistake: You calculate file size correctly but forget to round up to whole bytes. For example, you calculate that 13 RFID tags need 156 bits, conclude that’s “19.5 bytes,” and write “19.5 bytes” as your answer.

Why it costs marks: Storage devices allocate whole bytes, not fractions. If you answer “19.5 bytes,” you earn 0 marks. This pattern appears regularly in questions about RFID tags, smart cards, and storage sizing (similar to DSE 2015 Paper 1 Q5).

The fix: Always round UP to the next whole byte:

Calculate total bits: 13 tags × 12 bits/tag = 156 bits
Convert to bytes: 156 ÷ 8 = 19.5 bytes
Round UP: 20 bytes (you need a whole 20th byte for the remaining 4 bits)

Memory rule: “Partial bytes don’t exist in storage.” Round up before writing your final answer. Show the rounding step in your working — examiners award method marks.

Mistake 4: Assuming ASCII stores Chinese characters

The mistake: You claim that “ASCII can represent Chinese characters” or that “8-bit ASCII is sufficient for multilingual text.”

Why it costs marks: This is a factual error. ASCII is a 7-bit or 8-bit encoding designed for English characters (128 or 256 characters). It cannot represent Chinese, Japanese, Korean, or other CJK characters. Questions about character encoding appear regularly in HA1 — claiming ASCII works for Chinese earns 0 marks because it contradicts the syllabus.

The fix: Learn the encoding landscape:

ASCII (7-bit or 8-bit): English alphabet, numbers, symbols. Maximum 256 characters (extended ASCII). Cannot store Chinese, Japanese, Korean.
Unicode (16-bit or more): Universal character set supporting all world languages, including Chinese, Japanese, Korean, emoji. Each character has a unique code point. UTF-8, UTF-16, and UTF-32 are implementations.

Answer pattern: If asked about storing Chinese characters, specify “Unicode” or “UTF-8” — never ASCII. If asked why ASCII is insufficient, explain: “ASCII uses 7/8 bits, limiting it to 256 characters, which is inadequate for the thousands of Chinese characters.”

Mistake 5: Confusing CPU components (CU, ALU, registers)

The mistake: You mix up what the Control Unit (CU), Arithmetic Logic Unit (ALU), and registers do. For example: “The ALU fetches instructions from memory” (that’s the CU’s job) or “Registers perform calculations” (that’s the ALU’s job).

Why it costs marks: This is HB1 Computer System Fundamentals — a high-frequency topic. Questions like DSE 2015 Paper 1 Q13 ask which component performs which function. If you attribute the fetch-decode-execute cycle to the wrong component, you lose the full marks for that question (often 2-3 marks).

The fix: Learn the CPU division of labour:

Control Unit (CU): Fetches instructions from memory, decodes them, directs data flow between CPU components. It’s the “orchestra conductor” — coordinates everything but doesn’t process data itself.
Arithmetic Logic Unit (ALU): Performs arithmetic operations (add, subtract, multiply, divide) and logical operations (AND, OR, NOT, comparisons). It’s the “calculator” — executes the actual computations.
Registers: Small, fast storage locations within the CPU that hold data currently being processed. Examples: accumulator (stores results), program counter (holds address of next instruction), instruction register (holds current instruction being decoded).

Memory trick: CU = “Controller,” ALU = “Calculator,” Registers = “Storage.” When asked “which component executes instructions,” the answer is ALU (with CU direction). When asked “which component fetches instructions,” the answer is CU.

Mistake 6: Mixing up WHERE and HAVING in SQL

The mistake: You write WHERE after GROUP BY, or use HAVING without GROUP BY. For example: “SELECT department, COUNT() FROM employees GROUP BY department WHERE COUNT() > 5” — WHERE comes after GROUP BY, which is invalid syntax.

Why it costs marks: This is database fundamentals, tested in Paper 1 and essential for Paper 2A Databases. SQL clause order is strict — one wrong position = 0 marks for the entire question. This is one of the most common 2-3 mark deductions in structured questions.

The fix: Memorize the SQL clause order:

SELECT column(s)
FROM table
WHERE condition           -- Filters rows BEFORE grouping
GROUP BY column(s)        -- Groups rows
HAVING condition          -- Filters groups AFTER grouping
ORDER BY column(s)        -- Sorts results

Usage rule: WHERE filters individual rows; HAVING filters groups. Use WHERE for row-level conditions (e.g., “salary > 50000”). Use HAVING for group-level conditions (e.g., “COUNT(*) > 5” after GROUP BY).

Quick check: If your condition involves an aggregate function (COUNT, SUM, AVG, MAX, MIN), it belongs in HAVING. If it doesn’t, it belongs in WHERE. Never mix the order.

Mistake 7: Trace-table errors with dequeue/pop

The mistake: When tracing queue or stack operations, you record the wrong value after dequeue or pop. For example, after dequeue() on a queue containing [1, 2, 3], you record “1” removed but then show the queue as [2, 3] — correct so far — but when asked “what value was returned,” you write “3” instead of “1.”

Why it costs marks: Trace tables test whether you understand data structure conventions. Queue (FIFO) and stack (LIFO) questions require precise tracking of values. If you record the wrong returned value, you lose marks for the entire trace (often 3-4 marks) because every subsequent step depends on the correct previous state.

The fix: Learn the return convention:

Queue (FIFO): dequeue() removes and returns the FRONT (oldest) element. After enqueue(1), enqueue(2), enqueue(3), then dequeue() returns 1 and leaves [2, 3].
Stack (LIFO): pop() removes and returns the TOP (most recent) element. After push(1), push(2), push(3), then pop() returns 3 and leaves [1, 2].

Memory rule: Queue = “First In, First Out” — the oldest item leaves first. Stack = “Last In, First Out” — the newest item leaves first. When tracing, always write: “Operation | Returned value | New state.”

Verification: After each dequeue or pop, ask: “Which element just left the structure?” That’s the returned value. Never assume it’s the last element you visually saw — it depends on FIFO vs LIFO.

Mistake 8: Ignoring the command word’s depth

The mistake: You write a State-style answer (bare fact) when the question said Explain or Justify. For example, a 3-mark “Explain why parity checking cannot detect all transmission errors” question gets: “Parity checking can only detect an odd number of bit flips.” That’s 1 mark — you missed 2 marks by not showing the reasoning chain.

Why it costs marks: Command words signal required depth. Under-answering is the most consistent mark-killer across Paper 1 and Paper 2. You lose 1-2 marks per structured question when you ignore the depth requirement. Over 10 questions, that’s 10-20 marks gone.

The fix: Match your answer length to the command word:

State (1 mark): 1-2 words or a short phrase. Example: “State one advantage of fibre optics.” → “Higher bandwidth.”
Define (1-2 marks): 1 sentence. Example: “Define authentication.” → “Authentication is the process of verifying the identity of a user or system.”
Describe (2 marks): 2-3 sentences, features without cause-effect. Example: “Describe router function.” → “A router forwards data packets between networks. It determines the best path using routing tables and connects different network segments.”
Explain (2-3 marks): 3-4 sentences with “because” chain. Example: “Explain why parity fails.” → “Parity checks only detect an odd number of bit flips. If an even number of bits change, the parity bit remains correct and the error goes undetected. This makes parity checking unreliable for burst errors.”
Justify (2-3 marks): 3-4 sentences, multiple reasons supporting a claim. Example: “Justify P2P over client-server.” → “First, P2P reduces server costs since all nodes share resources. Second, it improves reliability because the system continues if some nodes fail. Third, it scales naturally as more users join.”

Quick check: If the command word is Explain or Justify, your answer MUST include causal language (“because,” “due to,” “leads to,” “results in”). For State, keep it to a fact. For Describe, list features without “because.”

Mistake 9: Leaving MC questions blank

The mistake: You skip multiple-choice questions when unsure, leaving them blank.

Why it costs marks: Paper 1 has NO penalty for wrong answers. If you guess, you have a 25% chance (1 in 4 options) of earning 1 mark. If you leave it blank, you have 0% chance. Over 40 MC questions, skipping 5 questions = throwing away ~1-2 free marks on average.

The fix: Never leave blanks. Follow this process:

Eliminate obviously wrong options — cross out choices with absolute qualifiers (“never,” “always”) or factual errors.
Guess from the remainder — if you eliminated 2 options, your guess is now 50% likely to be correct.
Mark and move on — if you’re stuck after 2 minutes, pick your best guess and move forward. Return later if time permits.

Time management: 40 MC questions in ~60 minutes = 1.5 minutes per question average. Spending 4+ minutes on one MC question = running out of time for later questions. Mark it, move on, return later.

Probability reality: Even if you’re purely guessing, expected value is positive. 25% of 1 mark = 0.25 marks per question. Over 10 pure guesses, you earn 2.5 marks on average. That’s often the margin between grades.

Mistake 10: Writing paragraphs instead of numbered points

The mistake: For structured questions asking “Give three reasons” or “State two advantages,” you write one long paragraph burying all points together. The marker has to hunt for your answers, often missing points you actually included.

Why it costs marks: Examiners mark point-by-point. If your three reasons are buried in a paragraph, the marker might miss one — even if you wrote it. You lose 1 mark per missed point. Over a 3-mark question, that’s 33% gone not because you didn’t know the answer, but because you hid it.

The fix: Always use numbered or bulleted lists for multi-point answers:

Instead of:

“P2P networks reduce server costs because all nodes share resources, they improve reliability because the system continues if some nodes fail, and they scale naturally as more users join and contribute resources.”

Write:

Reduces server costs — all nodes share resources.

Improves reliability — system continues if some nodes fail.

Scales naturally — more users = more resources.

Formatting rule: One distinct point per number/bullet. Start each point with the core concept, then add a brief explanation if the command word is Explain or Justify. For State or Describe, a single phrase or sentence per point is enough.

Marker psychology: Examiners grade hundreds of papers. Clear, numbered lists make their job easier and ensure you earn full marks for every point you made. Paragraphs invite ambiguity — lists earn clarity.

Where this fits in your prep

These 10 mistakes aren’t isolated — they compound. If you confuse validation/verification (Mistake 1), ignore command words (Mistake 8), and bury answers in paragraphs (Mistake 10), you can lose 5-7 marks on a single question despite understanding the concept.

The fix isn’t just knowing these mistakes — it’s practising until the correct approach becomes automatic. Use past papers to build an error log: track which mistake patterns repeat for you. Target your practice on those specific patterns.

For deeper dive on command words, see our command words guide. For SQL fundamentals, see our SQL survival guide. For comprehensive topic coverage, use our HKDSE ICT notes.

Ready to stop losing marks to avoidable mistakes? Book a trial lesson — we’ll review your past-paper answers, identify your mistake patterns, and build a targeted practice plan.

← All articles