CC104 SUMMATIVE TEST

A program needs to store 25,000 integer values for temporary calculations, prioritizing memory efficiency over range. Which primitive data type would be most suitable for this array, and how much memory would it approximately consume?

• An 'int' array, consuming around 100 KB, offers sufficient range for calculations.

• A 'short' array, consuming approximately 50 KB, provides better memory efficiency.

• A 'long' array, consuming 200 KB, is ideal for comprehensive integer storage needs.

• A 'byte' array, consuming only 25 KB, is the most memory-efficient choice.

Consider a Java class with an instance variable `isProcessed` (boolean) and a local variable `counter` (int) initialized to 0. If `isProcessed` is not explicitly set in the constructor, what are their initial values when an object is created?

• `isProcessed` is `true`, and `counter` is `0` by explicit initialization.

• Both `isProcessed` and `counter` would be `0` or `false` by default values.

• `isProcessed` is `false`, and `counter` is `0` as explicitly set.

• `isProcessed` is `null`, and `counter` remains uninitialized.

Evaluate the output of the following Java code snippet: `int x = 15; int y = 10; if (x > y * 2) { System.out.print("Alpha"); } else if (x == y + 5) { System.out.print("Beta"); } else { System.out.print("Gamma"); }`

• The output will be "Alpha" because x is greater than y times two.

• The output will be "Beta" because x equals y plus five.

• The output will be "Gamma" as no conditions are met by the variables.

• The code contains a syntax error preventing any output from being generated.

A program uses a `switch` statement with an integer variable `code = 2`. The cases are `case 1: System.out.print("Red"); break; case 2: System.out.print("Green"); case 3: System.out.print("Blue"); break; default: System.out.print("Unknown");`. What will be the output?

• The program will output "Green" due to a direct match.

• The program will output "GreenBlue" because of fall-through behavior.

• The program will output "Unknown" as there is no specific break.

• The program encounters an error with multiple cases matching.

A system needs to determine a user's access level. If `age` is 18 or higher, access is "Full"; otherwise, it's "Limited". Which ternary operation correctly implements this logic for `String accessLevel`?

• `accessLevel = (age > 18) ? "Full" : "Limited";`

• `accessLevel = (age >= 18) ? "Full" : "Limited";`

• `accessLevel = "Full" ? (age >= 18) : "Limited";`

• `accessLevel = (age < 18) ? "Full" : "Limited";`

Consider a `for` loop: `for (int k = 1; k < 5; k++) { System.out.print(k + " "); }`. What will be the final sequence of numbers printed to the console?

• The loop will print '1 2 3 4 5' before stopping.

• The output will be '1 2 3 4' because the condition is exclusive.

• The loop will result in '0 1 2 3 4' if the initialization was zero.

• Only '5' will be printed as the final iteration value.

A `while` loop is defined as: `int count = 3; while (count > 0) { System.out.print(count + " "); count--; }`. How many times will "count" be printed, and what is the last value printed?

• It prints 4 times, with the last value being 0.

• It prints 3 times, and the last value displayed is 1.

• It prints 3 times, with the last value printed being 0.

• It prints indefinitely, causing an infinite loop error.

A `do-while` loop is given: `int x = 5; do { x--; System.out.print(x + " "); } while (x > 2);`. What sequence of numbers will be printed by this loop?

• The loop prints '5 4 3' sequentially before stopping.

• The output will be '4 3 2' since x is decremented first.

• The loop produces '5 4 3 2' with the condition checked after.

• Only '4 3' will be printed; the loop executes twice.

Given `boolean a = true; boolean b = false; boolean c = true;`, evaluate the expression `(a && b) || c`. What is the final boolean result?

• The expression evaluates to false, as 'a' AND 'b' is false.

• The expression evaluates to true, because 'a' AND 'b' OR 'c' is true.

• The expression results in a compilation error due to operator precedence.

• The outcome is false, as 'c' does not negate the initial false.

A developer needs to store precise monetary values. Considering the information provided, which Java primitive data type is explicitly discouraged for such use cases due to precision issues?

• The 'double' data type is generally the default choice for decimals.

• Both 'float' and 'double' are unsuitable for precise currency calculations.

• The 'long' data type offers a wide range for integral values.

• Only 'float' should be avoided; 'double' offers sufficient precision.