CS Free MCQ Bank

[ Option D ]

The operators + (addition), * (multiplication), and / (division) can work with both integer and floating-point operands. There is no restriction that these operators must take only integer operands.

[ Option C ]

The conditional operator is also called the ternary operator because it works with three operands.
Syntax:
(condition) ? True Part : False Part;

#include <stdio.h>
int main()
{
    int a,p,q,min;
    printf("Enter A Number : ");
    scanf("%d",&a);
    a%2==0?printf("%d is Even",a):printf("%d is Odd",a);
    printf("
Enter Two Number : ");
    scanf("%d%d",&p,&q);
    min=p<q?p:q;
    printf("Minimum : %d",min);
    return 0;
}
OUTPUT
Enter A Number : 89
89 is Odd
Enter Two Number : 63 58
Minimum : 58

[ Option A ]

The operators && (AND) and || (OR) are called logical operators. They are used to combine multiple conditions in decision-making statements like if, while, or for.

• && (logical AND) : True only if both conditions are true.
• || (logical OR) : True if at least one condition is true.
• ! (logical NOT) : Reverse the logical value of a condition.

#include <stdio.h>
int main()
{
    int a, b;
    printf("Enter two Numbers: ");
    scanf("%d%d",&a,&b);
    if (a>0 && b>0)
    {
        printf("Both Numbers are Positive.
");
    }
    if (a<0 || b<0)
    {
        printf("At least One Number is Negative.
");
    } 
    if (!(a == b)) 
    {
        printf("The Numbers are Not Equal.");
    }
    return 0;
}
OUTPUT
Enter two Numbers: -87 56
At least One Number is Negative.
The Numbers are Not Equal.

[ Option A ]

The higher order precedence of given operators is:

• Unary operator.
• Arithmetic operator.
• Conditional operator.
• Assignment operator.

[ Option B ]

The modulus operator (%) is used to find the remainder after division of two integers. The sign of the result of % depends on the sign of the left operand (dividend). So, so -17%5 results in -2.
Note:
For solving % operator, there is no direct approach so it can be solved by using the equation, a%b=a-(a/b)*b and sign of remainder is determined by sign of first operand left to % symbol (dividend).
Now, the given expression is −17%5. Here a is -17 and b is 5.
a%b=a-(a/b)*b
-17%5 = -17-(-17/5)*5
-17%5 = -17-(-3*5)
-17%5 = -17+15
-17%5 = -2

[ Option B ]

The comma operator evaluates expressions from left to right, and the value of the entire expression is the value of the last expression.

[ Option B ]

In the given statement printf("%d",(17*2)%(int)5.5); first, 17*2 gives 34. Then type casting is applied, where (int)5.5 converts the floating-point value 5.5 into the integer value 5 by removing the decimal part. 
After this, the expression becomes 34%5. The modulus operator returns the remainder after division, and when 34 is divided by 5, the remainder is 4. Therefore, the value printed by printf() is 4.

[ Option D ]

[ Option C ]

[ Option C ]

The float variables a and b are first initialized with the values 2 and 3, respectively. The expression b *= +28.5 is evaluated first, which is equivalent to b = 3*28.5, resulting in b = 85.5. Next, the expression a *= b is evaluated, which is equivalent to a = 2*85.5, resulting in a = 171. 
Finally, when printf("%f",a); is executed, the float value of a is printed in standard floating-point format as 171.000000.

[ Option B ]

In C language, the modulus operation a % b is equivalent to the expression a-(a/b)*b, where integer division is used.

[ Option A ]

This expression uses the logical AND (&&) operator in C. The logical AND returns 1 (true) if both conditions are true, otherwise it returns 0 (false).
In given expression (5<8)&&(3>1), first, the relational expression 5<8 is evaluated, which is true and returns 1. Next, the relational expression 3>1 is also evaluated, which is true and returns 1. Since both conditions are true, the logical AND operation 1&&1 results in 1.

[ Option D ]

The operator ++ is called increment operator and it is used to increase the value of a variable by 1. It has several properties:

• The increment operator is a unary operator, meaning it operates on a single operand.
• The increment operator can write before or after the operand. If it is written before the operand then it is known as pre-increment (++a) or if it is written after the operand then it is known as post-increment (a++).
• It cannot be applied directly to an expression, it must be applied to a modifiable L-Value such as a variable like a++ or ++a, not to something like (a+1)++ or (a+b)++.

[ Option B ]

The modulus operator (%) is used to find the remainder after division of two integers. The sign of the result of % depends on the sign of the left operand (dividend). So, so -17%-5 results in -2.
Note:
For solving % operator, there is no direct approach so it can be solved by using the equation, a%b=a-(a/b)*b and sign of remainder is determined by sign of first operand left to % symbol (dividend).
Now, the given expression is −17%-5. Here a is -17 and b is -5.
a%b=a-(a/b)*b
-17%-5 = -17-(-17/-5)*-5
-17%-5 = -17-(3*-5)
-17%-5 = -17+15
-17%-5 = -2

[ Option A ]

In C language, relational operators are used to compare values, and they return 1 for true and 0 for false.
The result of logical AND (&&) is true only if both conditions are true and logical NOT (!) reverses the result i.e., true becomes false, false becomes true.

[ Option B ]

Initially, the variable i is initialized to 10. The expression i = !i > 14; have operator Logical Not (!) and greater than (>). According to operator precedence, the logical NOT operator (!) has higher precedence than the relational operator greater than (>). Therefore, the expression is interpreted as i = (!i) > 14;
Since i is 10 (a non-zero value), !i becomes 0, because the logical NOT of any non-zero value is 0. Now the expression becomes i = 0 > 14; The comparison 0 > 14 is false, and in C, false is represented as 0. Therefore, the final value stored in i is 0.

[ Option C ]

An operator is a special symbol that tells the computer to perform a specific mathematical or logical operation. 
For example, symbols like +, -, *, / are arithmetic operators used for calculations, while symbols like ==, >, and < are logical or relational operators used for comparisons.

• Operators act on values called operands to produce a result.
• Based on operands, operators are three types, unary, binary, and ternary.

[ Option D ]

The logical OR operator || evaluates expressions using short-circuit evaluation. This means:

• Evaluation stops as soon as one of its components evaluates to true, because the entire OR expression will already be true regardless of the remaining components.
• The evaluation takes place from left to right, meaning the left-hand side of || is evaluated first.

[ Option D ]

In C language, when both operands are integers, the division operator (/) performs integer division. Integer division discards the decimal part and keeps only the whole number. So, -17/5 = -3

[ Option B ]

Bitwise operators are used to perform operations directly on the binary representations (bits) of integer numbers. The common bitwise operator are:

The symbol "." (dot) is not a bitwise operator. It is commonly used as a member access operator in programming languages like C, C++, and Java for accessing fields or methods of a structure or object.

[ Option C ]

Initially, the variable a has a value of 4. The statement a *= 5+2; uses a compound assignment operator *= which multiplies the current value of a by the result of the expression on the right-hand side.
According to operator precedence rules, the addition 5+2 is evaluated first, giving 7. Then, the multiplication is performed, a = a*7 = 4*7 = 28. Therefore, after executing the statement, the value of a becomes 28.

[ Option D ]

• In post-increment (y++) first uses the value then increases it by 1.
• In pre-increment (++y) first increases the value then uses it.
• The comma operator (z=x,y;) has the lowest priority and expression is evaluated left to right. The final value assigned is the rightmost value.

[ Option C ]

When multiple operators come together in an expression then operator precedence determines the order in which operators are evaluated in an expression.

[ Option A ]

In the given C program, the expression inside the sizeof operator is sizeof(a=10,b=20,a+b+2.5). Here, the comma operator is used. With the comma operator, all expressions are evaluated from left to right, but the value and type of the entire expression are determined only by the last expression.
Therefore, although a=10 and b=20 appear inside sizeof, they are not actually executed, because sizeof (compile time operator) does not evaluate expressions, it only determines the size of the resulting data type.
The last expression is a+b+2.5. Since 2.5 is a double, the entire expression becomes of type double. On the given system, the size of double is 8 bytes, so c = 8. Because sizeof does not evaluate assignments, the values of a and b remain unchanged as 5 and 8.

REMEMBER:

• The sizeof operator is used to determine the memory size occupied by a data type, variable, or expression.
• The value returned by sizeof is always in bytes.
• The sizeof operator returns a value of type size_t, which is an unsigned integer type used to represent sizes in bytes.
• The sizeof is compile-time operator and evaluated at compile time. It does not execute the expression passed to it.
• If an expression contains assignments or function calls, they are not executed inside sizeof. 
• In the sizeof operator, the use of parentheses is mandatory when it is used with data types, such as sizeof(int), and optional when it is used with variables, such as sizeof a.

[ Option B ]

To check if the values of three variables age1, age2, and age3 are equal in C programming (and most languages), you use the equality operator == (Equal to) along with logical AND (&&) to combine multiple conditions.
Remember, the operator = is called assignment operator which is used for assign the value to the left-hand side operand (variable).

[ Option B ]

[ Option B ]

The two floating-point variables a and b are assigned the values 104.85 and 41.19, respectively. Their sum is calculated as a+b = 104.85+41.19 = 146.04. 
This sum is then assigned to the variable res, which is declared as an integer. In C, when a floating-point value is assigned to an integer variable, the decimal part is truncated. As a result, the value stored in res becomes 146.

[ Option B ]

The expression a=b-=c*=3 is evaluated from right to left because compound assignment operators associate right-to-left. Given that b = 101 and c = 10, the operation begins with the innermost expression c*=3, which multiplies c by 3 and updates it to 30. Next, the expression b-=c subtracts the new value of c (30) from b, updating b to 71. The result of the expression b -= c is this updated value of b, so the value assigned to a becomes 71.

[ Option C ]

The first printf statement uses sizeof(k/=i+j), where k/=i+j is an expression of type int. The sizeof operator determines the size of the operands type at compile time without evaluating the expression itself, so no side effect occurs, no assignment modifies k, which remains 15. 
Given that the size of an int is 4 bytes, the first printf outputs 4. The second printf then outputs the unchanged value of k, which is 15. Thus, the complete output is 4 15.

[ Option B ]

In C language:

• The & is bitwise AND operator.
• The && is Logical AND operator.
• The | is bitwise OR operator.
• The || is logical OR operator.

[ Option B ]

The comma operator (,) in C has left-to-right associativity, meaning expressions separated by commas are evaluated from left to right, and the value of the entire expression is the value of the rightmost expression.
int a;
a=(15,30,45);  
printf("%d",a);
The output is 45 because evaluation goes: 15 → 30 → 45, and the final value is taken.

[ Option C ]

Relational operators perform comparisons like equal to, not equal to, less than, greater than, etc. The Arithmetic Logic Unit (ALU) evaluates these comparisons and outputs one of two possible values, typically, 0 (false) or 1 (true).

Thus, the maximum number of outputs the ALU can give for relational operations is 2, representing true or false conditions.

[ Option A ]

Initially, the variables are initialized as i = 0, j = 1, and k = 2. The expression m = i++ || j++ || k++; uses the logical OR (||) operator, which follows short-circuit evaluation. This means the expression is evaluated from left to right, and the moment it encounters a true (non-zero) value, the remaining expressions are not evaluated.

[ Option D ]

The first three statements, a=a+1;, a+=1;, and a++;, all increment the value of a by 1.

• The a=a+1; is simple addition and assignment.
• The a+=1; is compound assignment, shorthand for a=a+1.
• The a++; is increment operator, i.e., adds 1 to a.

However, a=+1; does not increment a. It simply assigns the value +1 to a, replacing its previous value.

[ Option A ]

In C, the sizeof is not a variable or a keyword, instead, it is a compile-time operator that returns the size of its operand (variable, expression, or pointer).

[ Option C ]

In C language, most binary operators follow left-to-right associativity, while most unary operators follow right-to-left associativity. Among the options given, the array element access operator ([]) is a postfix operator, and postfix operators always associate left to right. This means when multiple array subscripts or postfix expressions appear together, they are evaluated from left to right.

[ Option A ]

Logical operators are used in programming and algorithms to perform decision-making based on true or false of conditions.

[ Option B ]

Initially, the variables are a = 10, b = 5, and c = 10. The if statement checks the condition (a > b) && (a <= c). Evaluating step by step: a > b is 10 > 5, which is true, and a <= c is 10 <= 10, which is also true. Since both parts of the condition are true, the && operator makes the whole condition true. Therefore, the code inside the if block executes, which is a = a + 1, so a becomes 11. The else block does not execute, so c remains 10.

[ Option B ]

Here the variable a is initialized with the value 2.3. The statement a+=.2; is a compound assignment operator, which means a=a+0.2, so the new value of a becomes 2.5. 
When printf("%f", a); is executed, the %f format specifier prints floating-point values with six digits after the decimal point by default. Therefore, the output displayed is 2.500000

[ Option B ]

The operator precedence determines the order in which operators are evaluated in an expression.
The logical AND operator && has higher precedence than logical OR (||), assignment (=), and the comma operator (,). This means that in an expression containing these operators, && will be evaluated first, followed by ||, then =, and finally ,.

[ Option C ]

In C, the % (modulus) operator is used to find the remainder of division, but it works only with integers, not floating-point numbers.
To calculate the remainder when dividing floating-point numbers like 3.14 and 2.1, we need to use the fmod() function, which is defined in the math.h header file.
 

#include <stdio.h>
#include <math.h>
int main()
{
    float rem;
    rem = fmod(3.14,2.1);
    printf("Remainder : %f",rem);
    return 0;
}
OUTPUT
Remainder : 1.040000

[ Option C ]

The logical NOT operator ! is a unary operator, and unary operators have higher precedence than binary operators like *, %, or +. This means expressions with ! are evaluated before multiplication, modulus, or addition when combined in a single statement.

[ Option C ]

Operators are symbols that perform operations on variables and values. Among the given options, & is bitwise AND operator, ~ is bitwise NOT operator, ! is logical NOT operator.
The # is not an operator, it is used in C as a preprocessor directive symbol like #include or #define but cannot perform any operation.

[ Option D ]