Relational & Logical Operators - C# Questions & Answers

This section of our 1000+ C# multiple choice questions and answers focuses on relational and logical operators in C# Programming Language.

1. What will be the output of the following C# code?

```
 static void Main(string[] args)
```
```
 {
```
```
     int a = 4;
```
```
     int b = 5;
```
```
     int c = 6;
```
```
     int d = 8;
```

     if (((a * b / c) + d) >= ((b * c + d ) / a))

```
     {
```

         Console.WriteLine("Line 1 - a is greater to b");

         Console.WriteLine((a * b / c) + d);

```
     }
```
```
     else
```
```
     {
```

         Console.WriteLine("Line 1 - a is not greater to b");

         Console.WriteLine((b * c + d )/ a);

```
     }
```
```
 }
```

"Line 1 - a is  greater to b"
11

"Line 1 - a is not greater to b"
9

c) Both are equal
d) None of the mentioned
View Answer

Answer: a
Explanation: Now, here in ‘if’ condition both conditions of parenthesis and hence evaluating operators based on parenthesis are tested.
for expression :

 ((a * b / c) + d)
Step 1: (a*b/c) (Evaluating as 4*5/6 = 3)
Step 2: ( (a*b/c) + d ) (Evaluating (3 + 8 = 11))
Result: 11
for expression : (b * c + d )/ a
Step 1: (b*c + d) (Evaluating as 5*6 +8 = 38)
Step 2:   (b*c + d) / a (Evaluating as 38 / 4 = 9)
Result: 9

The relational operator “>=” between both expressions check for largest figure and hence consecutively executes the if condition.
Output:

Note: Join free Sanfoundry classes at Telegram or Youtube

         Line 1 - a is greater to b.
         11

2. Check the following C# code whether the given relation operator works according to the if condition or not.

```
 static void Main(string[] args)
```
```
 {
```
```
     int a = 10;
```
```
     int b = 5;
```
```
     int c = 12; 
```
```
     int e = 8;
```
```
     int d;
```

     d = Convert.ToInt32((a * (c - b) / e + (b + c)) <= (e * (c + a) / (b + c) + a));

```
     Console.WriteLine(d);
```
```
     if (d == 1)
```
```
     {
```

         Console.WriteLine("C# is great language!");

         Console.WriteLine((a * (c - b) / e + (b + c)));

```
     }
```
```
     else
```
```
     {
```

         Console.WriteLine("harsh is not great language!");

         Console.WriteLine((e * (c + a) / (b + c) + a));

```
     }
```
```
 }
```

0
C# is great!
20

0
C# is not great!
25

0
C# is great!
25

0
C# is not great!
20

View Answer

Answer: d
Explanation: The expression (a * (c – b) / e + (b + c)) on evaluation parenthesis by parenthesis gives result mathematically as 25. Similarly, (e * (c + a) / (b + c) + a) on evaluation parenthesis by parenthesis gives mathematically result as 20. Relational operator now checks for condition as in if condition as (25 < 20) which is false. So, a false bit in form of ‘0’ is assigned to d. Now, in if condition (d != 1) as d = 0. So, condition after else is evaluated.
Output :

        0.
        C# is not great!.
        20.

3. Which of the following is/are not Relational operators in C#.NET?
a) >=
b) <>=
c) Not
d) <=
View Answer

Answer: b
Explanation: By definition.

4. What will be the output of the following C# code?

```
    int n = 2;
```
```
    int p = 4;
```
```
    int q = 5;
```
```
    int w = 3;
```

    if ( !((p * q) /n <= (q * w) + n/p ))

```
    {
```

        Console.WriteLine( ++p + w++ + " " + ++n);

```
        Console.WriteLine("b");
```
```
    }
```
```
    else
```
```
    {
```

        Console.WriteLine(--p + q-- + " " + --n);

```
        Console.WriteLine("a");
```
```
    }
```

6 2
b

8 1
a

6 1
a

8 1
b

View Answer

Answer: b
Explanation: After evaluation of the test expression (!((p*q)/n <= (q*w)+n/p)). The use of logical operator(!) turns false(0) result to bit ‘1’ and hence the condition evaluated by ‘if’ loop is after else as :
–p = 3
q–= 5
–p + q– = 8 where now value of ‘q’is 4.
–n = 2 – 1 =1.
So, values after evaluations are 8 1.
a.
Output :

         8 1
         a

5. What will be the output of the following C# code?

    m = 5;
    int y;
    1. y = m++;
    2. y = ++m;

a) y = 5, m = 6 ; y = 5, m = 5
b) y = 6, m = 6; y = 7, m = 6
c) y = 5, m = 6; y = 7, m = 7
d) y = 5, m = 6; y = 7, m = 8
View Answer

Answer: c
Explanation:

              step 1 :  m = 5, y = m++ i.e y =5, m =6.
              step 2 :  y = ++m, Since m = 6. So, m = 7 on ++m and hence y = 7.
Output : y = 5, m = 6; y =7, m = 7.

6. What will be the output of the following C# code?

```
  static void Main(string[] args)
```
```
  {
```
```
      int a = 3, b = 5, c = 1;
```
```
      int z = ++b;
```
```
      int y = ++c;
```

      b = Convert.ToInt32((Convert.ToBoolean(z)) && (Convert.ToBoolean(y))

       || Convert.ToBoolean(Convert.ToInt32(!(++a == b))));

      a = Convert.ToInt32(Convert.ToBoolean(c) || Convert.ToBoolean(a--));

```
      Console.WriteLine(++a);
```
```
      Console.WriteLine(++b);
```
```
      Console.WriteLine(c);
```
```
  }
```

a) 2, 2, 1
b) 2, 3, 2
c) 2, 2, 2
d) 2, 0, 9
View Answer

Answer: c
Explanation: z = 6 as ++b.
y = 2 as ++c.
6 && 2 = 1
(++a == b) which is false as 4!=6. Now, !(false) = true i.e 1.
So, 1 || 1 = 1. So, b = 1.
Similarly, c = 2 and a = 4. Now, 2 || 4 = 1.
So, a = 1.
Hence ++a = 2, ++b = 2, c = 2.
Output :

2, 2, 2

7. What will be the output of the following C# code?

```
 static void Main(string[] args)
```
```
 {
```
```
     int a = 4, b = 5, c = 7, u = 9;
```
```
     int h;
```

     h = (Convert.ToInt32(u < b)) + (a + b--) + 2;

```
     Console.WriteLine(h);
```
```
     Console.WriteLine(b);
```
```
     Console.WriteLine(u < b);
```
```
 }
```

a) 12, 5, 0
b) 11, 4, False
c) 11, 5, 0
d) 12, 4, False
View Answer

Answer: b
Explanation: Step 1: Convert.ToInt32(u < b)(Evaluate result as 9 < 5 which is false in nature. So, solution is converted from ‘false’ to ‘0’).

             Step 2: (a + b--) evaluated as 4 + 5 = 9 + 2 = 11.
             Step 3: u &lt; b evaluated as 'False' without being converted to '0'.
Output: 11
         4
         False.

8. What will be the output of the following C# code?

```
 static void Main(string[] args)
```
```
 {
```
```
     int m = 10, n = 5, p = 20;
```

     bool b1 =  m * p / n <= p * n / m ;

```
     int l = p - 2 * m;
```
```
     bool b2 = l == 0;
```
```
     int z = Convert.ToInt32(b2);
```
```
     int k = Convert.ToInt32(b1);
```
```
     Console.WriteLine(k);
```
```
     Console.WriteLine(z);
```
```
 }
```

a) 0 0
b) 1 0
c) 0 1
d) 1 1
View Answer

Answer: c
Explanation: Solving the expression for b1 tests the condition for either true or false result in ‘0’. Similarly, for ‘b2’ ‘l’ on solving gives ‘0’. So, condition is true for bool b2 as 0 == 0. Hence, k = 0 and z = 1.
Output :

0 1.

9. What will be the output of the following C# code?

```
 class method1
```
```
 {
```
```
     public int fun(int m)
```
```
     {
```
```
         return( m++ % 10);
```
```
     }
```
```
 }
```
```
 class Program
```
```
 {
```
```
     static void Main(string[] args)
```
```
     {
```
```
         int a = 23, b = 0, c;
```
```
         method1 z = new method1();
```
```
         c = z.fun (++b * --a % 2);
```
```
         int d = (z.fun (c-- + --a));
```
```
         Console.WriteLine(c);
```
```
         Console.WriteLine(a++);
```
```
         Console.WriteLine(d);
```
```
         Console.ReadLine();
```
```
     }
```
```
 }
```

a) -1, 22, 0
b) -1, 21, 1
c) 0, 22, 1
d) 0, 22, 0
View Answer

Answer: b
Explanation: Here, for first value of c, ++b = 1 and 1 * (22%2) = 0. c = 0. Now c — = 0 and — a = 22 – 1 =21. Now, c — is the first condition executed and then decremented So, c = -1. Similarly, a++ = 21. Now, as we can see from options we are confirmed over value of c = -1, a = 21. So, we can easily know that d = 1.
Output:

-1 21 1

10. What will be the output of the following C# code?

```
  static void Main(string[] args)
```
```
  {
```
```
      int a = 8, b = 6, c = 10;
```

      int d = a * c * 2 / Convert.ToInt32(Math.Pow ((c - b), 2));

      if (d == (c = Convert.ToInt32(Math.Sqrt (a * a + b * b))) && c == 10)

```
      {
```

          Console.WriteLine("figure is hypotenuse");

```
      }
```
```
      else
```
```
      {
```

         Console.WriteLine("figure is square");

```
      }
```
```
  }
```

a) Figure is square
b) Figure is hypotenuse
c) False
d) None of the mentioned
View Answer

Answer: a
Explanation: Solving the expression for ‘c’ we get c==10 in if first condition as (c == Convert.ToInt32(Math.Sqrt(a * a + b * b))). The logical condition when d == (c = 10) suits here. Similarly, going for second condition where c ==10 as ‘&&’ operator exists between both given condition and at last both are evaluated to true as c == 10. So, only first statement is executed.
Output :

Figure is square

Sanfoundry Global Education & Learning Series – C# Programming Language.

To practice all areas of C# language, here is complete set of 1000+ Multiple Choice Questions and Answers.

If you find a mistake in question / option / answer, kindly take a screenshot and email to [email protected]

« Prev - C# Questions & Answers – Arithmetic Operators

» Next - C# Questions & Answers – Bitwise and Conditional Operators

Related Posts:

Practice Computer Science MCQs
Practice MCA MCQs
Apply for Computer Science Internship
Apply for C# Internship
Check MCA Books

Recommended Articles: