Question 1

In C expression evaluation, consider the statement: a = f1(23, 14) * f2(12/4) + f3(); What is the guaranteed order in which the three function calls f1, f2, and f3 are executed?

Accepted Answer

Introduction / Context: Understanding evaluation order in C is critical when expressions contain multiple function calls with potential side effects. Many learners assume that operator precedence dictates evaluation order, but in C precedence only determines grouping, not sequencing. This question tests knowledge of sequence points and unspecified order of evaluation for subexpressions. Given Data / Assumptions: Expression: a = f1(23, 14) * f2(12/4) + f3(); Each function may have side effects and their relative execution order matters. No sequence-point operators (such as &&, ||, or ,) force a particular ordering between these three top-level calls. Concept / Approach: Operator precedence and associativity determine how an expression is parsed, not the runtime order in which operands are evaluated. In C, the operands of + and * may be evaluated in any order. Therefore, the calls to f1(...), f2(...), and f3()—which are operands of + and *—have unspecified relative order. A conforming compiler may choose any order, and different optimization levels may produce different valid orders. Step-by-Step Solution: Parse the expression based on precedence: (f1(...) * f2(...)) + f3().Recognize that parsing does not impose evaluation sequence.Recall: C leaves the evaluation order of subexpressions of + and * unspecified.Conclude that compilers may call f1, f2, and f3 in any order before performing the arithmetic and assignment. Verification / Alternative check: Insert logging side effects in f1/f2/f3 and compile with different compilers or flags; you will observe differing call sequences while still producing a conforming executable. Why Other Options Are Wrong: f1, f2, f3 and f3, f2, f1: Both assert a fixed order that the C standard does not guarantee. None of above: Incorrect because the standard explicitly allows the order to vary. Common Pitfalls: Assuming precedence equals evaluation order; writing expressions that rely on a particular call order; mixing side effects without sequence guarantees. Final Answer: Order may vary from compiler to compiler.

Question 2

Unary operators in C language: from the list 1) ! 2) sizeof 3) ~ 4) &&, which subset consists only of unary operators?

Accepted Answer

Introduction / Context: Operator arity (unary, binary, or ternary) determines how many operands an operator uses. This is essential when reasoning about expressions, precedence, and the effects on operands. The question asks you to identify which listed operators are strictly unary in C. Given Data / Assumptions: Operators provided: ! (logical NOT), sizeof (compile-time size), ~ (bitwise NOT), && (logical AND). Standard C semantics apply. Concept / Approach: Unary operators take one operand. In C, !, sizeof, and ~ each operate on a single operand: !a flips truthiness, sizeof(T or expr) yields a size, and ~a flips all bits. By contrast, && is a binary logical operator that requires two operands and short-circuits based on the left operand. Step-by-Step Solution: Identify each operator's arity.Group the unary ones: !, sizeof, ~.Exclude && because it requires two operands.Therefore, the correct subset is 1, 2, 3. Verification / Alternative check: Compile sample expressions like !x, sizeof x, ~x, and x && y; observe that only the last demands two operands. Why Other Options Are Wrong: 1, 2 and 1, 3 omit one valid unary operator. 2, 4 incorrectly includes a binary operator. Common Pitfalls: Confusing bitwise NOT (~) with logical NOT (!); forgetting that sizeof is an operator, not a function. Final Answer: 1, 2, 3.

Question 3

C operator precedence and associativity: determine the evaluation order by operator for z = x + y * z / 4 % 2 - 1 (from highest to lowest, left-to-right where applicable).

Accepted Answer

Introduction / Context: Mastering operator precedence and associativity in C prevents subtle bugs and clarifies how compound expressions are parsed. This problem asks you to list operators in the order they are applied to parse the expression, respecting associativity among operators of the same precedence. Given Data / Assumptions: Expression: z = x + y * z / 4 % 2 - 1. All operands are arithmetic types; default C precedence rules apply. We are listing operator categories by precedence, not forcing runtime evaluation sequence of operands. Concept / Approach: In C, the multiplicative operators * , / , % share the same precedence and associate left to right. Additive operators + and - come next, also left to right. Finally, the assignment operator = has lower precedence, evaluated after the right-hand side expression is formed. Step-by-Step Solution: First group multiplicative: compute y * z, then (result) / 4, then (result) % 2.Next apply addition: x + (multiplicative result).Then apply subtraction: (previous result) - 1.Finally assign to z using = after the right-hand side is fully determined. Verification / Alternative check: Parenthesize according to precedence: z = ((x + (((y * z) / 4) % 2)) - 1); This matches * / % + - before =. Why Other Options Are Wrong: = * / % + - places assignment too early. / * % - + = swaps order within the multiplicative group and places - before +. * % / - + = misorders / and %. Common Pitfalls: Confusing precedence with operand evaluation order; forgetting left-to-right associativity within precedence groups. Final Answer: * / % + - =.

Question 4

Hierarchy of arithmetic operations in C: which option correctly places the higher-precedence operators before the lower-precedence ones?

Accepted Answer

Introduction / Context: Arithmetic operator precedence governs how C parses expressions without explicit parentheses. While * and / share the same precedence level (with % as well), they together outrank + and -. This question checks that you can order these groups correctly. Given Data / Assumptions: Operators under consideration: +, -, , /. Standard C precedence and left-to-right associativity inside each level. Concept / Approach: The multiplicative operators (, /, %) have higher precedence than the additive operators (+, -). Within each group the left-to-right associativity applies, but the exact sequence between * and / is not a precedence distinction—they are coequal. Any listing that shows the multiplicative group before the additive group reflects the correct hierarchy. Step-by-Step Solution: Group 1 (higher): * and / (and %).Group 2 (lower): + and -.Choose the option that places the multiplicative group before the additive group.Option “/ * + -” satisfies this requirement. Verification / Alternative check: Parenthesize a sample: 3 + 4 * 5 is parsed as 3 + (4 * 5), confirming multiplicative precedence over additive. Why Other Options Are Wrong: Options placing + or - ahead of * or / invert the true hierarchy. The exact order between / and * is not significant for precedence; listing them together before + and - is the key. Common Pitfalls: Assuming addition happens before multiplication, a common arithmetic misconception. Final Answer: / * + -.

Question 5

Across the following operator categories in C—(1) Relational, (2) Arithmetic, (3) Logical, (4) Assignment—what is the correct precedence order from highest to lowest?

Accepted Answer

Introduction / Context: Reasoning about complex expressions often requires knowing which classes of operators bind tighter than others. C groups operators by precedence levels. This question asks you to order four broad classes correctly. Given Data / Assumptions: Classes: Arithmetic (2), Relational (1), Logical (3), Assignment (4). Unary operators are not part of this question; we consider the usual binary forms. Concept / Approach: Arithmetic operators (+, -, *, /, %) have higher precedence than relational operators (<, <=, >, >=). Relational operators, in turn, bind tighter than logical operators (&&, ||). The assignment operators (=, +=, etc.) are among the lowest. Therefore, the order from highest to lowest is: Arithmetic → Relational → Logical → Assignment. Step-by-Step Solution: Place Arithmetic first (2).Next place Relational (1).Then Logical (3).Finally Assignment (4).Concatenate: 2 1 3 4 → 2134. Verification / Alternative check: Consider 3 + 2 > 4 && flag = 1; The arithmetic part 3 + 2 is grouped first, then the relational comparison, then logical AND, and only then the assignment executes. Why Other Options Are Wrong: 1234, 3214, 4321 place one or more categories out of order with respect to the C precedence table. Common Pitfalls: Confusing evaluation order with precedence; logical operators short-circuit but still have lower precedence than relational operators. Final Answer: 2134.

Question 6

Conditional operator usage in C: which of the following is a correct and idiomatic use of the ternary operator ?:

Accepted Answer

Introduction / Context: The conditional (ternary) operator in C provides a compact, expression-based alternative to simple if/else assignments. It has the form condition ? expr_if_true : expr_if_false and returns the value of one of the two expressions. Using it correctly requires supplying both branches and respecting that it is an expression, not a statement keyword. Given Data / Assumptions: We are choosing among four snippets that purport to use ?:. Standard C syntax and usual operator precedence apply. Concept / Approach: A valid ternary expression must include both the true and false branches. It can yield a value, which you may assign or return. Nesting is allowed but parentheses are recommended for readability. Step-by-Step Solution: Option (a) provides both branches and performs assignments: a > b ? c = 30 : c = 40; This is valid (though many prefer c = a > b ? 30 : 40; for clarity).Option (b) omits the false branch; it is a syntax error.Option (c) uses nested ternaries to compute a maximum; while complicated, the snippet is missing a final semicolon in this listing but the expression form is otherwise valid. However, the question asks for the correct usage among the listed lines as-is; (a) is the clean, unambiguous example.Option (d) uses “a:b” inside parentheses, which is invalid; it should be return (a > b) ? a : b; Verification / Alternative check: Compile variant forms: c = a > b ? 30 : 40; and confirm behavior matches the equivalent if/else. Why Other Options Are Wrong: (b) is incomplete syntax. (c) as written is missing a terminator in many coding styles and is needlessly hard to read. (d) misuses the colon; the right form is a : b without parentheses around the pair. Common Pitfalls: Forgetting the else part; writing side-effect-laden branches that reduce readability; mixing statements and expressions improperly. Final Answer: a>b ? c=30 : c=40;.

Question 7

What will be the output of the program? #include<stdio.h> int main() {     int i=4, j=-1, k=0, w, x, y, z;     w = i || j || k;     x = i && j && k;     y = i || j &&k;     z = i && j || k;     printf("%d, %d, %d, %d ", w, x, y, z);     ret…

Accepted Answer

Step 1: int i=4, j=-1, k=0, w, x, y, z; here variable i, j, k, w, x, y, z are declared as an integer type and the variable i, j, k are initialized to 4, -1, 0 respectively. Step 2: w = i || j || k; becomes w = 4 || -1 || 0;. Hence it returns TRUE. So, w=1 Step 3: x = i && j && k; becomes x = 4 && -1 && 0; Hence it returns FALSE. So, x=0 Step 4: y = i || j &&k; becomes y = 4 || -1 && 0; Hence it returns TRUE. So, y=1 Step 5: z = i && j || k; becomes z = 4 && -1 || 0; Hence it returns TRUE. So, z=1. Step 6: printf("%d, %d, %d, %d
", w, x, y, z); Hence the output is "1, 0, 1, 1".

Question 8

What will be the output of the program? #include int main() { char ch; ch = 'A'; printf("The letter is"); printf("%c", ch >= 'A' && ch <= 'Z'? ch + 'a' - 'A':ch); printf("Now the letter is"); printf("%c ", ch >= 'A' …

Accepted Answer

Step 1: char ch; ch = 'A'; here variable ch is declared as an character type an initialized to 'A'. Step 2: printf("The letter is"); It prints "The letter is". Step 3: printf("%c", ch >= 'A' && ch <= 'Z' ? ch + 'a' - 'A':ch); The ASCII value of 'A' is 65 and 'a' is 97. Here => ('A' >= 'A' && 'A' <= 'Z') ? (A + 'a' - 'A'):('A') => (TRUE && TRUE) ? (65 + 97 - 65) : ('A') => (TRUE) ? (97): ('A') In printf the format specifier is '%c'. Hence prints 97 as 'a'. Step 4: printf("Now the letter is"); It prints "Now the letter is". Step 5: printf("%c ", ch >= 'A' && ch <= 'Z' ? ch : ch + 'a' - 'A'); Here => ('A' >= 'A' && 'A' <= 'Z') ? ('A') : (A + 'a' - 'A') => (TRUE && TRUE) ? ('A') :(65 + 97 - 65) => (TRUE) ? ('A') : (97) It prints 'A' Hence the output is The letter is a Now the letter is A

Question 9

What will be the output of the program? #include<stdio.h> int main() {     int x=12, y=7, z;     z = x!=4 || y == 2;     printf("z=%d ", z);     return 0; }

Accepted Answer

Step 1: int x=12, y=7, z; here variable x, y and z are declared as an integer and variable x and y are initialized to 12, 7 respectively. Step 2: z = x!=4 || y == 2; becomes z = 12!=4 || 7 == 2; then z = (condition true) || (condition false); Hence it returns 1. So the value of z=1. Step 3: printf("z=%d
", z); Hence the output of the program is "z=1".

Question 10

What will be the output of the program? #include<stdio.h> int main() {     int i=-3, j=2, k=0, m;     m = ++i && ++j || ++k;     printf("%d, %d, %d, %d ", i, j, k, m);     return 0; }

Accepted Answer

Step 1: int i=-3, j=2, k=0, m; here variable i, j, k, m are declared as an integer type and variable i, j, k are initialized to -3, 2, 0 respectively. Step 2: m = ++i && ++j || ++k; becomes m = (-2 && 3) || ++k; becomes m = TRUE || ++k;. (++k) is not executed because (-2 && 3) alone return TRUE. Hence this statement becomes TRUE. So it returns '1'(one). Hence m=1. Step 3: printf("%d, %d, %d, %d
", i, j, k, m); In the previous step the value of i,j are increemented by '1'(one). Hence the output is "-2, 3, 0, 1".

Question 11

What will be the output of the program? #include<stdio.h> int main() {     int i=2;     int j = i + (1, 2, 3, 4, 5);     printf("%d ", j);     return 0; }

Accepted Answer

Because, comma operator used in the expression i (1, 2, 3, 4, 5). The comma operator has left-right associativity. The left operand is always evaluated first, and the result of evaluation is discarded before the right operand is evaluated. In this expression 5 is the right most operand, hence after evaluating expression (1, 2, 3, 4, 5) the result is 5, which on adding to i results into 7.

Question 12

What will be the output of the program? #include int main() { int k, num=30; k = (num>5? (num <=10? 100 : 200): 500); printf("%d ", num); return 0; }

Accepted Answer

Step 1: int k, num=30; here variable k and num are declared as an integer type and variable num is initialized to '30'. Step 2: k = (num>5 ? (num <=10 ? 100 : 200): 500); This statement does not affect the output of the program. Because we are going to print the variable num in the next statement. So, we skip this statement. Step 3: printf("%d
", num); It prints the value of variable num '30' Step 3: Hence the output of the program is '30'

Question 13

What will be the output of the program? #include<stdio.h> int main() {     int i=-3, j=2, k=0, m;     m = ++i || ++j && ++k;     printf("%d, %d, %d, %d ", i, j, k, m);     return 0; }

Accepted Answer

Step 1: int i=-3, j=2, k=0, m; here variable i, j, k, m are declared as an integer type and variable i, j, k are initialized to -3, 2, 0 respectively. Step 2: m = ++i || ++j && ++k; here (++j && ++k;) this code will not get executed because ++i has non-zero value. becomes m = -2 || ++j && ++k; becomes m = TRUE || ++j && ++k; Hence this statement becomes TRUE. So it returns '1'(one). Hence m=1. Step 3: printf("%d, %d, %d, %d
", i, j, k, m); In the previous step the value of variable 'i' only increemented by '1'(one). The variable j,k are not increemented. Hence the output is "-2, 2, 0, 1".

Question 14

What will be the output of the program? #include<stdio.h> int main() {     static int a[20];     int i = 0;     a[i] = i  ;     printf("%d, %d, %d ", a[0], a[1], i);     return 0; }

Accepted Answer

Step 1: static int a[20]; here variable a is declared as an integer type and static. If a variable is declared as static and it will be automatically initialized to value '0'(zero). Step 2: int i = 0; here vaiable i is declared as an integer type and initialized to '0'(zero). Step 3: a[i] = i ; becomes a[0] = 0; Step 4: printf("%d, %d, %d
", a[0], a[1], i); Here a[0] = 0, a[1] = 0(because all staic variables are initialized to '0') and i = 0. Step 4: Hence the output is "0, 0, 0".

Question 15

Assuming, integer is 2 byte, What will be the output of the program? #include<stdio.h>  int main() {     printf("%x ", -2<<2);     return 0; }

Accepted Answer

The integer value 2 is represented as 00000000 00000010 in binary system. Negative numbers are represented in 2's complement method. 1's complement of 00000000 00000010 is 11111111 11111101 (Change all 0s to 1 and 1s to 0). 2's complement of 00000000 00000010 is 11111111 11111110 (Add 1 to 1's complement to obtain the 2's complement value). Therefore, in binary we represent -2 as: 11111111 11111110. After left shifting it by 2 bits we obtain: 11111111 11111000, and it is equal to "fff8" in hexadecimal system.

Question 16

What will be the output of the program? #include<stdio.h> int main() {     int x=4, y, z;     y = --x;     z = x--;     printf("%d, %d, %d ", x, y, z);     return 0; }

Accepted Answer

Step 1: int x=4, y, z; here variable x, y, z are declared as an integer type and variable x is initialized to 4. Step 2: y = --x; becomes y = 3; because (--x) is pre-decrement operator. Step 3: z = x--; becomes z = 3;. In the next step variable x becomes 2, because (x--) is post-decrement operator. Step 4: printf("%d, %d, %d
", x, y, z); Hence it prints "2, 3, 3".

Question 17

What will be the output of the program? #include<stdio.h> int main() {     int i=3;     i = i++;     printf("%d ", i);     return 0; }

Accepted Answer

4

Question 18

What will be the output of the program? #include int main() { int x=55; printf("%d, %d, %d ", x<=55, x=40, x>=10); return 0; }

Accepted Answer

Step 1: int x=55; here variable x is declared as an integer type and initialized to '55'. Step 2: printf("%d, %d, %d ", x<=55, x=40, x>=10); In printf the execution of expressions is from Right to Left. here x>=10 returns TRUE hence it prints '1'. x=40 here x is assigned to 40 Hence it prints '40'. x<=55 returns TRUE. hence it prints '1'. Step 3: Hence the output is "1, 40, 1".

Question 19

What will be the output of the program? #include<stdio.h> int main() {     int a=100, b=200, c;     c = (a == 100 || b > 200);     printf("c=%d ", c);     return 0; }

Accepted Answer

Step 1: int a=100, b=200, c; Step 2: c = (a == 100 || b > 200); becomes c = (100 == 100 || 200 > 200); becomes c = (TRUE || FALSE); becomes c = (TRUE);(ie. c = 1) Step 3: printf("c=%d
", c); It prints the value of variable i=1 Hence the output of the program is '1'(one).

Question 20

What will be the output of the program? #include<stdio.h> int main() {     int i=-3, j=2, k=0, m;     m = ++i && ++j && ++k;     printf("%d, %d, %d, %d ", i, j, k, m);     return 0; }

Accepted Answer

Step 1: int i=-3, j=2, k=0, m; here variable i, j, k, m are declared as an integer type and variable i, j, k are initialized to -3, 2, 0 respectively. Step 2: m = ++i && ++j && ++k; becomes m = -2 && 3 && 1; becomes m = TRUE && TRUE; Hence this statement becomes TRUE. So it returns '1'(one). Hence m=1. Step 3: printf("%d, %d, %d, %d
", i, j, k, m); In the previous step the value of i,j,k are increemented by '1'(one). Hence the output is "-2, 3, 1, 1".

Expressions Questions