Comparing Boolean Expressions

!(p && q) and !p || !q form a De Morgan pair: the negation moves inward and the operator changes from && to ||. Equivalent expressions agree for every combination of values, so both variables hold true here.

• B is not correct: false would require the two expressions to disagree, but De Morgan's Laws make them equivalent, so they agree for every combination of p and q.
• C is not correct: the letter a names an operand in the statement of De Morgan's Laws; it is not a value that a comparison of two boolean variables can produce.
• D is not correct: nothing in the segment breaks a rule: each of the first four lines declares a boolean variable, and the last line prints the result of a comparison.

Comparing a reference with null uses == or != and does not call a method. Assigning null to badge changes only badge; saved still holds the reference it received earlier.

• A is not correct: saved received the reference to the String object before the assignment, so it still refers to that object and the second comparison is false.
• C is not correct: badge holds null when the first comparison runs, so that comparison is true; this choice reverses the order of the two results.
• D is not correct: the first comparison is true, because badge was assigned null on the line just above the two output statements.

== checks reference identity, while equals applies the class's rule for content equality. r2 receives an existing reference and becomes an alias, and the second new expression creates a different object.

• A is not correct: r2 == r3 is false, because r3 comes from its own new expression and therefore refers to a different object.
• B is not correct: r1 == r2 is true, since r2 receives the reference held by r1 and both names then refer to one object.
• D is not correct: r1 == r2 is true for the alias, and r1.equals(r3) is true because both strings contain the same characters.

The operators == and != compare object references. copy received the reference before p was assigned null, so the two variables no longer hold the same reference.

• B is not correct: false would mean both variables hold the same reference, but only p was changed by the assignment of null.
• C is not correct: null is the value stored in p; the comparison itself produces a boolean result rather than that stored value.
• D is not correct: comparing a reference with == or != does not call a method, so holding null causes no exception here.

Moving the negation inward changes && to || and negates each comparison, so n >= 5 becomes n < 5 and n <= 12 becomes n > 12. Both forms then describe the same values.

• B is not correct: the second variable is also true, because 14 is greater than 12, which makes one operand of the || expression true.
• C is not correct: the first variable is true as well: n <= 12 is false, so the && expression is false and its negation is true.
• D is not correct: both expressions describe the same condition, and 14 lies outside the range, so neither of them evaluates to false.

!(a && b) is equivalent to !a || !b, and a truth table confirms it: the final two columns match in every row. The operator itself changes, not only the placement of the !.

• A is not correct: that is the pattern for negating an || expression; the original operator here is &&, so the negated operands must be joined by ||.
• C is not correct: both ! operators have been dropped, so this expression is false when p and q are both false, where the original is true.
• D is not correct: this is the expression inside the parentheses without its negation, so it gives the opposite result in every row of a truth table.

!(a || b) is equivalent to !a && !b, as the truth table shows: the final two columns match in every row. Moving the negation inward changes the operator as well as the operands.

• B is not correct: the operator has not changed here; negating an || expression must join the negated operands with && rather than with ||.
• C is not correct: both ! operators are missing, so this expression is true only when p and q are both true, where the original is false.
• D is not correct: this is the expression inside the parentheses with the negation dropped, so it gives the opposite result in every row of a truth table.

A negated relational expression can often be rewritten by flipping the comparison. Each relational operator has a negated form, and the negated form of x <= y is x > y.

• A is not correct: x >= 18 is true when x equals 18, but the original expression is false there, so the two are not equivalent.
• B is not correct: x < 18 is the negation of x >= y rather than of x <= y; it is true exactly where the original expression is false.
• D is not correct: x == 18 tests a single value, while the original expression is true for every value greater than 18.

De Morgan turns !(p && q) into !p || !q, so the whole condition becomes an || expression with four operands. Whatever value p has, one of p and !p is true.

• B is not correct: p && !p is always false, because p and !p cannot both be true at the same time.
• C is not correct: after the negation moves inward this expression contains both p and !p joined by &&, which makes it always false.
• D is not correct: p && q is false whenever either operand is false, so it is not true for every combination of values.

!(p || q) becomes !p && !q, so the whole condition is an && expression with four operands, among them p and !p. They cannot both be true.

• A is not correct: p || !p is always true, because one of those two operands is true whatever value p has.
• B is not correct: this is the || pattern that is always true, since moving the negation inward leaves both p and !p among its operands.
• D is not correct: when p is true the second operand makes the whole || expression true, so it is not always false.

Equivalence is about results rather than appearance. buildingOpen && !atCapacity and !(!buildingOpen || atCapacity) look nothing alike, yet a truth table shows that they agree in every row.

• A is not correct: two expressions written with different symbols can still agree on every input, and agreement on every input is all that equivalence requires.
• C is not correct: the number of characters says nothing about the values produced; equivalence is decided row by row, by comparing results for every possible input.
• D is not correct: relational operators are allowed. !(score < 60 || score > 100) and score >= 60 && score <= 100 both use them and are equivalent.

In De Morgan's Laws each operand may be an entire expression. Negating the outer || changes it to &&; the negation of !p is p, and the negation of p && q is !p || !q.

• A is not correct: !p && q requires p to be false, but moving the negation inward leaves p itself as one of the operands.
• C is not correct: the outer negation turns the || into &&, so the equivalent expression cannot keep || as its main operator.
• D is not correct: this keeps || where De Morgan's Laws require &&, and it is true when p and q are both false, where the original is false.