---
title: CSCI 1301 -- Lab 16
author: Clément Aubert
lang: en
fontsize: 10pt
documentclass: scrartcl
numbersections: true
links-as-notes: true
papersize: letter
geometry: margin=1in
keywords:
- Computer Science
- Problem solving methods
- Syllabus
- Augusta University
- Bachelor of Science
---

# Truth Tables

Copy-and-paste the following code in the `Main` method of a new project:

~~~~~~~{.cs .numberLines .lineAnchors}
/* 
 * We have two boolean values: true and false.
 * We can use the constant "true" and "false",
 * we can also declare constants with the same value,
 * but a shorter name:
 */
const bool t = true;
const bool f = false;

Console.WriteLine("Conjonction (and, &&) truth table:"
+ "\n\n\t" + t+ "\t" + f
+ "\n" + t+ "\t" + (t && t)+ "\t" + (t && f)
+ "\n" + f+ "\t" + (f && t)+ "\t" + (f && f)
+ "\n\n*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*\n");

Console.WriteLine("Negation (not, !) truth table:"
+ "\n\n\t" + t+ "\t" + f
+ "\n\t" + (!t)+ "\t" + (!f)
+ "\n\n*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*\n");
~~~~~~~

Compile and execute it.

Then, write the code that will display on the screen the truth tables for the binary operators disjunction (or, `||`), identity (equality, `==`) and difference (inequality, `!=`).

Normally, using the find-and-replace feature of VS should make this task easy and fast.

# Precedence and Order of Evaluation

## Reading and Understanding

If you look at <https://docs.microsoft.com/en-us/cpp/c-language/precedence-and-order-of-evaluation>, you will see that

|
:---: | :---: 
`!` | is evaluated before
`*`, `/`, and `%` | which are evaluated before
`+` and `-` | which are evaluated before
`<`, `>`, `<=`, and `>=` | which are evaluated before
`==` and `!=` | which are evaluated before
`&&` | which is evaluated before
`||`| which comes last

and that within those groups, operations are evaluated from left to right.

So that, for instance, `! true || false && 3 * 2 == 5` will be evaluated as

||
--- | --- | --
**`! true`** `|| false && 3 * 2 == 6` | ⇒ | **`false`** `|| false && 3 * 2 == 6` 
`false || false &&` **`3 * 2`** `== 6` | ⇒ | `false || false &&` **`6`** `== 6`
`false || false &&` **`6 == 6`** | ⇒ | `false || false &&` **`true`**
`false ||` **`false && true`** | ⇒ | `false ||` **`false`**
**`false || false`** | ⇒ | **`false`**

Note that an expression like `!3 > 2` doesn't make any sense: C# would try to take the negation of `3`, but you can't negate an integer!
Along the same way, an expression like `false * true` doesn't make any sense: you can't multiply booleans!
Similarly, `3 % false` will cause an error: can you decide why?

## Computing Simple Boolean Expressions

Evaluate the following expressions (where `t` stands for `true`, and `f` for `false`):

- `t && f || t`
- `!t && f`
- `f || t && !f`
- `f == !t || f`
- `!(t || f || t && t)`
- `!(t || f) && (t && !f)`
- `!t || f && (t && !f)`
- `t != !(f || t)`

## Computing Expressions Involving Booleans and Numerical Values

For each of the following expression, decide if they are "legal" or not.
If they are, give the result of their evaluation.

- `3 > 2`
- `2 == 4`
- `3 >= 2 != f`
- `3 > f`
- `t && 3 + 5 * 8 == 43`
- `3 + t != f`

# A Guessing Game (Optional)

Write a program that

#. Store your favorite number in a variable
#. Ask the user to enter a numerical value, and store the user's answer in a variable.
#. With an `if` statement, display on the screen "You guessed correctly" if the number entered by the user is your favorite number.
#. Once this part of the program works, add an `if` statement that displays on the screen "Too high!" if the number entered by the user is strictly greater than your favorite number.
#. Once this part of the program works, add an `if` statement that displays on the screen "Too low!" if the number entered by the user is strictly lower than your favorite number.
#. Once this part of the program works, add an `if` statement that displays on the screen "You found a multiple of my favorite number!" if the number entered by the user is a multiple of your favorite number, but different from it.
