Implementing Selection and Iteration Algorithms: Practice Questions (Computer Science A 2.9)

Answer: (B). The loop adds the digits 5, 0, 3 and 7: 5 + 0 + 3 + 7 = 15.

• (A) is only the first (last) digit.
• (C) is the original number.
• (D) leaves out the digit 3, or confuses the digits.

Answer: (C). The divisors of 20 are 1, 2, 4, 5, 10 and 20: 6 values.

• (A) forgets 1 and 20 (or counts only the proper divisors 2, 4, 5, 10).
• (B) forgets one of the divisors, usually 20 itself.
• (D) counts every iteration of the loop.

Answer: (A). total = 2 + 4 + 6 + 8 = 20 and count = 4. Both are int, so 20 / 4 is the int 5, and 5 is printed.

• (B) would need a double result and would print 5.0. Here both operands are ints.
• (C) is the total, not the average.
• (D) is 10 / 4, using the wrong total.

Answer: (A). The digits of 253 are 3, 5 and 2, none of which is below 0, so the test n % 10 < smallest is never true and smallest stays 0, which is not a digit of 253. The right answer is 2.

• (B) 9 is at least as large as every digit, so the first digit 3 replaces it, then 2 replaces 3: the result is 2, correct.
• (C) 10 is larger than every digit, so the result is 2, correct.
• (D) Integer.MAX_VALUE is larger than every digit, so the result is 2, correct.

Answer: (A). The digits come off as 0, 5, 1, 2. rev becomes 0, then 5, then 51, then 512. The leading zero of the reversed number is lost.

• (B) shows a leading zero, which an int cannot hold.
• (C) is the reverse of 215, not 2150.
• (D) is the original number.

Answer: (B). term is reset to 0 on every pass and sum = term replaces the previous total, so after the last pass sum is just the last value of i.

• (A) is what a correct accumulation gives (sum = sum + i), but this code does not accumulate.
• (C) is the first value.
• (D) would need the loop not to run.

Model answer.

public static int countEvenDigits(int n) {
    int count = 0;
    while (n > 0) {
        int digit = n % 10;
        if (digit % 2 == 0) {
            count++;
        }
        n = n / 10;
    }
    return count;
}

For 40672 the digits are 2, 7, 6, 0, 4; the even ones are 2, 6, 0 and 4: 4.

Suggested Marlbridge rubric (6 marks).

(a) sum = 10 and count = 4, so sum / count is the int division 10 / 4 = 2, and the method returns 2.0. It should return 2.5.

(b) Both sum and count are int, so the division is integer division and the fractional part is discarded before the result is converted to double for the return.

(c) return (double) sum / count;

Suggested Marlbridge rubric (4 marks). 1 mark for each of: 2.0 returned; 2.5 expected; integer division identified as the fault; the cast placed on an operand (not around the whole quotient: (double) (sum / count) is still wrong).

Model answer.

public static int smallestDivisor(int n) {
    for (int d = 2; d < n; d++) {
        if (n % d == 0) {
            return d;
        }
    }
    return n;
}

smallestDivisor(35): 2 does not divide 35, 3 does not, 4 does not, 5 does, so 5. smallestDivisor(13): no value from 2 to 12 divides 13, so the loop ends and the method returns 13 itself, 13.

Suggested Marlbridge rubric (6 marks).

Accept a version with d <= n in the loop and no final return after it, provided every path returns.

(a) n increases on every pass, so each qualifying value is larger than the previous one. Overwriting best each time a number qualifies means that the last number to qualify, which is also the largest, is the one left in best. The loop only needs to remember the most recent qualifying value.

(b)

(c) The loop ends after n = 98 (the next multiple, 105, is not less than 100): 98 has digit sum 17 (odd), so best stays 91. The program prints 91.

Suggested Marlbridge rubric (7 marks). 2 marks for (a) (ascending order, last qualifying value kept); 4 marks for (b) (1 per correct row of digit sum and decision, with the unchanged rows for 63 and 70 counting as one mark together); 1 mark for 91.