Programming Output Evaluation

In C, function arguments are evaluated from right to left in many compilers (like GCC). Evaluating x=x>>2 first shifts 5 right by 2, making x equal to 1. Then x<<2 evaluates to 4, and the final x is 1, resulting in '1 4 1'.

The assignment a=1 sets a to 1 and returns 1, which is truthy. The ternary operator ? therefore evaluates to 2, assigned to b. printf outputs '1 2'. Option A (1 3) would be the result if the assignment returned 0 (falsey).

Tracing the pointers: abc.next points to def, def.next points to ghi, ghi.prev points back to def, def.next points to ghi, and ghi.i equals 2. The entire expression evaluates to 2. Option A (1) would be def.i, and Option C (3) would be jkl.i.

The function sets the register variable _AX to 1000. In many C compilers (especially older ones like Turbo C), return values are passed through the _AX register. When abc() is called, it sets _AX=1000, and main retrieves this as the return value i.

In C++, new int(87) allocates memory for a single int and initializes it to 87. The pointer p points to this allocated int containing value 87. Option D would require new int[87](array syntax).

The for loop runs from 1 to 4. continue skips remaining code in the current iteration, but since it's at the end of the loop body, it has no effect. Each iteration prints its number: 1, 2, 3, 4 → output: 1234.

Float 0.7 is stored as 0.699999... due to binary representation. Literal 0.7 in the if condition becomes double (more precise). Comparison: 0.699999 < 0.700000 → true, so c++ prints. This demonstrates floating-point precision issues.

char * const ptr means ptr is const (can't change what it points to). Trying to reassign ptr = xyz is illegal - compile error. The pointer itself is locked even though the data it points to isn't.

const char *ptr means the data is const (can't change what ptr points to), but ptr itself can be reassigned. ptr = xyz works because we're changing where ptr points, not modifying abc. Output: xyz.

In C, local variables (including those declared with the register storage class) are not automatically initialized. Reading an uninitialized local variable results in undefined behavior, which typically prints whatever garbage value happens to be in that register or memory location.

Java does not allow static variables to be declared inside methods - static variables must be class members. The code 'static int i;' inside amethod() is illegal syntax. This is a compile-time error regardless of initialization.

Option D (int z = 015) is correct - 015 is octal notation for decimal 13. Options A and C are wrong because 'S' and 'c' are not valid suffixes for numeric literals. Option B is wrong because single quotes denote char literals, not String literals.

The output is 1. Tracing: l starts at 0, k = l++ means k gets 0 then l becomes 1. j = ++k means k increments to 1 then j gets 1. i = j++ means i gets 1 then j becomes 2. System.out.println(i) outputs 1.

In Python, names starting with double underscore are name-mangled. foo becomes _Afoo internally. Attempting to call a.__foo() from outside the class raises an AttributeError because the method name doesn't exist as written.

Since 'a' is a compile-time constant (final int), 'x' is also a compile-time constant with a value of 10. The compiler allows assigning 'x' directly to byte 'b' without an explicit cast because its value fits within the range of a byte.