Why exactly the output of this expression return true

Question

I have this expression:

!(1 && !(0 || 1))

The output returns 1 true. And that's ok. When I read the expression I came to the same conclusion before checking the output. But I would really appreciate if someone can explain to me why the returning value is true, that way, I will have a better understanding of boolean logic and how to implement better evaluators in my code.

Key observation here: ! is not, && is the "And" operator, and || is the "Inclusive Or" Operator.

Answer 1

What are you really asking when you say "why it's true?".

0 = false
1 = true

AND && table
0 0 -> 0
0 1 -> 0
1 0 -> 0
1 1 -> 1

OR || table
0 0 -> 0
0 1 -> 1
1 0 -> 1
1 1 -> 1

NOT ! table
0 -> 1
1 -> 0

With parentheses implying "do this first", the statement reduces using the tables above:

!(1 && !(0 || 1))
!(1 && !1)
!(1 && 0)
!0
1

But I don't know "why" it's true. Because that's what an AND operation is, what an OR operation is, and what a NOT operation is, and how reducing a statement works. With those definitions, it can't be another answer, so it's that answer. But you already know that, because you did it yourself and got the same answer ... so what does the question mean?

Answer 2

The innermost expression (0 || 1) is always true. So !(0 || 1) is always false.

That leaves 1 && 0, which is always false.

So !(false) is always true.

Please forgive my freely intermixing 0/false and 1/true.

The human evaluator (:-).

Answer 3

Working through the expression, following order of operation:

  !(1 && !(0 || 1))
= !(1 && !(1))
= !(1 && 0)
= !(0)
= 1

Answer 4

!(1 && !(0 || 1))

Since, you have used parenthesis, evaluation takes place according to them.

First, evaluate innermost parenthesis.

0 || 1                 => always true.
!(0 || 1)              => !(true)       => always false.
1 && !(0 || 1)         => 1 && false    => always false.
!(1 && !(0 || 1))      => !false        => always true.

Answer 5

Step by step explanation:

1 = true 0 = false

Starting point: !(1 && !(0 || 1))

---

Lets start with the inner most expression: !(0 || 1)

Var1 || Var2 = 
Var1 or Var2 = 
If Var1 or Var2 is 1 or both are 1, the result is 1. 

(0 || 1) = 0 or 1  -> the second variable is 1 so the expression is 1.

---

Insert the result (0 || 1) = 1 into Startingpoint: !(1 && !(1))

! = not (inverts the value of what is behinde)
!1 = 0
!0 = 1

!(0 || 1) = !(1) = 0

---

Insert the result !(1) = 0 into Startingpoint: !(1 && 0)

So we have !(1 && 0)

Var1 && Var2 = And = 
the opossite of or =
If Var1 AND Var2 are both 1, the result is 1. Else it is 0 =
If Var1 or Var2 is 0, the result is zero

1 && 1 = 1
1 && 0 = 0
everything else: 0

---

So this is left: !(0)

Reminder: ! = not = inverts the expression behind it. So !0 = 1 (and !1 = 0)

This is 1. Or in your case: true

A good book for Beginner C programmers and people who want to learn about programming and logic in an easy, understandable way:

C for Dummies by Dan Godkins