Casting and Range of Variables: Practice Questions (Computer Science A 1.5)

Answer: (C). Casting a double to an int truncates: the digits to the right of the decimal point are dropped.

• (A) rounds to the nearest integer, which a cast never does.
• (B) forgets that the cast gives an int, which prints without a decimal point.
• (D) ignores the cast altogether.

Answer: (D). In the first statement the cast applies to 9 alone, giving 9.0, so the division is 9.0 / 4 = 2.25. In the second, the brackets force 9 / 4 to be worked out first as integer division (2); the result is then converted to 2.0.

• (A) assumes both casts have the same effect, forgetting the effect of the brackets.
• (B) has the two results in the wrong order.
• (C) forgets that a double prints with a decimal point.

Answer: (B). x - 0.5 is -4.1 and truncating toward zero gives -4, the nearest integer to -3.6.

• (A) truncates to -3, which is not the nearest integer.
• (C) is the formula for non-negative numbers. Here it gives (int) (-3.1), which is -3.
• (D) is -3 + 1 = -2, which is further away.

Answer: (B). The sum is outside the range of int, so an integer overflow occurs. The result is an int within the allowed range: here it wraps around to the smallest value, Integer.MIN_VALUE.

• (A) is not a legal int; an int can never hold a value above Integer.MAX_VALUE.
• (C) is wrong: overflow does not throw an exception. ArithmeticException is for integer division by zero.
• (D) is wrong: the code compiles, and the overflow happens silently at run time.

Answer: (D). Values such as 0.1 and 0.2 cannot be stored exactly in a double, so the sum is rounded to the nearest representable value. That is a round-off error.

• (A) is the mathematically exact answer, which a double cannot always give.
• (B) is wrong because Java does not print trailing zeros in that style.
• (C) is wrong: adding two double values is perfectly legal.

Answer: (A). Inside the brackets, 7 / 2 is integer division: 3. The cast turns it into 3.0, and 3.0 * 2 is 6.0.

• (B) would result from (double) 7 / 2 * 2 (3.5 * 2), where the cast applies to 7 only.
• (C) and (D) are int values; r is a double, so it holds 6.0.

(a) double percent = 100.0 * correct / total; The 100.0 makes the arithmetic double from the start: 100.0 * 13 is 1300.0 and 1300.0 / 16 is 81.25.

(b) int rounded = (int) (100.0 * correct / total + 0.5); The value in brackets is 81.25 + 0.5 = 81.75, and truncating gives 81.

(c) correct / total is integer division: 13 / 16 is 0, then 0 * 100 is 0, and the value stored is 0.0. The fraction was thrown away before the multiplication.

Suggested Marlbridge rubric (5 marks):

(a) The true sum is 4,000,000,000. An int is stored in 4 bytes, so its largest value is Integer.MAX_VALUE, 2,147,483,647. The sum is larger, so it is out of range.

(b) Neither. The code compiles (both operands and the result are int values) and no exception is thrown at run time. An integer overflow occurs.

(c) No. The result is an int value in the allowed range but not the value expected. (For reference, it is -294967296, but you are not expected to calculate that by hand.) The program continues with a wrong value and gives no warning.

Suggested Marlbridge rubric (4 marks):

(a) sum / count is evaluated first, as integer division: 9 / 2 is 4. The cast then makes it 4.0. So avg holds 4.0, not 4.5. Fix: double avg = (double) sum / count; so the cast converts sum before the division, and avg holds 4.5.

(b) Integer division gives 4, and 4 is widened to 4.0 when stored. avg holds 4.0. Fix: double avg = (double) sum / count; (or sum / (double) count, or 1.0 * sum / count).

Suggested Marlbridge rubric (4 marks):

Suggested Marlbridge rubric (7 marks): one mark for each correct value (the values must be shown in the correct form: 3.5 and 3.0 with decimal points, the others without).