Java and Python Programming Fundamentals Quiz

ArrayList uses ensureCapacity(int minCapacity) to request internal capacity expansion before adding elements. This is an optimization to avoid multiple internal array resizes. Option A's 'incSize' and option C's 'incCapicity' (misspelled) don't exist in the API.

The clone() method in ArrayList returns a shallow copy - the ArrayList object itself is new, but the elements are references to the same objects (not deep copies). It doesn't return a String, Array, or void.

ArrayList extends AbstractList, which is indeed an abstract class. This is a factual statement about Java's Collections hierarchy: ArrayList -> AbstractList -> AbstractCollection.

Python lists are mutable, meaning you can modify them after creation by appending, removing, or changing elements. This is different from tuples, which are immutable. You can change list elements using indexing (x[0] = 5), add elements with append() or extend(), or delete them with del or remove().

Multiplying a list by an integer repeats the list's contents that many times. [1] * 3 creates a new list with three copies of the original element: [1, 1, 1]. This is valid Python syntax and won't cause any errors. The list repetition operator is a convenient way to create lists with repeated elements.

The code initializes a list a and nests it inside list x. To access the first element of a through x, we use x[0] to get a, and then index 0 of that nested list, yielding x[0][0]. Since there are no syntax or runtime errors, the other options are incorrect.

In Python, negative indexing access elements from the end of the list. The index -1 retrieves the last element, which is 5. It does not produce an error or return a garbage value.

The substring method in Java extracts characters from index begin (inclusive) to end (exclusive). With s='Bicycle', begin=1, end=3, it extracts characters at positions 1 and 2, which are 'i' and 'c', resulting in 'ic'. Note that iEnd is char but gets promoted to int.

The code contains a compilation error - the paint() method signature is incorrect as it's missing proper parameters or doesn't override a valid method. Without seeing the actual method signature and body, the code cannot compile successfully.

Legal Java identifiers cannot start with a digit (A: 1alpha), cannot contain operators like + (C: xy+abc), cannot be keywords (D: transient is reserved), and cannot contain hyphens (E: account-num). Options B (_abcd) and F (very_long_name) are legal.

Due to short-circuit evaluation, the first expression (t && ((i++) == 0)) executes i++ making i=1. The second expression (f && ((i+=2) > 0)) short-circuits because f is false, so i+=2 never executes. Final i=1.

Virtual destructors are essential in C++ polymorphism. When you delete a derived class object through a base class pointer, a virtual destructor ensures the correct destructor chain is called (derived first, then base). Without virtual destructors, only the base class destructor executes, causing resource leaks and undefined behavior.

This is Java polymorphism in action. The interface reference 'mi' points to an object of class B. At runtime, the JVM calls the overridden show() method in class B, not the one in class A. This demonstrates dynamic method dispatch - the actual method executed depends on the object type, not the reference type.

The question is poorly worded and technically inaccurate. C++ provides exactly 4 special member functions by default: default constructor, copy constructor, copy assignment operator, and destructor. A 'destructor' is always supplied (not user-defined), but the question seems to confuse 'supplied with' with 'compiler-generated'. All four options are technically provided by the compiler, but 'Destructor' wording is misleading.

Due to binary floating-point representation, 2.00 - 1.10 does not equal 0.9 exactly. In binary, 0.1 cannot be represented precisely (it's a repeating fraction in binary). The actual result is 0.8999999999999999. Since none of the options A (0.9), B (0.90), or C (It varies - suggests randomness) are correct, the answer is D (None of the above).

This loop appears to count from (Integer.MAX_VALUE - 100) to Integer.MAX_VALUE, which should be 101 iterations. However, when i equals Integer.MAX_VALUE and we execute i++, it overflows to Integer.MIN_VALUE (most negative int). The condition i <= end is then always true (since MIN_VALUE <= MAX_VALUE), creating an infinite loop. The count will increase indefinitely.

The code fails to compile because the overriding method show() in subclass B has a more restrictive access modifier (protected) than the overridden public method in class A. Because of this compilation error, no output is produced, making 'None of the above' correct.

The first print uses string concatenation: "H" + "a" = "Ha". The second print involves character arithmetic: 'H' + 'a' promotes chars to int, resulting in 72 + 97 = 169. The output is "Ha169" (or "Ha" followed by 169). Since this exact output isn't listed, the answer is "None of the above".