Computer Science — Chapter-Wise Constructed Response Questions (CRQs)

• 1 mark for correct binary addition in part i ($10001011_2$).
• 1 mark for correct binary subtraction in part ii ($0011000_2$ or $11000_2$).
• 1 mark for correct binary multiplication in part iii ($11100001_2$).

  Carry:   1 1 1 1 0 0 0
           1 0 1 0 1 1 0_2   (86_10)
         + 0 1 1 0 1 0 1_2   (53_10)
         -----------------
         1 0 0 0 1 0 1 1_2   (139_10)

           1 1 1 0 0 1 1_2   (115_10)
         - 1 0 1 1 0 1 1_2   ( 91_10)
         -----------------
           0 0 1 1 0 0 0_2   ( 24_10)

               1 0 1 1 0 1_2   (45_10)
             x       1 0 1_2   ( 5_10)
             ---------------
               1 0 1 1 0 1
             0 0 0 0 0 0 x
         + 1 0 1 1 0 1 x x
         -------------------
           1 1 1 0 0 0 0 1_2   (225_10)

Examiner Commentary (Better Responses): Follow the reference model solution and step-by-step marking criteria.

• i. 1 mark for correctly writing a logical expression (X = AB + C').
• ii. 4 marks for correctly filling the truth table (1 mark will be given to fill two possible outputs).
• Note: round off marks to the nearest whole number.

Examiner Commentary (Better Responses): In better responses, candidates accurately wrote the correct logical expression (X = AB + C'). They correctly identified the logic gates and combined the variables with logic gate symbols given in the circuit diagram. Also, they correctly applied the method that solved the truth table and determined the correct output of the truth table across all eight possible input combinations.

Authentic E-Marking Better Candidate Script:

• Part i (3 Marks): 1 mark for NOT gates on A and B ($\overline{A}, \overline{B}$); 1 mark for the three OR gates representing $(A + \overline{B})$, $(\overline{A} + \overline{B})$, and $(A + B)$ (or equivalent Sum-of-Products gates); 1 mark for combining them with an AND gate to output $X$.
• Part ii (2 Marks): 0.5 mark for each correct row of the 4-row truth table (including intermediate working columns).

Examiner Commentary (Better Responses): In better responses, candidates represented 'sends value 0' using NOT gates, connected the three two-input gates into a final combining gate, and showed complete intermediate columns in the Working Space of the truth table.

• i. 1 mark for correctly placing NOT gates; 1 mark for correctly placing OR gates; 1 mark for correctly placing any AND gates.
• ii. 1 mark for writing either both pairs of working space and value of X for TWO or attempting either working space or value of X for any TWO values; 1 mark will be awarded if only the values of X are written or only the working is shown.

Examiner Commentary (Better Responses): In better responses, the candidates accurately depicted the symbols of gates, ensuring their correct representation. Moreover, the candidates effectively demonstrated the working of the truth table, providing step-by-step calculations to arrive at the correct output (X = 1, 0, 1, 1).

Authentic E-Marking Better Candidate Script:

• 1 mark for correct column NOT A.
• 1 mark for correct column B . C.
• 1 mark for correct final column X = NOT A + (B . C).

Examiner Commentary (Better Responses): Better responses showed good understanding of various Boolean operations and evaluated the Boolean expressions in the table correctly.

Authentic E-Marking Better Candidate Script:

• 1 mark for column A + B.
• 1 mark for column NOT(A + B).
• 1 mark for column X = NOT(A + B) . C.

Examiner Commentary (Better Responses): Better responses demonstrated a very good understanding of the Boolean operations (complement, AND, OR), applied these operations on given variables and completed the table correctly.

Authentic E-Marking Better Candidate Script:

• 1 mark for column NOT A.
• 1 mark for column B . C.
• 1 mark for column X = NOT A + (B . C).

Examiner Commentary (Better Responses): Better responses demonstrated very good understanding of the Boolean operations (complement, AND, OR), performed them and completed the table correctly.

Authentic E-Marking Better Candidate Script:

• 1 mark for Start/Stop steps and loop initialisation (i = 1 to 10).
• 1 mark for printing/outputting i inside the For loop body.
• 1 mark for proper loop termination (EndFor / Next i).

Step 1: Start
Step 2: For i = 1 to 10 do
          Output i
        EndFor
Step 3: Stop

Examiner Commentary (Better Responses): Follow the reference model solution and step-by-step marking criteria.

• 1 mark for each correct identification of name and symbol (TWO required).
• 1 mark will be awarded if only names are written.
• 1 mark will be awarded if only symbols are drawn.

Examiner Commentary (Better Responses): In better responses, candidates accurately identified and placed the correct names and corresponding symbols by using the descriptions. For example, in the description 'All the decisions appear inside this symbol', candidates wrote the name decision box and drew a diamond symbol in their respective columns. Similarly, in the description 'it is used to represent input and output in a flowchart' candidates wrote the name input/ output box and drew a parallelogram symbol in their respective columns. These candidates showed familiarity with standard diagram conventions and applied their knowledge effectively.

Authentic E-Marking Better Candidate Script:

• 0.5 mark for each correctly matched/drawn flowchart symbol (4 × 0.5 = 2 Marks).

Examiner Commentary (Better Responses): In better responses, candidates accurately drew or identified the Rectangle for A (calculations/processing), the Flowline Arrow for B (connecting symbols), the Parallelogram for C (input/output), and the Circle for D (on-page connector).

• 1 mark for each correct identification of name and symbol (TWO required).
• 1 mark will be awarded if only names are written.
• 1 mark will be awarded if only symbols are drawn.

Examiner Commentary (Better Responses): The candidates' responses to the flowchart question demonstrated an impressive understanding and proficiency in flowchart concepts. The symbols were accurately named ('Process' and 'Flow lines'), and their symbolic representations (Rectangle and Arrow lines) were aligned precisely with the given description.

Authentic E-Marking Better Candidate Script:

• 1 mark for Start and Stop oval symbols.
• 1 mark for initialising SUM = 0 and N = 0 in a process box.
• 1 mark for incrementing N = N + 1 and updating SUM = SUM + N in process boxes.
• 1 mark for decision diamond (Is N = 50?) with Yes/No branches looping back above N = N + 1.
• 1 mark for printing SUM in an output parallelogram.

      ( Start )
          |
          v
  +---------------+
  |   SUM = 0     |
  |    N = 0      |
  +---------------+
          |
          +<------------+
          |             |
          v             |
  +---------------+     |
  |   N = N + 1   |     |
  +---------------+     |
          |             |
          v             |
  +---------------+     |
  | SUM = SUM + N |     |
  +---------------+     |
          |             |
          v             |
        /   \           |
      /  Is   \   No    |
     < N = 50? >--------+
      \       /
        \   /
          | Yes
          v
    /-----------/
   / PRINT SUM /
  /-----------/
          |
          v
       ( Stop )

Examiner Commentary (Better Responses): Better responses applied the correct flowchart symbols along with correct statements to design the required flowchart for the given scenario. Moreover, these responses paid attention to the note written in the question and used the same variable names as given in the scenario. These responses also connected the Yes and No arrows coming from the decision box to the correct points to depict the loop.

Authentic E-Marking Better Candidate Script:

• 0.5 mark for each correctly placed statement number (10 × 0.5 = 5 marks).
• Note: The pair of statements 9 and 2 can be used in place of the pair of statements 8 and 5 and vice versa.

Examiner Commentary (Better Responses): Better responses demonstrated that candidates had a clear understanding of the purpose of each flowchart symbol and inserted the statement numbers inside the relevant symbols in the required order. The pair of statements 9 and 2 can be used in the place of the pair of statements 8 and 5 and vice versa.

Authentic E-Marking Better Candidate Script:

• 1 mark for Start and End oval symbols.
• 1 mark for initialising SUM = 0 and N = 0 in a process box.
• 1 mark for incrementing N = N + 1 and updating SUM = SUM + N in process boxes.
• 1 mark for decision diamond (If N = 50) with Yes/No branches looping back above N = N + 1.
• 1 mark for printing SUM in an output parallelogram.

      ( START )
          |
          v
  +---------------+
  |   SUM = 0     |
  |    N = 0      |
  +---------------+
          |
          +<------------+
          |             |
          v             |
  +---------------+     |
  |   N = N + 1   |     |
  +---------------+     |
          |             |
          v             |
  +---------------+     |
  | SUM = SUM + N |     |
  +---------------+     |
          |             |
          v             |
        /   \           |
      /  Is   \   No    |
     < N = 50? >--------+
      \       /
        \   /
          | Yes
          v
    /-----------/
   / Print SUM /
  /-----------/
          |
          v
       ( END )

Examiner Commentary (Better Responses): Better responses demonstrated that candidates had clear understanding of purpose of each flowchart symbol and used correct flowchart symbols along with statements for each step of the algorithm given in question. Moreover, these responses connected the flowchart symbols in the correct order.

Authentic E-Marking Better Candidate Script:

• 1 mark for reading the number using prompt().
• 1 mark for testing divisibility by 2 using if (num % 2 === 0).
• 1 mark for displaying 'Even' and 'Odd' in the if and else branches.

let num = Number(prompt("Enter a number:"));
if (num % 2 === 0) {
    document.write(num + " is an Even number.");
} else {
    document.write(num + " is an Odd number.");
}

Examiner Commentary (Better Responses): Follow the reference model solution and step-by-step marking criteria.

• 1 mark for valid JavaScript array declaration (const / let / var with bracket notation [...]).
• 1 mark for initialising elements of all four requested data types (number, string, boolean, and null).

const mixedArray = [25, "Computer Science", true, null];
document.write(mixedArray);

Examiner Commentary (Better Responses): Follow the reference model solution and step-by-step marking criteria.

• 1 mark for accurately describing program syntax.
• 1 mark for accurately describing program semantics.

Examiner Commentary (Better Responses): Follow the reference model solution and step-by-step marking criteria.

• Give ONE mark for writing each conclusion (THREE required).

if ((n1 > n2) && (n1 > n3))
{
    printf("%d is the largest", n1);
}
else if ((n2 > n1) && (n2 > n3))
{
    printf("%d is the largest", n2);
}
else
{
    printf("%d is the largest", n3);
}

if ((n1 > n2) && (n1 > n3)) {
    document.write(n1 + " is the largest");
} else if ((n2 > n1) && (n2 > n3)) {
    document.write(n2 + " is the largest");
} else {
    document.write(n3 + " is the largest");
}

Examiner Commentary (Better Responses): In better responses, candidates accurately compared all three numbers by using the if-else-if structure and printed the largest number. For example, 1st number with the other two numbers, similarly, 2nd number, and 3rd number with the other two numbers. Their code demonstrated a solid understanding of conditional logic, and the syntax was written precisely without any errors.

Authentic E-Marking Better Candidate Script:

• 1 mark for initialisation of counter variable.
• 1 mark for writing the correct condition using a do-while statement.
• 1 mark for writing the correct increment statement.
• Note: No mark deduction if the increment is done anywhere inside the body of the loop.

int i = 20;
do
{
    printf("\n%d", i);
    i += 5;
}
while (i < 50);

let i = 20;
do {
    document.write(i + "<br>");
    i += 5;
} while (i < 50);

Examiner Commentary (Better Responses): In better responses, candidates correctly applied the do-while structure to the given for loop code. They initialised the counter variable before the loop, placed the print and increment statements within the body of the do-while loop, and appropriately applied the loop condition outside the braces using the while( ) statement.

Authentic E-Marking Better Candidate Script:

• 1 mark for calculating the sum of the three angles (sum = a1 + a2 + a3;).
• 1 mark for writing the if condition checking whether sum == 180 (and printing that the triangle is valid).
• 1 mark for writing the else branch printing that the formation of the triangle is not possible.

sum = a1 + a2 + a3;
if (sum == 180 && a1 > 0 && a2 > 0 && a3 > 0)
{
    printf("Triangle formation is possible.\n");
}
else
{
    printf("Triangle formation is not possible.\n");
}

let sum = a1 + a2 + a3;
if (sum === 180 && a1 > 0 && a2 > 0 && a3 > 0) {
    document.write("Triangle formation is possible.");
} else {
    document.write("Triangle formation is not possible.");
}

Examiner Commentary (Better Responses): In better responses, candidates computed `sum = a1 + a2 + a3;`, used the relational equality operator `if (sum == 180)` (often additionally verifying positive angles), and printed clear messages in both the `if` and `else` blocks.

• 1 mark for correctly completing Iteration 1 (x = 14, y = 20, Output = 14).
• 1 mark for correctly completing Iteration 2 (x = 16, y = 20, Output = 16).
• 1 mark for correctly completing Iteration 3 (x = 18, y = 20, Output = 18) and showing x = 20, y = 20 where the loop terminates.

Examiner Commentary (Better Responses): In better responses, candidates respected the statement order inside the `while` loop (`printf` first, then `x += 2`), recording outputs `14`, `16`, and `18` while keeping `y = 20` constant, and stopping when `x` reached `20`.

• 1 mark for writing each correct condition (THREE required).

if ((n1 > n2) && (n1 > n3))
    printf("Largest number is: %d", n1);
else if ((n2 > n1) && (n2 > n3))
    printf("Largest number is: %d", n2);
else
    printf("Largest number is: %d", n3);

if ((n1 > n2) && (n1 > n3)) {
    document.write("Largest number is: " + n1);
} else if ((n2 > n1) && (n2 > n3)) {
    document.write("Largest number is: " + n2);
} else {
    document.write("Largest number is: " + n3);
}

Examiner Commentary (Better Responses): Such responses exhibited a high level of competence as the candidates skilfully utilised the if-else-if structure to determine the largest among three numbers. The logical operator used was appropriate in if statements, ensuring the desired output is achieved upon implementing this program.

Authentic E-Marking Better Candidate Script:

• 1 mark for writing correct value of n and output of each iteration (THREE required).
• No marks will be awarded if either n or output is missing.

Examiner Commentary (Better Responses): Some candidates' responses were exemplary as they efficiently populated the trace table with accurate values derived from executing the correct program. The calculated values in the 'n' column aligned precisely with the expected output (36, 33, 30, and terminating at 27).

Authentic E-Marking Better Candidate Script:

• 1 mark for inputting current (I) and voltage (V).
• 1 mark for calculating power using programming multiplication operator (P = I * V).
• 1 mark for outputting power (PRINT P).
• 0.5 mark for each correct evaluation (4 × 0.5 = 2 marks).

10 CLS
20 INPUT "Current: "; I
30 INPUT "Voltage: "; V
40 LET P = I * V
50 PRINT "Power = "; P
60 END

let I = parseFloat(prompt("Enter current (I):"));
let V = parseFloat(prompt("Enter voltage (V):"));
let P = I * V;
document.write("Power (P) = " + P);

Examiner Commentary (Better Responses): Part (a): Better responses demonstrated strong understanding of basic concepts of GW-BASIC programming. These responses wrote correct input and output statements and used * operator for multiplication in GW-BASIC statement to calculate power rather than using × as multiplication operator. Part (b): Better responses depicted strong understanding of almost all types of GW-BASIC operators and their evaluation in GW-BASIC statements, i.e. arithmetic operators, relational operators and logic operators.

Authentic E-Marking Better Candidate Script:

• 1 mark for tracing Z = 1, 2, 3 at Line 50.
• 1 mark for tracing X = 12, 24, 48 at Line 60.
• 1 mark for tracing Output = 12, 24, 48 at Line 70.
• 1 mark for tracing Y = 12, 24, 48 at Line 80.
• 1 mark for correctly rewriting the statement (IF-block executes when condition is true and ELSE-block executes when condition is false).

Examiner Commentary (Better Responses): Part (a): Better responses depicted that candidates interpreted the program correctly to complete the table. These responses calculated values of X, Y, Z and Output correctly with the help of GW-BASIC expressions given in the program and then wrote them in the correct line number of table. Part (b): Better responses depicted good theoretical understanding of IF...ELSE statement and wrote the correct statement after removing errors, i.e. an IF…ELSE statement executes IF-block statements when the condition is true and ELSE-block statements when the condition is false.

Authentic E-Marking Better Candidate Script:

• 1 mark for part (a): Numeric data type.
• 1 mark for part (b): Inputs 15 numbers and calculates/prints the square of each input number.
• 1 mark for part (c): 30 FOR X = 1 TO 22.
• 1 mark for part (d): 50 PRINT A(X) - 5.

  30 FOR X = 1 TO 22
  

  50 PRINT A(X) - 5
  

Examiner Commentary (Better Responses): (a) Better responses understood the question well and wrote the data type of array, i.e. numeric or number, rather than writing the type of array, i.e. one-dimensional or two-dimensional array. (b) Better responses revealed that candidates interpreted the program given in the question very well and wrote the correct purpose of the program, that it will calculate and print the square of input of values. (c) Better responses demonstrated good understanding of FOR…NEXT loop and wrote the correct syntax of this loop with correct initial and final values of counter variable. (d) Better responses understood and answered this part correctly by rewriting the code in line 50 that subtracted 5 from each value of array.

Authentic E-Marking Better Candidate Script:

• 1 mark for defining the function using DEF FNEQU(X, Y) = (2 * X) + (3 * Y) - 2.
• 1 mark for inputting two numeric values.
• 1 mark for calling FNEQU and printing the result.

10 CLS
20 DEF FNEQU(X, Y) = (2 * X) + (3 * Y) - 2
30 INPUT "Enter first value: "; A
40 INPUT "Enter second value: "; B
50 PRINT FNEQU(A, B)
60 END

Examiner Commentary (Better Responses): Better responses demonstrated good application skills of user-defined functions in GW-BASIC and wrote correct syntax for naming, writing expression and calling user-defined function to print the values.

Authentic E-Marking Better Candidate Script:

• 1 mark for inputting Principal Amount (P), Interest Rate (I/R), and Number of Years (Y/T).
• 1 mark for calculating Simple Interest S = (P * I * Y) / 100 using programming arithmetic operators (* and /).
• 1 mark for displaying Simple Interest in output.
• 2 marks for completing all 5 remaining relational operations and their programming symbols.

10 CLS
20 INPUT "Principal Amount = "; P
30 INPUT "Interest rate per year = "; I
40 INPUT "Number of years = "; Y
50 LET S = (P * I * Y) / 100
60 PRINT "Simple Interest is = "; S
70 END

let P = parseFloat(prompt("Enter Principal Amount:"));
let R = parseFloat(prompt("Enter Interest Rate per Year:"));
let T = parseFloat(prompt("Enter Number of Years:"));
let SI = (P * R * T) / 100;
document.write("Simple Interest is = " + SI);

Examiner Commentary (Better Responses): Part (a): Better responses depicted good understanding of basic concepts of GW-BASIC programming, i.e. input from the user, performed calculations on input by writing the formula in GW-BASIC and displayed output with an appropriate message. Part (b): Better responses wrote the correct names of relational operators and their symbols (`<>`, `>`, `<`, `>=`, `<=`).

Authentic E-Marking Better Candidate Script:

• 1 mark for initialising counter variable (e.g., A = 1) and incrementing it (A = A + 1).
• 1 mark for IF condition checking counter <= 10 and printing 'I LOVE PAKISTAN'.
• 1 mark for GOTO statement looping back to the IF line and terminating when counter > 10.

10 CLS
20 LET A = 1
30 IF A <= 10 THEN PRINT "I LOVE PAKISTAN" ELSE GOTO 60
40 A = A + 1
50 GOTO 30
60 END

for (let a = 1; a <= 10; a++) {
    document.write("I LOVE PAKISTAN<br>");
}

Examiner Commentary (Better Responses): Better responses demonstrated a good understanding of repetition via IF statement in GW-BASIC. These responses wrote the correct condition of the IF statement and used a counter variable to count the number of iterations and printed the statement given in the question.

Authentic E-Marking Better Candidate Script:

• 1 mark for part (a): One-dimensional array.
• 1 mark for part (b): It contains only one subscript/index per element (or has one column of values).
• 1 mark for part (c): 10 (or X$(10)).
• 1 mark for part (d): String data type because of the '$' sign attached to the array name X$ (or because it stores text/city names).

Examiner Commentary (Better Responses): Better responses showed good visual understanding of arrays and identified array as one-dimensional, gave the correct reason to identify the array, i.e. it has one column only / it has single subscript value. Similarly, these responses wrote 10 as an index number in part (c) which means they know that index number starts from 0. Likewise, they wrote a $ symbol to determine the data type of array as string.

Authentic E-Marking Better Candidate Script:

• 1 mark for defining the function: DEF FNCUBE(A) = A * A * A.
• 1 mark for inputting an integer value from the user.
• 1 mark for calling FNCUBE and printing the output.

10 CLS
20 DEF FNCUBE(A) = A * A * A
30 INPUT "Enter the number: "; N
40 PRINT FNCUBE(N)
50 END

Examiner Commentary (Better Responses): Better responses used the correct syntax to define the function named CUBE with an appropriate number of function parameters. Furthermore, these responses transformed the formula to calculate the cube in GW-BASIC instruction correctly and finally printed the value of cube function by calling the function with the PRINT keyword.

Authentic E-Marking Better Candidate Script:

• 1 mark for any one valid Logic Operator (AND, OR, NOT / &&, ||, !).
• 1 mark for any one valid Arithmetic Operator (+, -, *, /, MOD / %).
• 1 mark for any one valid Relational Operator (=, <>, <, >, <=, >= / ==, ===, !=, !==).
• 1 mark for placing X$ under Variable with String Data Type.
• 1 mark for placing Z% under Variable with Integer Data Type (excluding Y#, which is double-precision).

Examiner Commentary (Better Responses): Part (a): Better responses showed good knowledge of logic, arithmetic and relational operators and wrote the correct symbols for each type of operator. Part (b): Better responses identified X$ as string variable and Z% as integer variable which shows that candidates know the purpose of data type symbols with variable names.

Authentic E-Marking Better Candidate Script:

• 1 mark for part (a): Output A (5 asterisks).
• 4 marks for part (b): Initialising Count = 0, WHILE Count <= 4, PRINT "*", Count = Count + 1, and WEND.

10 CLS
20 LET Count = 0
30 WHILE Count <= 4
40 PRINT "*"
50 Count = Count + 1
60 WEND
70 END

let count = 0;
while (count <= 4) {
    document.write("*<br>");
    count++;
}

Examiner Commentary (Better Responses): Better responses selected A as output of the given program which means candidates had clear understanding that loop will iterate 5 times (starting from 0 and ending at 4). Moreover, these responses converted the given FOR loop program correctly into WHILE…WEND program and placed the programming statements in correct order.

Authentic E-Marking Better Candidate Script:

• 2 marks for part (a): 10 DIM N$(900) or 10 DIM N$(899) (string 1D array).
• 2 marks for part (b): 10 DIM A(30, 30) or (150, 6) / (15, 60) / (90, 10) / (36, 25) (numeric 2D array totaling 900 elements).

Examiner Commentary (Better Responses): Better responses declared arrays with proper name, correct data type and size of array, i.e. array size is 900 or 899 for one-dimensional array and array size is (30, 30), (150, 6), (15, 60), (90, 10), or (36, 25) in case of two-dimensional array.

Authentic E-Marking Better Candidate Script:

• 1 mark for Box 1 output: 115.46.
• 1 mark for Box 2 output: 5.
• 1 mark for Box 3 output: Kent.

Examiner Commentary (Better Responses): Better responses showed good understanding of the built-in functions 'ABS', 'SQR' and 'LEFT$' in GW-BASIC by writing the correct output (`115.46`, `5`, and `Kent`).

Authentic E-Marking Better Candidate Script: