Conditionals.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Conditional Execution\n",
    "\n",
    "## Topics\n",
    "- conditional executions\n",
    "- comparison operators\n",
    "- types of conditional statements\n",
    "- switch statement\n",
    "- using conditional statements in functions\n",
    "- ternary conditional operator\n",
    "- logical operators\n",
    "- passing arguments to `main()` and using them\n",
    "\n",
    "## Conditional execution\n",
    "- so far, our programs executed top to bottom starting from **main( )**\n",
    "    - statement by statement\n",
    "    - functions change the execution flow from call to definition\n",
    "- it's important that computer skips or executes certain block of code\n",
    "    - computer needs to decide to do that to produce useful programs\n",
    "- **conditional statements** let computer think or make decisions based on data\n",
    "    - similar to what humans do!\n",
    "    - e.g. what are the criteria/conditions that help you pick a college?\n",
    "        - which major or class should I pick? \n",
    "        - should I go to class today?\n",
    "- conditional statements compare data values to create conditions\n",
    "    - the outcome of which is boolean `true` or `false`\n",
    "\n",
    "### Comparison operators\n",
    "- **comparison operators** are used to compare data values\n",
    "    - thus, creating a condition\n",
    "- comparison operators are binary operators that take two operands\n",
    "- following table shows comparison operators that compare left hand side value with the right hand side\n",
    "\n",
    "| symbol | example | description |\n",
    "| :---- | :--- | :--- |\n",
    "| == | x == y | is x equal to y? |\n",
    "| != | x != y | is x not equal to y? |\n",
    "| >  | x > y  | is x greater than y ? |\n",
    "| >= | x >= y | is x greater than or equal to y? |\n",
    "| <  | x < y  | is x less than y ? |\n",
    "| <= | x <= y | is x less than or equal to y? |\n",
    "\n",
    "- result of comparison expression (condition) is **true** or **false** boolean value\n",
    "    - technically, it's **1** and **0**\n",
    "    - where, **1** -> true and **0** -> false"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "#include <iostream> // for std io\n",
    "#include <cassert> // for assert()\n",
    "#include <string> // for C++ string\n",
    "using namespace std;"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "true"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "// comparison operators examples\n",
    "1 == 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "int x = 10;\n",
    "int y = 20;"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0"
     ]
    }
   ],
   "source": [
    "// is x eqal to y?\n",
    "cout << (x == y);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "true"
     ]
    }
   ],
   "source": [
    "// let's print true of false using io manipulator\n",
    "// is x not equal to y?\n",
    "cout << boolalpha << (x != y);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "false"
     ]
    }
   ],
   "source": [
    "cout << (x > y);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "true"
     ]
    }
   ],
   "source": [
    "cout << (x < y);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "false"
     ]
    }
   ],
   "source": [
    "cout << (x >= y);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "true"
     ]
    }
   ],
   "source": [
    "cout << (x <= y);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Types of conditional statements\n",
    "- there are 3 types of conditional statements:\n",
    "    1. one-way selector\n",
    "    2. two-way selector\n",
    "    3. multi-way selector\n",
    "\n",
    "### one-way selector\n",
    "- simplest form of conditional statement\n",
    "- syntax:\n",
    "\n",
    "```cpp\n",
    "    if (condition) {\n",
    "        // body of if\n",
    "        // block of code to execute\n",
    "    }\n",
    "```\n",
    "- the block of code inside if statement executes iff condition evalutes to true\n",
    "    - skips the block, otherwise!\n",
    "- the following flow-chart demonstrates the flow of if statment execution\n",
    "\n",
    "![](resources/ifstatement.png)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "stuff before if\n",
      "body of if\n",
      "stuff after if\n"
     ]
    }
   ],
   "source": [
    "// examples\n",
    "cout << \"stuff before if\\n\";\n",
    "if (true) { // true is always true; same as true == true\n",
    "    cout << \"body of if\\n\";\n",
    "}\n",
    "cout << \"stuff after if\\n\";"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "stuff before if\n",
      "stuff after if\n"
     ]
    }
   ],
   "source": [
    "cout << \"stuff before if\\n\";\n",
    "if (false) { // false always evaluates to false; same as false == true\n",
    "    cout << \"body of if\\n\";\n",
    "}\n",
    "cout << \"stuff after if\\n\";"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "// check if a given number is positive\n",
    "int num;"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "enter a whole number: 100\n",
      "100 is positive\n",
      "Good bye!"
     ]
    }
   ],
   "source": [
    "cout << \"enter a whole number: \";\n",
    "cin >> num;\n",
    "if (num > 0) {\n",
    "    cout << num << \" is positive\\n\";\n",
    "}\n",
    "cout << \"Good bye!\";"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Visualize one-way selector in [pythontutor.com](http://pythontutor.com/cpp.html#code=%23include%20%3Ciostream%3E%0Ausing%20namespace%20std%3B%0A%0Aint%20main%28%29%20%7B%0A%20%20int%20num%20%3D%20-9%3B%0A%20%20if%20%28num%20%3E%200%29%20%7B%0A%20%20%20%20cout%20%3C%3C%20num%20%3C%3C%20%22%20is%20positive%5Cn%22%3B%0A%20%20%7D%0A%20%20cout%20%3C%3C%20%22Good%20bye!%22%3B%0A%20%20return%200%3B%0A%7D&curInstr=0&mode=display&origin=opt-frontend.js&py=cpp&rawInputLstJSON=%5B%5D)\n",
    "\n",
    "### Two-way selector\n",
    "- provides alternative execution\n",
    "- analogy is a true/false type question\n",
    "    - you have to pick one or the other\n",
    "- syntax:\n",
    "```cpp\n",
    "    if (condition) {\n",
    "        // body of if\n",
    "    }\n",
    "    else {\n",
    "        // otherwise, body of else\n",
    "    }\n",
    "```\n",
    "- if the condition is true, body of if executes\n",
    "- oterwise, body of else executes\n",
    "- the following flowchart demonstrates the flow of if else statement\n",
    "\n",
    "![](resources/ifelsestatement.png)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter a whole number: 99\n",
      "99 is positive\n",
      "Good bye!"
     ]
    },
    {
     "data": {
      "text/plain": [
       "@0x10c49bed0"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "// determine if the given number is positive or negative\n",
    "cout << \"Enter a whole number: \";\n",
    "cin >> num;\n",
    "if (num > 0) {\n",
    "    cout << num << \" is positive\\n\";\n",
    "}\n",
    "else {\n",
    "    cout << num << \" is negative\\n\";\n",
    "}\n",
    "cout << \"Good bye!\";\n",
    "// run it few times providing +ve and -ve numbers"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Visualize two-way selector in [pythontutor.com](http://pythontutor.com/cpp.html#code=%23include%20%3Ciostream%3E%0Ausing%20namespace%20std%3B%0A%0Aint%20main%28%29%20%7B%0A%20%20int%20num1%20%3D%20100%3B%0A%20%20int%20num2%20%3D%20200%3B%0A%20%20if%20%28num1%20%3E%3D%20num2%29%0A%20%20%20%20cout%20%3C%3C%20num1%20%3C%3C%20%22%20is%20greater%20than%20or%20equal%20to%20%22%20%3C%3C%20num2%20%3C%3C%20endl%3B%0A%20%20else%0A%20%20%20%20cout%20%3C%3C%20num2%20%3C%3C%20%22%20is%20greater%20than%20%22%20%3C%3C%20num1%20%3C%3C%20endl%3B%0A%20%20%20%20%0A%20%20cout%20%3C%3C%20%22Good%20Bye!%22%3B%0A%20%20return%200%3B%0A%7D&curInstr=0&mode=display&origin=opt-frontend.js&py=cpp&rawInputLstJSON=%5B%5D)\n",
    "\n",
    "### Multi-way selector\n",
    "- sometimes one may have to pick one outcome from several options\n",
    "    - analogy is multiple-choice question with only one correct answer!\n",
    "- we can achieve this by chaining a series of `else if`s\n",
    "- also called chained conditionals\n",
    "- syntax:\n",
    "```cpp\n",
    "    if (condition) {\n",
    "        // first if block\n",
    "    }\n",
    "    else if(condition) {\n",
    "        // 2nd if block\n",
    "    }\n",
    "    else if(condition) {\n",
    "        // 3rd if block\n",
    "    }\n",
    "    ...\n",
    "    else {\n",
    "        // alternative\n",
    "    }\n",
    "```\n",
    "- check condition starting from the first **if statement**\n",
    "- if the condition is true, execute the corresponding if block\n",
    "    - skip the rest of the chained conditions if any\n",
    "- otherwise, check next condition\n",
    "    - so on and so forth...\n",
    "- execute else alternative if not a single condition is evaluated true\n",
    "- the following flowchart depicts the chained conditional execution\n",
    "\n",
    "![](resources/multi-wayselector.png)\n",
    "\n",
    "### NOTE:\n",
    "- since the condition is checked from top to bottom, the order of checking condition matters in some problems!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "enter a whole number: -9\n",
      "-9 is negative\n",
      "Good bye!"
     ]
    }
   ],
   "source": [
    "// determine if a given number is 0, positive, or negative\n",
    "cout << \"enter a whole number: \";\n",
    "cin >> num;\n",
    "if (num > 0)\n",
    "    // if a block has only one statment; {} can be ignored!\n",
    "    cout << num << \" is positive\\n\";\n",
    "else if (num < 0)\n",
    "    cout << num << \" is negative\\n\";\n",
    "else\n",
    "    cout << \"the entered number is 0\\n\";\n",
    "\n",
    "cout << \"Good bye!\";"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Demo program that determines letter grade (A-F) given numeric grade (0-100)\n",
    "- write a program that converts numeric grade into the corresponding letter grade\n",
    "- letter grade criteria:\n",
    "```\n",
    "    grade >= 90 -> A\n",
    "    grade >= 80 -> B\n",
    "    grade >= 70 -> C\n",
    "    grade >= 60 -> D\n",
    "    grade < 60  -> F\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "// variable to store the numeric grade\n",
    "float grade;"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter a grade: 90\n",
      "90 is a D.\n",
      "Good bye!"
     ]
    }
   ],
   "source": [
    "// Implementation I\n",
    "// does this solution give correct answer?\n",
    "// order of checking condition matters!\n",
    "cout << \"Enter a grade: \";\n",
    "cin >> grade;\n",
    "\n",
    "if (grade < 60)\n",
    "    cout << grade << \"is an F!\\n\";\n",
    "else if(grade >= 60)\n",
    "    cout << grade << \" is a D.\\n\";\n",
    "else if(grade >= 70)\n",
    "    cout << grade << \"is a C.\\n\";\n",
    "else if (grade >= 80)\n",
    "    cout << grade << \" is a B.\\n\";\n",
    "else if (grade >= 90)\n",
    "    cout << grade << \" is an A!\\n\";\n",
    "\n",
    "cout << \"Good bye!\";"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter a grade: 90\n",
      "90 is an A! :))\n",
      "Awesome job!\n",
      "Good bye!\n"
     ]
    }
   ],
   "source": [
    "// Implementation II\n",
    "// how about this solution; does this give correct answer?\n",
    "cout << \"Enter a grade: \";\n",
    "cin >> grade;\n",
    "\n",
    "if (grade >= 90) {\n",
    "    cout << grade << \" is an A! :))\\n\";\n",
    "    cout << \"Awesome job!\\n\";\n",
    "}\n",
    "else if(grade >= 80) {\n",
    "    cout << grade << \" is a B. :)\\n\";\n",
    "    cout << \"Great job! So close to acing... keep working!\\n\";\n",
    "}\n",
    "else if(grade >= 70) {\n",
    "    cout << grade << \" is a C. :|\\n\";\n",
    "    cout << \"Good job! work harder to get a B or an A\\n\";\n",
    "}\n",
    "else if(grade >= 60) {\n",
    "    cout << grade << \" is a D. :(\\n\";\n",
    "    cout << \"Sorry, D isn't good enought to move on to CS2\\n. Work very hard!\";\n",
    "}\n",
    "else {\n",
    "    cout << grade << \" is an F. :((\\n\";\n",
    "    cout << \"Sorry, that's a fail. Work really really hard to pass!!\\n\";\n",
    "}\n",
    "\n",
    "cout << \"Good bye!\\n\";"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "// Implementation III - using function\n",
    "char find_letter_grade(float grade) {\n",
    "    if (grade >= 90)\n",
    "        return 'A';\n",
    "    else if(grade >= 80)\n",
    "        return 'B';\n",
    "    else if(grade >= 70)\n",
    "        return 'C';\n",
    "    else if(grade >= 60)\n",
    "        return 'D';\n",
    "    else\n",
    "        return 'F';\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter a numeric grade: 75\n",
      "75 is equivalent to C\n"
     ]
    }
   ],
   "source": [
    "// manually test find_letter_grade function\n",
    "cout << \"Enter a numeric grade: \";\n",
    "cin >> grade;\n",
    "char l_grade = find_letter_grade(grade);\n",
    "cout << grade << \" is equivalent to \" << l_grade << endl;\n",
    "if (l_grade == 'A')\n",
    "    cout << \"Awesome job! :))\\n\";"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "// automatically test find_letter_grade function\n",
    "void test_find_letter_grade() {\n",
    "    assert(find_letter_grade(100) == 'A');\n",
    "    assert(find_letter_grade(40) == 'F');\n",
    "    assert(find_letter_grade(89) == 'B');\n",
    "    // TODO: test for every possible outcome\n",
    "    cerr << \"all test casses passed!\" << endl;\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "all test casses passed!\n"
     ]
    }
   ],
   "source": [
    "test_find_letter_grade();"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Visualize multi-way selector in [pythontutor.com](http://pythontutor.com/cpp.html#code=//%20program%20to%20determine%20day%20of%20the%20week%20given%20number%0A//%201-7%20%28sunday%20to%20saturday%29%0A%23include%20%3Ciostream%3E%0Ausing%20namespace%20std%3B%0A%0Aint%20main%28%29%20%7B%0A%20%20int%20day%20%3D%200%3B%0A%20%20if%20%28day%20%3D%3D%201%29%0A%20%20%20%20cout%20%3C%3C%20day%20%3C%3C%20%22%20is%20Sunday%5Cn%22%3B%0A%20%20else%20if%20%28day%20%3D%3D%202%29%0A%20%20%20%20cout%20%3C%3C%20day%20%3C%3C%20%22%20is%20Monday%5Cn%22%3B%0A%20%20else%20if%20%28day%20%3D%3D%203%29%0A%20%20%20%20cout%20%3C%3C%20day%20%3C%3C%20%22%20is%20Tuesday%5Cn%22%3B%0A%20%20else%20if%20%28day%20%3D%3D%204%29%0A%20%20%20%20cout%20%3C%3C%20day%20%3C%3C%20%22%20is%20Wednesday%5Cn%22%3B%0A%20%20else%20if%20%28day%20%3D%3D%205%29%0A%20%20%20%20cout%20%3C%3C%20day%20%3C%3C%20%22%20is%20Thursday%5Cn%22%3B%0A%20%20else%20if%20%28day%20%3D%3D%206%29%0A%20%20%20%20cout%20%3C%3C%20day%20%3C%3C%20%22%20is%20Friday%5Cn%22%3B%0A%20%20else%20if%20%28day%20%3D%3D%207%29%0A%20%20%20%20cout%20%3C%3C%20day%20%3C%3C%20%22%20is%20Saturday%5Cn%22%3B%0A%20%20else%0A%20%20%20%20cout%20%3C%3C%20day%20%3C%3C%20%22%20is%20not%20a%20valid%20day!%22%3B%0A%20%20%20%20%0A%20%20cout%20%3C%3C%20%22Good%20bye...%5Cn%22%3B%0A%20%20return%200%3B%0A%7D&curInstr=0&mode=display&origin=opt-frontend.js&py=cpp&rawInputLstJSON=%5B%5D)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Nested conditionals\n",
    "- one or more type of conditional statements can be nested inside another conditional statement\n",
    "- syntax:\n",
    "\n",
    "```cpp\n",
    "    if (condition) {\n",
    "        // do something\n",
    "        if (condition) {\n",
    "            // do something..\n",
    "        }\n",
    "\n",
    "        if (condition) {\n",
    "            // do something\n",
    "        }\n",
    "        else {\n",
    "            // do something else\n",
    "        }\n",
    "\n",
    "    }\n",
    "    else {\n",
    "        // do something else...\n",
    "        if (condition) {\n",
    "            // do something\n",
    "        }\n",
    "    }\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "enter a whole number: -75\n",
      "-75 is negative and odd\n",
      "Good bye!"
     ]
    }
   ],
   "source": [
    "// a program that determines if a given number is 0, even or odd and positive or negative\n",
    "// the order of condition doesn't matter in this example\n",
    "cout << \"enter a whole number: \";\n",
    "cin >> num;\n",
    "if (num > 0) {\n",
    "    cout << num << \" is positive \";\n",
    "    // check if the number is even or odd\n",
    "    if (num %2 == 0)\n",
    "        cout << \"and even\\n\";\n",
    "    else\n",
    "        cout << \"and odd\\n\";\n",
    "}\n",
    "else if (num < 0) {\n",
    "    cout << num << \" is negative \";\n",
    "    // check if the number is even or odd\n",
    "    if (num %2 == 0)\n",
    "        cout << \"and even\\n\";\n",
    "    else\n",
    "        cout << \"and odd\\n\";\n",
    "}\n",
    "else\n",
    "    cout << \"the entered number is 0\\n\";\n",
    "\n",
    "cout << \"Good bye!\";"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Visualize nested conditional execution in [pythontutor.com](http://pythontutor.com/cpp.html#code=//%20program%20to%20determine%20day%20of%20the%20week%20given%20number%0A//%201-7%20%28sunday%20to%20saturday%29%0A%23include%20%3Ciostream%3E%0Ausing%20namespace%20std%3B%0A%0Aint%20main%28%29%20%7B%0A%20%20int%20num%20%3D%20-99%3B%0A%20%20if%20%28num%20%3E%200%29%20%7B%0A%20%20%20%20cout%20%3C%3C%20num%20%3C%3C%20%22%20is%20positive%20%22%3B%0A%20%20%20%20//%20check%20if%20the%20number%20is%20even%20or%20odd%0A%20%20%20%20if%20%28num%20%252%20%3D%3D%200%29%0A%20%20%20%20%20%20%20%20cout%20%3C%3C%20%22and%20even%5Cn%22%3B%0A%20%20%20%20else%0A%20%20%20%20%20%20%20%20cout%20%3C%3C%20%22and%20odd%5Cn%22%3B%0A%20%20%7D%0A%20%20else%20if%20%28num%20%3C%200%29%20%7B%0A%20%20%20%20%20%20cout%20%3C%3C%20num%20%3C%3C%20%22%20is%20negative%20%22%3B%0A%20%20%20%20%20%20//%20check%20if%20the%20number%20is%20even%20or%20odd%0A%20%20%20%20%20%20if%20%28num%20%252%20%3D%3D%200%29%0A%20%20%20%20%20%20%20%20%20%20cout%20%3C%3C%20%22and%20even%5Cn%22%3B%0A%20%20%20%20%20%20else%0A%20%20%20%20%20%20%20%20%20%20cout%20%3C%3C%20%22and%20odd%5Cn%22%3B%0A%20%20%7D%0A%20%20else%0A%20%20%20%20%20%20cout%20%3C%3C%20%22the%20entered%20number%20is%200%5Cn%22%3B%0A%20%20%20%20%0A%20%20%20%20cout%20%3C%3C%20%22Good%20bye!%22%3B%0A%20%20return%200%3B%0A%7D&curInstr=0&mode=display&origin=opt-frontend.js&py=cpp&rawInputLstJSON=%5B%5D)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "// TODO: Convert the above program as a function"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Conditional operator\n",
    "- C++ provies a ternary conditional operator\n",
    "- takes 3 operands\n",
    "- syntax:\n",
    "```cpp\n",
    "    (condition) ? expression1 : expression2;\n",
    "```\n",
    "- the value of (condition) is evaluated\n",
    "- if the condition is true, expression1 is used as the result\n",
    "- otherwise expression2 is uesed as the result\n",
    "- simply, a shortcut for:\n",
    "\n",
    "```cpp\n",
    "    if (condition) {\n",
    "        expression1;\n",
    "    }\n",
    "    else {\n",
    "        expression2;\n",
    "    }\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "// application of conditional operator\n",
    "// write a program that determines if a given number is odd or even\n",
    "\n",
    "#include <iostream>\n",
    "#include <string>\n",
    "using namespace std;\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "int number;"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter an Integer number: 45\n",
      "45 is odd"
     ]
    }
   ],
   "source": [
    "cout << \"Enter an Integer number: \";\n",
    "cin >> number;\n",
    "cout << number << \" is \" << ((number%2 == 0) ? \"even\" : \"odd\");"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Logical operators\n",
    "- often times programs need to evaluate complex logics involving two or more logical expressions (conditions)\n",
    "- C++ provides three logical operators to evaluate complex boolean expressions\n",
    "\n",
    "| operator | alternative | example | description |\n",
    "| :--- | :--- | :--- | :--- |\n",
    "| && | and | cond1 && cond2 | Is condition 1 true AND condition 2 is also true? |\n",
    "| \\|\\| | or | cond1 \\|\\| cond2 | Is condition 1 is true OR condition 2 is true? |\n",
    "| ! |  not | !condition | Is NOT condition true or false? |\n",
    "\n",
    "- `&&` and `||` are binary operators\n",
    "- `!` is an unary operator\n",
    "- can also use alternative names `and` and `or` and `not` in-place of the symbols\n",
    "- symbols usage are more common compared to names in C/C++\n",
    "\n",
    "- let's say if **a** and **b** are logical expression resulting **true (T)** or **false (F)**\n",
    "    - the following truth table provides the final outcome of these logical operators\n",
    "    \n",
    "### Truth table for && (and)\n",
    "| a | b  | a **&&** b |\n",
    "| --- | --- | --- |\n",
    "| T | T |  T |\n",
    "|T | F |  F |\n",
    "|F | T |  F |\n",
    "|F | F |  F |\n",
    "\n",
    "### Truth table for || (or)\n",
    "| a | b  | a **\\|\\|** b |\n",
    "| --- | --- | --- |\n",
    "| T | T |  T |\n",
    "|T | F |  T |\n",
    "|F | T |  T |\n",
    "|F | F |  F |\n",
    "\n",
    "### Truth table for ! (not)\n",
    "|a  |  ! a |\n",
    "|---|---|\n",
    "|T  |   F |\n",
    "|F  |   T |\n",
    "\n",
    "### Order of evaluation\n",
    "- if all three operators are found in the same expression:\n",
    "    - `!` is evaluated first, `&&` second and finally `||`\n",
    "- complete C++ operator precedence order can be found here: https://en.cppreference.com/w/cpp/language/operator_precedence"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "enter a whole number: 50\n",
      "number is even and positve\n"
     ]
    }
   ],
   "source": [
    "// && examples\n",
    "// determine if a number is even and positve\n",
    "cout << \"enter a whole number: \";\n",
    "cin >> num;\n",
    "if (num > 0 and num%2 == 0)\n",
    "    cout << \"number is even and positve\\n\";\n",
    "else\n",
    "    cout << \"I don't know much about \" << num << \" except that it's an integer\\n\";"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "// || or example\n",
    "// write a program that determines if somone can retire.\n",
    "// if a person owns a Ferrari or has 1 Million dollors in savings then the person can retire\n",
    "string has_ferrari;\n",
    "long savings;"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Do you own a Ferarrai? Enter [y|yes]: yes\n",
      "How much in savings do you have in dollars? 0\n",
      "Congratulations, you can retire now!\n"
     ]
    }
   ],
   "source": [
    "cout << \"Do you own a Ferarrai? Enter [y|yes]: \";\n",
    "cin >> has_ferrari;\n",
    "cout << \"How much in savings do you have in dollars? \";\n",
    "cin >> savings;\n",
    "if (has_ferrari == \"yes\" or has_ferrari == \"y\" or savings >= 1000000)\n",
    "    cout << \"Congratulations, you can retire now!\\n\";\n",
    "else\n",
    "    cout << \"Sorry, no cigar! Keep working...\\n\";"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Do you own a Ferarrai? Enter [y|yes]: no\n",
      "How much in savings do you have in dollars? 10\n",
      "Sorry, no cigar! Keep working...\n"
     ]
    }
   ],
   "source": [
    "// ! example\n",
    "// redo retirement calculator\n",
    "cout << \"Do you own a Ferarrai? Enter [y|yes]: \";\n",
    "cin >> has_ferrari;\n",
    "cout << \"How much in savings do you have in dollars? \";\n",
    "cin >> savings;\n",
    "if (!(has_ferrari == \"yes\" || has_ferrari == \"y\" or savings >= 1000000))\n",
    "    cout << \"Sorry, no cigar! Keep working...\\n\";\n",
    "else\n",
    "    cout << \"Congratulations, you can retire now!\\n\";"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Passing arguments to main\n",
    "\n",
    "- `main( )` can also take arguments\n",
    "- since main is never called, arguments are provided when the program is ran from a terminal\n",
    "- the program doesn't have to interactively prompt user to enter required data\n",
    "- syntax:\n",
    "```cpp\n",
    "    int main(int argc, char* argv[]) {\n",
    "        // argc is total no. of arguments provided to the program\n",
    "        // automatically calcuated by the system based on the no. of arguments\n",
    "        // argc is atleast 1\n",
    "        // argv is an array of char* (c_string; similar in concept to C++ string)\n",
    "        // contains name of the program and all the user provided arguments\n",
    "\n",
    "        // body of main\n",
    "        return 0;\n",
    "    }\n",
    "```\n",
    "\n",
    "- pass space separated arguments to main or program\n",
    "- use double quotes for arguments with spaces\n",
    "- all the arguments are treated as C-string\n",
    "    - must convert numeric arguments to numeric types\n",
    "\n",
    "```bash\n",
    "    $ programName.exe arg1 arg2 arg3 \"multiple word arguments\" ...\n",
    "    $ git add \"Filename.cpp\" # add and \"Filename.cpp\" are arguments to git's main()\n",
    "```\n",
    "\n",
    "### demo programs\n",
    "1. simple demo [demos/conditionals/main_arg1/main_arg1.cpp](demos/conditionals/main_arg1/main_arg1.cpp)\n",
    "2. more useful demo: [demos/conditionals/main_arg2.cpp](demos/conditionals/main_arg2/main_arg2.cpp)\n",
    "3. Kattis Hello World problem with test case: [hello](https://github.com/rambasnet/KattisDemos/blob/master/hello/C%2B%2B/hello.cpp)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Switch statement\n",
    "- switch statment is very similar to chained conditional or multi-way selector\n",
    "- allows a variable to be tested for equality against a list of values\n",
    "- each value is called a case\n",
    "- syntax:\n",
    "```cpp\n",
    "    switch(integral-expression) {\n",
    "        case constant-expression:\n",
    "            statement(s);\n",
    "            break; // optional\n",
    "        case constant-expression:\n",
    "            statements(s);\n",
    "            break; // optional\n",
    "        // more case statements\n",
    "        default: // Optional\n",
    "            statements(s);\n",
    "    }\n",
    "```\n",
    "- switch only works on integral type variables (int, char, long, etc.)\n",
    "- when break statement is reached, switch terminates\n",
    "- if no break statement is encountered, the statements following that case will execute until a break statement is reached or switch statments terminates\n",
    "- the following figure demonstrates the flow of execution in switch statement\n",
    "\n",
    "![](resources/switch.png)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [],
   "source": [
    "// e.g. of a switch statement\n",
    "// determine name of the day given the number 1-7\n",
    "unsigned int day;"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter day of the week 1-7: 6\n"
     ]
    }
   ],
   "source": [
    "cout << \"Enter day of the week 1-7: \";\n",
    "cin >> day;"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Day is Friday\n"
     ]
    }
   ],
   "source": [
    "// comment out break; and see the result\n",
    "switch(day) {\n",
    "    case 1: \n",
    "        cout << \"Day is Sunday\\n\";\n",
    "        break;\n",
    "    case 2:\n",
    "        cout << \"Day is Monday\\n\";\n",
    "        break;\n",
    "    case 3:\n",
    "        cout << \"Day is Tuesday\\n\";\n",
    "        break;\n",
    "    case 4:\n",
    "        cout << \"Day is Wednesday\\n\";\n",
    "        break;\n",
    "    case 5:\n",
    "        cout << \"Day is Thursday\\n\";\n",
    "        break;\n",
    "    case 6:\n",
    "        cout << \"Day is Friday\\n\";\n",
    "        break;\n",
    "    case 7:\n",
    "        cout << \"Day is Saturday\\n\";\n",
    "        break;\n",
    "    default:\n",
    "        cout << day << \" is not a valid day!\\n\";\n",
    "        //break; not required!\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Menu-driven CLI interface\n",
    "- command-line interface (CLI), though not as intuitive as Graphical User Interface (GUI), is still used widely\n",
    "- airline reservation systems, check-in and printing boarding passes, point-of-sale (POS) terminals at big companies such as Lowe's, Home Depot, etc. use CLI\n",
    "- a lot of text-based games used CLI as well\n",
    "\n",
    "- a good application of switch statement is in developing menu-driven CLI\n",
    "\n",
    "### write a menu-driven C++ program that calculates various statistics of any 2 numbers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [],
   "source": [
    "#include <iostream>\n",
    "#include <string>\n",
    "#include <cassert>\n",
    "#include <cmath>\n",
    "#include <iomanip>\n",
    "#include <sstream>\n",
    "\n",
    "using namespace std;"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [],
   "source": [
    "template<class T>\n",
    "T add(T val1, T val2) {\n",
    "    return val1 + val2;\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [],
   "source": [
    "template<class T>\n",
    "T subtract(T val1, T val2) {\n",
    "    return val1 - val2;\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [],
   "source": [
    "template<class T>\n",
    "T larger(T val1, T val2) {\n",
    "    return val1 >= val2 ? val1 : val2;\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [],
   "source": [
    "template<class T>\n",
    "double average(T val1, T val2) {\n",
    "    return add(val1, val2)/2.0;\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [],
   "source": [
    "int getMenuOption() {\n",
    "    // A Smiple CLI-based calculator\n",
    "    int option;\n",
    "    cout << \"Enter one of the following menu options: [1-6]\\n\"\n",
    "        \"1 -> Add\\n\"\n",
    "        << \"2 -> Subtract\\n\"\n",
    "        << \"3 -> Larger\\n\"\n",
    "        << \"4 -> Average\\n\"\n",
    "        << \"5 -> Multiply\\n\"\n",
    "        << \"6 -> Quit\\n\";\n",
    "    cin >> option;\n",
    "    return option;\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [],
   "source": [
    "void program() {\n",
    "    float n1, n2;\n",
    "    int option;\n",
    "    option = getMenuOption();\n",
    "    if (option == 6) {\n",
    "        cout << \"Good bye...\\n\";\n",
    "        return;\n",
    "    }\n",
    "    cout << \"Enter two numbers separated by space: \";\n",
    "    cin >> n1 >> n2;\n",
    "    switch(option) {\n",
    "        case 1:\n",
    "            cout << n1 << \" + \" << n2 << \" = \" << add<float>(n1, n2) << endl;\n",
    "            break; // terminate switch\n",
    "        case 2:\n",
    "            cout << n1 << \" - \" << n2 << \" = \" << subtract<float>(n1, n2) << endl;\n",
    "            break;\n",
    "        case 3:\n",
    "            cout << \"larger between: \" << n1 << \" and \" << n2 << \" is \" << larger<float>(n1, n2) << endl;\n",
    "            break;\n",
    "        case 4:\n",
    "            cout << \"average of \" << n1 << \" and \" << n2 << \" = \" << average<float>(n1, n2) << endl;\n",
    "            break;\n",
    "        default:\n",
    "            cout << n1 << \" x \" << n2 << \" = \" << n1*n2 << endl;\n",
    "            break;\n",
    "    }\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter one of the following menu options: [1-6]\n",
      "1 -> Add\n",
      "2 -> Subtract\n",
      "3 -> Larger\n",
      "4 -> Average\n",
      "5 -> Multiply\n",
      "6 -> Quit\n",
      "1\n",
      "Enter two numbers separated by space: 3 105\n",
      "3 + 105 = 108\n"
     ]
    }
   ],
   "source": [
    "// TODO: run this many times...\n",
    "program();"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Note: a loop would work better for menu-driven program\n",
    "\n",
    "- loop is covered in next chapter\n",
    "\n",
    "### A complete demo program is here: [demos/conditionals/menu/menu.cpp](demos/conditionals/menu/menu.cpp)\n",
    "\n",
    "### Rectangle demo program [demos/conditionals/rectangle/main.cpp](demos/conditionals/rectangle/main.cpp)\n",
    "- An improvded Rectangle program from previous chapter that calls automated test when user wants to by passing argument to the main"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercises\n",
    "1. Write a program that helps someone decide where to go eat lunch depending on amount of money one has in their pocket.\n",
    "\n",
    "\n",
    "2. Improve exercise 1 by using function(s) and writing at least 3 test cases for each function.\n",
    "\n",
    "\n",
    "3. Write a program that determines whether someone is eligible to vote in the US federal election.\n",
    "    - see sample solution here [exercises/conditionals/vote1/voting_eligibility.cpp](exercises/conditionals/vote1/voting_eligibility.cpp)\n",
    "\n",
    "\n",
    "4. Improve exercise 3 by using function(s) and writing at least 3 test cases for each function.\n",
    "    - see sample solution here [exercises/conditionals/vote2/voting_eligibility_v2.cpp](exercises/conditionals/vote2/voting_eligibility_v2.cpp)\n",
    "\n",
    "\n",
    "5. Write a function day_name that converts an integer number 0 to 6 into the name of a day. Assume day 0 is \"Sunday\". Return \"Invalid Day\" if the argument to the function is not valid."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [],
   "source": [
    "// code stub for Exercise 5\n",
    "string day_name(int day) {\n",
    "    // FIXME - complete the rest\n",
    "    return \"\";\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "// Here are some tests that should pass for day_name function defined above\n",
    "void test_day_name() {\n",
    "    assert(day_name(3) == \"Wednesday\");\n",
    "    assert(day_name(6) == \"Saturday\");\n",
    "    assert(day_name(42) == \"Invalid Day\");\n",
    "    cout << \"all test cases passed for day_name()\\n\";\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "6. Improve exercise 5 as a complete program with algorithm stepts, main(), etc."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "7. Write a function that helps answer questions like \"Today is Wednesday. I leave on holiday in 19 days time. What day will that be?\" So, the function must take a day name and a delta argument (the number of days to add) and should return the resulting day name."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "// Exercise 6 hints\n",
    "string day_add(string dayName, int delta) {\n",
    "    // FIXME\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "// Exercise 6 test function\n",
    "// here are some tests that should pass\n",
    "void test_day_add() {\n",
    "    assert(day_add(\"Monday\", 4) ==  \"Friday\");\n",
    "    assert(day_add(\"Tuesday\", 0) == \"Tuesday\");\n",
    "    assert(day_add(\"Tuesday\", 14) == \"Tuesday\");\n",
    "    assert(day_add(\"Sunday\", 100) == \"Tuesday\");\n",
    "    assert(day_add(\"Sunday\", -1) == \"Saturday\");\n",
    "    assert(day_add(\"Sunday\", -7) == \"Sunday\");\n",
    "    assert(day_add(\"Tuesday\", -100) == \"Sunday\");\n",
    "    cout << \"all test cases passed for day_add()\";\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "8. Improve Exercise 7 as a complete program with algorithm steps, main(), etc.\n",
    "\n",
    "\n",
    "9. Write a C++ program including algorithm steps that calculates area and perimeter of a triangle given three sides.\n",
    "    - must define and use separate functions to calculate area and perimeter\n",
    "    - write at least 3 test cases for each function\n",
    "    - Hint: use Heron's formula to find area with three sides.\n",
    "    - define and use function to determine if 3 sides form a triangle\n",
    "    \n",
    "    \n",
    "10. Write a C++ program including algorithm steps that calculates Body Mass Index (BMI) of a person.\n",
    "    - must use as many functions as possible\n",
    "    - write at least 3 test cases for each function\n",
    "    - more info on BMI - https://www.nhlbi.nih.gov/health/educational/lose_wt/BMI/bmicalc.htm\n",
    "    - Formula [here]( https://www.cdc.gov/healthyweight/assessing/bmi/childrens_bmi/childrens_bmi_formula.html#:~:text=The%20formula%20for%20BMI%20is,to%20convert%20this%20to%20meters.&text=When%20using%20English%20measurements%2C%20pounds%20should%20be%20divided%20by%20inches%20squared).\n",
    "    - a sample solution is provided at [exercises/conditionals/BMI/BMI_v3.cpp](exercises/conditionals/BMI/BMI_v3.cpp)\n",
    "        - **an improved version that interprets the BMI result**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Kattis Problems\n",
    "- almost all Kattis problems require conditional statements\n",
    "- following are some problems that can be solved based on the concepts learned from Ch1-6\n",
    "- solve each problem using function(s)\n",
    "- write at least 3 test cases for each function\n",
    "\n",
    "1. Take Two Stones - https://open.kattis.com/problems/twostones\n",
    "    - Hint: check even or odd\n",
    "\n",
    "\n",
    "2. Laptop Sticker - https://open.kattis.com/problems/laptopsticker\n",
    "    - Hint: basic math\n",
    "    \n",
    "\n",
    "3. Sort Two Numbers - https://open.kattis.com/problems/sorttwonumbers\n",
    "    - Hint: compare two numbers and print their order\n",
    "    \n",
    "    \n",
    "4. FYI - https://open.kattis.com/problems/fyi\n",
    "    - Hint: string.find() and condition\n",
    "    \n",
    "\n",
    "5. Astrological Sign - https://open.kattis.com/problems/astrologicalsign\n",
    "    - Hint: 12 outer conditions; for each month check two data ranges\n",
    "    \n",
    "    \n",
    "6. Right-of-Way - https://open.kattis.com/problems/vajningsplikt\n",
    "    - Hint: many cases just follow the cases for yield as required and everything else is No yield\n",
    "    \n",
    "    \n",
    "7. Knight Packing - https://open.kattis.com/problems/knightpacking\n",
    "    - Hint: check even or odd\n",
    "    \n",
    "    \n",
    "8. Chocolate Division - https://open.kattis.com/problems/chocolatedivision\n",
    "    - Hint: check even or odd"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Summary\n",
    "- we learned about another fundamental concepts: conditional execution\n",
    "- learned with examples 3 different types of conditional statements\n",
    "- learned how to use conditional statements in functions\n",
    "- learned about ternary conditional operator (condition) ? exp1 : exp2\n",
    "    - a short cut for alternative execution\n",
    "- learned about comparision and logical operators; order of precedence\n",
    "- learned passing and using arguments to main( )\n",
    "- finally, exercise and sample solutions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "C++14",
   "language": "C++14",
   "name": "xcpp14"
  },
  "language_info": {
   "codemirror_mode": "text/x-c++src",
   "file_extension": ".cpp",
   "mimetype": "text/x-c++src",
   "name": "c++",
   "version": "14"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}