Added all materail for Section08.

Author: Anthony Yan

Section08-Statements_and_Operators/README.md

@@ -174,7 +174,92 @@ result = (100 == 50 + 50);
 result = (num1 != num2);
 
 cout << (num1 == num2) << endl;     // 0 or 1
-cout << std::boolalpha;
+cout << std::boolalpha;             // this allow display "true or false" rather than "0 or 1"
 cout << (num1 == num2) << endl;     // true or false
-cout << std::noboolalpha;
-```
+cout << std::noboolalpha;           // this revert display "true or false" back to "0 or 1"
+```
+
+## Relational Operator
+
+| Operator | Meaning |
+| --- | --- |
+| `>` | greater than |
+| `>=` | greater than or equal to |
+| `<` | less than |
+| `<=` | less than or equal to |
+| `<=>` | three-way comparision (C++20) |
+
+
+## Logical Operators
+
+| Operator | Meaning |
+| --- | --- |
+| `not`, `!` | negation |
+| `and`, `&&` | logical and |
+| `or`, `||` | logical or |
+
+
+### AND or `&&`
+
+- is only true if both operands are true
+
+| Expression A | Expression B | `A and B` or `A && B` |
+| --- | --- | --- |
+| true | true | **true** |
+| true | false | false |
+| false | true | false |
+| false | false | false |
+
+
+### OR or `||` 
+
+- is true if one or more operands are true
+
+| Expression A | Expression B | `A or B` or `A || B` |
+| --- | --- | --- |
+| true | true | **true** |
+| true | false | **true** |
+| false | true | **true** |
+| false | false | false |
+
+
+### Precedence 
+
+- `not` has higher precedence than `and`
+- `and` has higher precedence than `or`
+- `not` is a unary operator
+- `and` and `or` are binary operators
+
+
+### Short-Circuit Evaluation
+
+- When evaluating a logical expression C++ stops as soon as the result is known
+
+
+## Compound assignemnt
+
+| Operator | Example | Meaning |
+| --- | --- | --- |
+| `+=` | lhs += rhs; | lhs = lhs + (rhs); |
+| `-=` | lhs -= rhs; | lhs = lhs - (rhs); |
+| `*=` | lhs *= rhs; | lhs = lhs * (rhs); |
+| `/=` | lhs /= rhs; | lhs = lhs / (rhs); |
+| `%=` | lhs %= rhs; | lhs = lhs % (rhs); |
+| `>>=` | lhs >>= rhs; | lhs = lhs >> (rhs); |
+| `<<=` | lhs <<= rhs; | lhs = lhs << (rhs); |
+| `&=` | lhs &= rhs; | lhs = lhs & (rhs); |
+| `^=` | lhs ^= rhs; | lhs = lhs ^ (rhs); |
+| `|=` | lhs |= rhs; | lhs = lhs | (rhs); |
+
+```c++
+a += 1;     // a = a + 1;
+a /= 5;     // a = a / 5;
+a *= b + c; // a = a * (b + c);
+
+cost += items * tax;        // cost = cost + (items * tax);
+```
+
+## Operator Precedence
+
+- [C++ Operator Precedence](https://en.cppreference.com/w/cpp/language/operator_precedence)
+- Use parenthesis is good practice to remove confusion

Section08-Statements_and_Operators/section08_coding_exercise/README.md

@@ -34,9 +34,11 @@ void assignment_operator() {
     //----DO NOT MODIFY THE CODE BELOW THIS LINE----
 
    cout << num1 << " " << num2;
+   
 }
 ```
 
+
 # Coding Exercise 8: Using the Arithmetic Operators
 
 Write a program that uses arithmetic operators to manipulate an integer number that is provided to you.
@@ -82,5 +84,36 @@ int arithmetic_operators(int number) {
     //----WRITE YOUR CODE ABOVE THIS LINE----
 
     return number;
+
 }
-```
+```
+
+
+# Coding Exercise 9: Logical Operators and Operator Precedence - Can you work?
+
+Write a program that determines the eligibility of an individual applying for a job as a delivery driver. 
+
+- driver must be `18` years of age or older 
+- or be above the age of `15` and have their parents consent to work
+- they must possess a valid social security number and have no driving accidents
+- let the variable `age` represent the individual's age
+- boolean variable `parental_consent` represent parental consent
+- `ssn` represent a valid social security number
+- `accidents` represent whether they have had any car accidents
+
+## Solution 
+```c++
+#include <iostream>
+using namespace std;
+
+void logical_operators (int age, bool parental_consent, bool ssn, bool accidents) {
+
+    //----WRITE YOUR CODE BELOW THIS LINE----
+    
+    if ( (age >= 18 && ssn && !accidents) || (age > 15 && parental_consent && ssn && !accidents) )//WRITE ALL YOUR CODE WITHIN THE PARENTHESES
+        cout << "Yes, you can work.";
+    
+    //----WRITE YOUR CODE ABOVE THIS LINE----
+    return;
+
+}

Section08-Statements_and_Operators/section08_source_code/Challenge/main.cpp

@@ -39,8 +39,87 @@ using namespace std;
 
 int main() {
 
+	// Declare changes in unit of cents
+	const int dollar {100};
+	const int quarter {25};
+	const int dime {10};
+	const int nickel {5};
+	const int penny {1};
+	
+	// Declare output variables
+	int change {};
+	int num_dollar {};
+	int num_quarter {};
+	int num_dime {};
+	int num_nickel {};
+	int num_penny {};
+	
+
+	cout << "Enter an amount in cents: ";
+	cin >> change;
+
+	if (change == 0) {
+
+		cout << "\nYou can provide this change as follows: " << endl;
+		cout << "dollars:\t0" << endl;
+		cout << "quarters:\t0" << endl;
+		cout << "dimes:\t\t0" << endl;
+		cout << "nickels:\t0" << endl;
+		cout << "pennies:\t0" << endl;
+
+	} else if (change < 0) {
+
+		cout << "Somthing is wrong... We can't have negative change." << endl;
+
+	} else {
+
+		// 1. Dollar
+		num_dollar = change / dollar;
+		// if (num_dollar < 1){				// didn't need these if-statements because int of decimal number is 0
+		// 	num_dollar = 0;
+		// }
+		change -= num_dollar * dollar;		// update change
+
+		// 2. Quarter
+		num_quarter = change / quarter;
+		// if (num_quarter < 1){
+		// 	num_quarter = 0;
+		// }
+		change -= num_quarter * quarter;	// update change
+
+		// 3. Dime
+		num_dime = change / dime;
+		// if (num_dime < 1){
+		// 	num_dime = 0;
+		// }
+		change -= num_dime * dime;			// update change
+
+		// 4. Nickel
+		num_nickel = change / nickel;
+		// if (num_nickel < 1){
+		// 	num_nickel = 0;
+		// }
+		change -= num_nickel * nickel;		// update change
+
+		// 5. Penny
+		num_penny = change / penny;
+		// if (num_penny < 1){
+		// 	num_penny = 0;
+		// }
+		change -= num_penny * penny;		// update change
+
+		// cout << change << endl;		// debug to see if change equal to zero after all calculations
+		cout << "\nYou can provide this change as follows: " << endl;
+		cout << "dollars:\t" << num_dollar << endl;
+		cout << "quarters:\t" << num_quarter << endl;
+		cout << "dimes:\t\t" << num_dime << endl;
+		cout << "nickels:\t" << num_nickel << endl;
+		cout << "pennies:\t" << num_penny << endl;
+	}
+
     cout << endl;
     return 0;
 }
 
 
+

Section08-Statements_and_Operators/section8_source_code/EqualityOperators/main.cpp

@@ -37,14 +37,18 @@ int main() {
 //    not_equal_result = (double1 != double2);
 //    cout << "Comparision result (equals) : " << equal_result << endl;
 //    cout << "Comparision result (not equals) : " << not_equal_result << endl;
+// if the input dobules are "12.0" and "11.99999999999", they will equate to each other becuase the representation that is used to save the doubles behind the scene is equal.
+// if one desired to distinguish between the two doubles, speical libraries need to be used.
 //
 //    cout << "Enter an integer and a double separated by a space: ";
 //    cin >> num1 >> double1;
 //    equal_result = (num1 == double1);
 //    not_equal_result = (num1 != double1);
 //    cout << "Comparision result (equals) : " << equal_result << endl;
 //    cout << "Comparision result (not equals) : " << not_equal_result << endl;
-
+// mix mode comparison doesn't work. The two types have to be the same.
+// the int will be promoted to double.
+// the output will be equal
 
     cout << endl;
     return 0;