Operators And Expressions — Part 1 MCQs with Explanations

In C and many programming languages, mathematical expressions follow the operator precedence rules. Multiplication (*) and division (/) have higher precedence than addition (+) and subtraction (-). So, when evaluating the expression "5 + 7 * 2," the multiplication is performed before addition: 5 + (7 * 2) = 5 + 14 = 19 Therefore, the result of the expression "5 + 7 * 2" in C is Option A: 19 .

In C, the || operator is used for logical OR. It returns true (1) if at least one of the operands is true, otherwise, it returns false (0). Option A ( && ) represents the logical AND operator. Option B ( | ) represents the bitwise OR operator. Option C ( & ) represents the bitwise AND operator in C. Therefore, Option D ( || ) is the correct answer.

When the ++ operator is applied to a variable in C, it increments the value of the variable by 1. Option A ( Decrements by 1 ) is incorrect as the ++ operator increases the value. Option C ( Doubles the value ) is incorrect as the ++ operator adds 1, not doubles the value. Option D ( Leaves it unchanged ) is incorrect as the ++ operator explicitly increments the variable's value by 1.

In C, the % (modulo) operator is used for modulus division. It calculates the remainder when one number is divided by another. Option B ( / ) is incorrect as it represents regular division. Option C ( * ) is incorrect as it represents multiplication. Option D ( & ) is incorrect as it represents the bitwise AND operator, not modulus division.

In C, when you perform integer division, as in the expression 8 / 3, it results in the quotient without any decimal places. Therefore, the result is 2 . Option B ( 2.67 ) is incorrect as it would be the result of floating-point division. Option C ( 3 ) is incorrect because it would be the result of rounding up in floating-point division. Option D ( 3.5 ) is incorrect because it would be the result of floating-point division.

In C, the arithmetic operators have a specific order of precedence. Multiplication has the highest precedence, followed by division, and then addition and subtraction. This order ensures that expressions are evaluated in the correct mathematical order.

In C, arithmetic expressions follow the order of precedence, where multiplication and division have higher precedence than addition and subtraction. Therefore, in the expression 10 - 5 * 2, the multiplication (5 * 2) is performed first, resulting in 10 - 10, which indeed equals 0 .

In C, the == operator is used for equality comparison. It checks if the two operands are equal and returns true if they are, otherwise, it returns false. Option B ( = ) is incorrect as it is the assignment operator, used to assign values to variables, not for equality comparison. Option C ( != ) is incorrect as it is the "not equal to" operator, used to check if two values are not equal. Option D ( <> ) is not a valid equality comparison operator in C.

In C, arithmetic expressions follow the order of operations (PEMDAS/BODMAS), where parentheses have the highest precedence. Therefore, the expression (6 - 2) is evaluated first, resulting in 4, and (1 + 2) is evaluated as 3. Then, these results are multiplied: 4 * 3, which equals 12

In C, when you perform integer division, as in the expression 7 / 2, it results in the quotient without any decimal places. Therefore, the result is 3 . Option A ( 2 ) is incorrect because it doesn't consider integer division. Option B ( 3.5 ) is incorrect because it represents the result of floating-point division. Option D ( 3.50 ) is also incorrect because it represents a floating-point number, which is not the result of integer division.

In C, the % (modulo) operator is used to calculate the remainder when one number is divided by another. In the expression 5 % 3, it calculates the remainder of dividing 5 by 3, which is 2 .

In C, the ! operator is used for logical NOT. It negates the value of a Boolean expression, turning true to false and false to true. Option A ( && ) represents the logical AND operator, not logical NOT. Option C ( & ) represents the bitwise AND operator, not logical NOT. Option D ( | ) represents the bitwise OR operator, not logical NOT.

In C, dividing a number by zero is undefined and leads to a runtime error. The expression 10 / 0 will result in a runtime error because dividing by zero is not allowed in mathematics or in C programming. Option A ( 0 ) is incorrect because dividing by zero does not result in zero; it is undefined. Option B ( Infinity ) is not the result in C programming when you divide by zero; it depends on the context and compiler. Option C ( Compilation error ) typically does not occur because the error is detected at runtime, not during compilation.

In C, the = operator is used for assignment. It is used to assign a value to a variable or a data location. Option A ( == ) represents the equality operator, used to compare two values for equality. Option C ( := ) is not a valid operator in C programming. Option D ( -> ) is used for accessing members of a structure or union through a pointer to that structure or union, not for assignment.

In C, the & operator is used to perform a bitwise AND operation. It performs a bitwise AND between corresponding bits of two integers. It returns a new integer where each bit is the result of ANDing the corresponding bits of the operands. Option A ( && ) represents the logical AND operator, which is used for logical comparisons, not bitwise operations. Option B ( | ) represents the bitwise OR operator, which performs bitwise OR operations, not bitwise AND. Option D ( || ) represents the logical OR operator, used for logical comparisons, not bitwise operations.

In C, when you perform integer division, as in the expression 5 / 2, it results in the quotient without any decimal places. Therefore, the result is 2 . Option B ( 2.5 ) is incorrect because it represents the result of floating-point division, not integer division. Option C ( 2.50 ) is incorrect because it also represents a floating-point number, which is not the result of integer division. Option D ( 3 ) is incorrect because it doesn't consider integer division; the correct result is 2 .

In C, the order of precedence for logical operators is as follows: OR (||) has the highest precedence, followed by NOT (!) , and then AND (&&) . This order ensures that expressions are evaluated correctly based on logical conditions. Option A ( AND, OR, NOT ) is incorrect because it doesn't follow the correct order of precedence. Option B ( NOT, OR, AND ) is also incorrect for the same reason. Option C ( OR, AND, NOT ) is incorrect as it doesn't reflect the correct order of precedence for logical operators in C.

In C, arithmetic expressions follow the order of operations (PEMDAS/BODMAS), where parentheses have the highest precedence. Therefore, the expression (10 + 2) is evaluated first, resulting in 12. Then, the division by 2 is performed, resulting in 12 / 2, which equals 6 . Option A ( 12 ) is incorrect because it represents the result of the expression inside the parentheses without considering the subsequent division. Option C ( 7 ) is incorrect because it does not represent the correct result of the expression. Option D ( 11 ) is incorrect because it doesn't consider the division by 2;

In C, the != operator is used for inequality comparison. It checks if two values are not equal and returns true if they are not equal, otherwise, it returns false. Option B ( <> ) is not a valid inequality comparison operator in C. Option C ( == ) represents the equality operator, used to check if two values are equal, not for inequality comparison. Option D ( = ) is the assignment operator, used to assign values to variables, not for comparison.

In C, when you add two floating-point numbers, as in the expression 2.5 + 2, the result is a floating-point number. Therefore, the result is 4.5 . Option B ( 4 ) is incorrect because it represents an integer result, but the expression involves floating-point numbers. Option C ( 2.7 ) is incorrect; it's not the result of the given expression. Option D ( 2 ) is incorrect for the same reason as Option B; it represents an integer result, not a floating-point result.

In C, the % (modulo) operator is used to calculate the remainder when one number is divided by another. In the expression 8 % 4, it calculates the remainder of dividing 8 by 4, which is 0 . Option B ( 4 ) is incorrect because it doesn't represent the remainder of the division. Option C ( 2 ) is incorrect because it also doesn't represent the remainder; it represents half of the dividend. Option D ( 8 ) is incorrect because it's the dividend itself, not the remainder of the division.

In C, the | operator is used to perform a bitwise OR operation. It performs a bitwise OR between corresponding bits of two integers. It returns a new integer where each bit is the result of ORing the corresponding bits of the operands. Option A ( && ) represents the logical AND operator, which is used for logical comparisons, not bitwise operations. Option C ( & ) represents the bitwise AND operator, which performs bitwise AND operations, not bitwise OR. Option D ( || ) represents the logical OR operator, used for logical comparisons, not bitwise operations.

In C, the && operator is the logical AND operator. It returns 1 (TRUE) if both operands are true (non-zero), and 0 (FALSE) if any of the operands is false (zero). In this expression, the second operand is 0 , which is false. Therefore, the result of the expression is 0 (FALSE) . Option A ( 1 ) is incorrect because the result of the expression is 0 , not 1 . Option C ( TRUE ) represents the true value, but the result of the expression is 0 (FALSE) . Option D ( FALSE ) represents the false value, which is the correct result of the expression.

In C, arithmetic expressions follow the order of operations (PEMDAS/BODMAS), where parentheses have the highest precedence. Therefore, the expression (1 + 2) inside the parentheses is evaluated first, resulting in 3. Then, the multiplication is performed: 5 * 3, which equals 15. Finally, the subtraction is performed: 15 - 3, which equals 12 . Option B ( 15 ) is incorrect because it represents the result of the multiplication but doesn't consider the subsequent subtraction. Option C ( 10 ) is incorrect because it doesn't represent the correct result of the expression. Option D ( 6 ) is incorrect because it doesn't consider both the multiplication and subtraction; the correct result is 12 .

In C, the ^ operator is used to perform a bitwise XOR (exclusive OR) operation. It performs a bitwise XOR between corresponding bits of two integers. It returns a new integer where each bit is the result of XORing the corresponding bits of the operands. Option A ( && ) represents the logical AND operator, used for logical comparisons, not bitwise operations. Option B ( || ) represents the logical OR operator, used for logical comparisons, not bitwise operations. Option C ( & ) represents the bitwise AND operator, used for bitwise AND operations, not bitwise XOR.

In C, dividing a number by zero is undefined and leads to a runtime error. The expression (6 + 3) / 0 will result in a runtime error because dividing by zero is not allowed in mathematics or in C programming.

In C, when you divide an integer by a floating-point number, the result is a floating-point number. In this expression, 5 is an integer, and 2.0 is a floating-point number. When you perform the division, 5 / 2.0, it results in 2.5 . Option A ( 2 ) is incorrect because it represents an integer result, but the expression involves a floating-point division. Option C ( 2.0 ) is also incorrect because it represents the result as a floating-point number, but the correct result is 2.5 . Option D ( 3 ) is incorrect because it doesn't consider the decimal part of the result; the correct result is 2.5 .

In C, the modulus operator ( % ) takes only integer operands. It is used to find the remainder when one integer is divided by another. This operator is specifically designed for integer arithmetic. Option A ( + ) represents the addition operator, which can take both integer and floating-point operands. Option B ( * ) represents the multiplication operator, which can take both integer and floating-point operands. Option C ( / ) represents the division operator, which can take both integer and floating-point operands. Option E ( None of these ) is incorrect because % is the operator that specifically takes only integer operands; the other options can take both integer and floating-point operands.

In C, the logical OR operator (||) behaves as follows: If the first operand evaluates to true, the entire expression is considered true, and further evaluation is stopped. If the first operand evaluates to false, the evaluation continues with the second operand. If the second operand evaluates to true, the entire expression is considered true. If both operands evaluate to false, the entire expression is considered false. Based on this behavior, the evaluation doesn't stop when one of its components evaluates to true (contrary to option II). Instead, it stops when one of its components evaluates to false. Regarding option IV, the evaluation of the logical OR operator (||) is left-to-right, so option IV is correct. So, the correct answer is indeed Option D: II and IV, which means the evaluation will stop when one of its components evaluates to false, and the evaluation takes place from left to right. Thank you for pointing out the correction.

In this C program, the expression i++ || j++ || k++ involves the logical OR ( || ) operator. Here's how it works: - It evaluates from left to right. - It stops evaluating as soon as it finds a true condition because in a logical OR operation, if one operand is true, the result is true. Let's break it down step by step: - i is initially 0. i++ returns 0 (post-increment), but it increments i to 1. - j is initially 1. j++ returns 1 (post-increment), and it increments j to 2. - k is initially 2. k++ returns 2 (post-increment), and it increments k to 3. Now, the expression is evaluated: - 0 || 1 is true because one of the operands is true. - Since the result is true, the evaluation stops. After the evaluation: - m is assigned the value 1 because the result is true. - i is 1 because i was incremented during the evaluation. - j is 2 because j was incremented during the evaluation. - k is 2 because k was not incremented further. Therefore, the output of the printf statement is 1 1 2 2 , which corresponds to Option B.

In this C program, the expression - -2 involves the use of the unary minus operator ( - ) applied twice to the number 2. - The first - operator negates the number 2, resulting in -2 . - The second - operator negates -2 , which effectively makes it positive again, resulting in 2 . So, the variable c is assigned the value 2 , and the output of the printf statement is c=2 , which corresponds to Option C.

In the expression ! i > 14 , NOT (!) operator has more precedence than ' > ' symbol. ! is a unary logical operator. ! i (!10) is 0 (not of true is false). 0>14 is false (zero).

The comma operator evaluates both of its operands and produces the value of the second. It also has lower precedence than assignment. Hence c = a, b is equivalent to c = a, while d = (a, b) is equivalent to d = b.

Evaluating ++ i + ++ i would produce undefined behavior, but the operand of sizeof is not evaluated, so i remains 3 throughout the program. The type of the expression ( int ) is reduced at compile time, and the size of this type (2) is assigned to j.

See C Operator Precedence Table .

The correct answer is D. Nothing is printed . In the given code, the if statement condition consists of multiple expressions separated by commas ( , ). The comma operator evaluates each expression from left to right and returns the result of the last expression. In this case, the expressions a , b , x , and y are used as the condition. Since they are non-zero values (10, 20, 1, and 0 respectively), the condition is considered true. However, the comma operator only returns the result of the last expression ( y ), which is 0 (false). Since the condition evaluates to false, the code block within the if statement ( printf("EXAM"); ) is not executed, resulting in nothing being printed.

C Operator Precedence Table According to precedence table execution of the given operators are as follows: 1. x++(Postfix operator) i.e x will become 5 2. y--(Prefix operator) i.e y will become -11 3. * and / have same priority so they will be executed according to their associativity i.e left to right. So, *(Multiplication) will execute first and then /(division). 4. -(Subtraction) So the complete expression would be 5 - (-11)*2/4 = 5 - (-22)/4 = 5 - (-5) = 5 + 5 = 10.

Since the evaluation is from right to left. So when the print statement execute value of i = 0 Since its execute from right to left when i++ will be execute first and print value 0 (since its post increment ) and after printing 0 value of i become 1. So it its prints for 1 for next i .

Expression a = b>c ? c>d ? 12 : d>e ? 13 : 14 : 15; can be rewritten as if ( b>c ) { if ( c>d ) a = 12; else { if ( d>e ) a = 13; else a = 14; } } else { a = 15; }

-1 will be represented in binary form as: 1111 1111 1111 1111 Now -1<<4 means 1 is Shifted towards left by 4 positions, hence it becomes: 1111 1111 1111 0000 in hexadecimal form - fff0.