[10_Questions]_QUIZ_Conditional_Statements.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "upset-links",
   "metadata": {},
   "source": [
    "## [10 Questions] QUIZ - Conditional Statements"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "worldwide-loading",
   "metadata": {},
   "source": [
    "**Q 1:**\n",
    "\n",
    "Ask the user to enter a number.\n",
    "\n",
    "Find out if this number is Odd or Even."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "convenient-discipline",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "please enter a number: 5\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5 is odd number\n"
     ]
    }
   ],
   "source": [
    "# S 1:\n",
    "\n",
    "x = int(input('please enter a number:'))\n",
    "\n",
    "if x % 2 == 0:\n",
    "    print(x, ' is Even')\n",
    "\n",
    "else:\n",
    "    print(x,'is odd ')\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "relevant-disposition",
   "metadata": {},
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "composed-colony",
   "metadata": {},
   "source": [
    "**Q 2:**\n",
    "\n",
    "Ask for a letter from the user.\n",
    "\n",
    "Find out if it is a vowel or consonant."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "deluxe-protection",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "kindly enter a letter: R\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "consonant: R\n"
     ]
    }
   ],
   "source": [
    "# S 2:\n",
    "\n",
    "#ask for a letter\n",
    "letters = input('kindly enter a letter:')\n",
    "\n",
    "if letters in ( 'a','e','i','o','u'):\n",
    "    print ('vowel:', letters)\n",
    "else:\n",
    "    print('consonant:', letters)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cordless-savannah",
   "metadata": {},
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "indoor-hughes",
   "metadata": {},
   "source": [
    "**Q 3:**\n",
    "\n",
    "Define a function named **which_shape**.\n",
    "\n",
    "The function will ask a number from the user.\n",
    "\n",
    "It will decide the name of the shape according to that number, and return that name.\n",
    "\n",
    "Sides & Shapes:\n",
    "* 3 - Triangle\n",
    "* 4 - Rectangle\n",
    "* 5 - Pentagon\n",
    "* 6 - Hexagon\n",
    "* 7 and more - Polygon"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6b7e85a2-a432-4c14-aa68-1c0b51ed69ba",
   "metadata": {},
   "outputs": [],
   "source": [
    "def which_shape():\n",
    "    \"\"\"\n",
    "    Asks for a number and returns the name of the shape.\n",
    "    Parameters: None\n",
    "    Returns: str shape_name\n",
    "    \"\"\"\n",
    "\n",
    "    # get the number\n",
    "    number_of_sides = int(input(\"Please enter the number of sides: \"))\n",
    "    \n",
    "    # define a variable to keep the shape name\n",
    "    shape_name = \"\"\n",
    "    \n",
    "    if number_of_sides == 3:\n",
    "        shape_name = 'Triangle'\n",
    "    elif number_of_sides == 4:\n",
    "        shape_name = 'Rectangle'\n",
    "    elif number_of_sides == 5:\n",
    "        shape_name = 'Pentagon'\n",
    "    elif number_of_sides == 6:\n",
    "        shape_name = 'Hexagon'\n",
    "    else:\n",
    "        shape_name = 'Polygon'\n",
    "    \n",
    "    # return the shape name\n",
    "    return shape_name\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "adequate-transition",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "please enter number of sides:  9\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "polygon\n"
     ]
    }
   ],
   "source": [
    "# S 3:\n",
    "\n",
    "def which_shape():\n",
    "    number_of_sides = int(input('please enter number of sides: '))\n",
    "    \n",
    "    # define a variable to keep the shape name\n",
    "    shape_name = \"\"\n",
    "    \n",
    "    if number_of_sides == 3:\n",
    "        print('Triangle')\n",
    "    elif number_of_sides == 4:\n",
    "        print('Rectangle')\n",
    "    elif number_of_sides == 5:\n",
    "        print ('Pentagon')\n",
    "    elif number_of_sides ==6:\n",
    "        print ('Hexagon')\n",
    "    elif number_of_sides <3:\n",
    "        print ('void')\n",
    "    else :\n",
    "        print ('polygon')\n",
    "    return\n",
    "\n",
    "which_shape()\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "seventh-beauty",
   "metadata": {},
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9378986d-6f77-4bd3-8ed4-d5ca923954d6",
   "metadata": {},
   "source": [
    "Q4\n",
    "\n",
    "Define a function to print the number_of_days in the given month.\n",
    "\n",
    "Function name will be number_of_days_in_month.\n",
    "\n",
    "It will ask month name from the user.\n",
    "\n",
    "Number of Days in Gregorian Calendar:\n",
    "January - 31\n",
    "February - 28 or 29\n",
    "March - 31\n",
    "April - 30\n",
    "May - 31\n",
    "June - 30\n",
    "July - 31\n",
    "August - 31\n",
    "September - 30\n",
    "October - 31\n",
    "November - 30\n",
    "December - 31\n",
    "\n",
    "pre\n",
    "Expected Output:\n",
    "Please enter the month name:  October\n",
    "'There are 31 days in October'\n",
    "pre"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5ac9d756-d15b-4b5a-9511-b5321d893746",
   "metadata": {},
   "outputs": [],
   "source": [
    "def number_of_days_in_month():\n",
    "    \n",
    "    # variable for number of days\n",
    "    days = 31\n",
    "    \n",
    "    # ask for the month\n",
    "    month = input(\"Please enter the month name: \")\n",
    "    \n",
    "    # Now check months with number of days 28-29, 30 and 31\n",
    "    \n",
    "    if month == 'April' or month == 'June' or \\\n",
    "       month == 'September' or month == 'November':\n",
    "        days = 30\n",
    "    elif month == 'February':\n",
    "        days = '28 or 29'\n",
    "        \n",
    "    return 'There are ' + str(days) + ' days in ' + str(month)\n",
    "#print(\"There are \"+ format(days) +\" days in \" + format(month_name))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "83eaa60b-79e4-465b-a61f-d9616a7636d9",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "The name of Month:  march\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "'There are 31 days in March'"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# S 4:\n",
    "def number_of_days_in_month():\n",
    "    # ask for the month\n",
    "    month_name = input(\"The name of Month: \").title()\n",
    "    \n",
    "    # variable for number of days\n",
    "    days = \"\"\n",
    "    \n",
    "    if month_name in (\"April\",\"June\",\"September\",\"November\"):\n",
    "        days = 30\n",
    "        \n",
    "    elif month_name in (\"January\",\"March\",\"May\",\"July\", \"August\", \"October\", \"December\"):\n",
    "        days = 31    \n",
    "        \n",
    "    elif month_name == \"February\":\n",
    "        days = 28 or 29\n",
    "        \n",
    "    else:\n",
    "        days = 0\n",
    "        \n",
    "    return 'There are ' + str(days) + ' days in ' + month_name \n",
    "\n",
    "number_of_days_in_month()\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "27bf8230-cccc-448a-b25a-ca863cfd681d",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "74eecd3b-6b7f-48df-b9bd-e24cf31d566b",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "proud-watch",
   "metadata": {},
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "80374045-5c9f-4cd4-8d94-8112c917522d",
   "metadata": {},
   "source": [
    "**Q 5:**\n",
    "\n",
    "Define a function to ask the length of sides of a triangle.\n",
    "\n",
    "Function name is **name_the_triangle**.\n",
    "\n",
    "The function will decide the type of triangle, according to the sides length.\n",
    "\n",
    "And will return its name.\n",
    "\n",
    "Types of Triangles:\n",
    "* Equilateral: three equal sides\n",
    "* Isosceles: two equal sides\n",
    "* Scalene: no equal sides"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "a5089c99-9112-4bde-8e7f-950d6cef6608",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Length for the first side:  3\n",
      "Length for the second side:  3\n",
      "Length for the third side:  4\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "'Isosceles'"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def name_the_triangle():\n",
    "    \n",
    "    # variable to keep name\n",
    "    name = \"\"\n",
    "    \n",
    "    # ask for lengths\n",
    "    side_1 = float(input('Length for the first side: '))\n",
    "    side_2 = float(input('Length for the second side: '))\n",
    "    side_3 = float(input('Length for the third side: '))\n",
    "    \n",
    "    # conditions\n",
    "    if side_1 == side_2 and side_1 == side_3:\n",
    "        name = 'Equilateral'\n",
    "    elif side_1 == side_2 or side_1 == side_3 or side_2 == side_3:\n",
    "        name = 'Isosceles'\n",
    "    else:\n",
    "        name = 'Scalene'\n",
    "    \n",
    "    return name\n",
    "name_the_triangle()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f5e8d198-08bb-4709-a16c-02ad6b7cc9fd",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "smoking-perfume",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Input lengths of the triangle sides:\n"
     ]
    },
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "x:  2\n",
      "y:  3\n",
      "z:  3\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "isosceles triangle\n"
     ]
    }
   ],
   "source": [
    "# S 5:\n",
    "\n",
    "def name_the_triangle():\n",
    "\n",
    "    print(\"Input lengths of the triangle sides:\")\n",
    "    x = int(input(\"x: \"))\n",
    "    y = int(input(\"y: \"))\n",
    "    z = int(input(\"z: \"))\n",
    "\n",
    "    if x == y == z:\n",
    "        print(\"Equilateral triangle\")\n",
    "    elif x==y or y==z or z==x:\n",
    "        print(\"isosceles triangle\")\n",
    "    else:\n",
    "        print(\"Scalene triangle\")\n",
    "        \n",
    "    \n",
    "name_the_triangle()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "66345350-d9ee-4422-a5dd-a6250c507572",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "numerical-international",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Input lengths of the triangle sides:\n"
     ]
    },
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "x:  3\n",
      "y:  10\n",
      "z:  30\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Scalene triangle\n"
     ]
    }
   ],
   "source": [
    "name_the_triangle()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "acute-suggestion",
   "metadata": {},
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8e39671e-bc00-4fbc-b52d-13bcb5c13255",
   "metadata": {},
   "source": [
    "**Q 6:**\n",
    "\n",
    "Define a function that decides what to wear, according to the month and number of the day.\n",
    "\n",
    "Function name will be **what_to_wear** and it will ask for the name of the month and day number.\n",
    "\n",
    "According to month and day number, it will check for the season and with season, it will return what to wear.\n",
    "\n",
    "<pre>\n",
    "Seasons and Garments \n",
    "Spring: Shirt\n",
    "Summer: T-shirt\n",
    "Autumn: Sweater\n",
    "Winter: Coat\n",
    "\n",
    "The Solstices:\n",
    "* June (21)\n",
    "* December (21)\n",
    "\n",
    "The Equinoxes:\n",
    "* March (21)\n",
    "* September (23)\n",
    "\n",
    "Expected Output:\n",
    "Enter month name:  March\n",
    "Enter day number:  24\n",
    "In March, day 24 we wear Shirt\n",
    "</pre>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b93753d9-d7f6-4acf-9053-6cacfdbcf185",
   "metadata": {},
   "outputs": [],
   "source": [
    "def what_to_wear():\n",
    "    \n",
    "    # ask for month and day number\n",
    "    month = input(\"Enter month name: \")\n",
    "    day = int(input(\"Enter day number: \"))\n",
    "\n",
    "    # keep the garment\n",
    "    garment = \"\"\n",
    "    \n",
    "    # decide what to wear\n",
    "    if month == 'January' or month == 'February':\n",
    "        garment = 'Coat'\n",
    "    elif month == 'March':\n",
    "        # March 21\n",
    "        if day < 21:\n",
    "            garment = 'Coat'\n",
    "        else:\n",
    "            garment = 'Shirt'\n",
    "    elif month == 'April' or month == 'May':\n",
    "        garment = 'Shirt'\n",
    "    elif month == 'June':\n",
    "        # June 21\n",
    "        if day < 21:\n",
    "            garment = 'Shirt'\n",
    "        else:\n",
    "            garment = 'T-shirt'\n",
    "    elif month == 'July' or month == 'August':\n",
    "        garment = 'T-shirt'\n",
    "    elif month == 'September':\n",
    "        # September 23\n",
    "        if day < 23:\n",
    "            garment = 'T-shirt'\n",
    "        else:\n",
    "            garment = 'Sweater'\n",
    "    elif month == 'October' or month == 'November':\n",
    "        garment = 'Sweater'\n",
    "    elif month == 'December':\n",
    "        # December 21\n",
    "        if day < 21:\n",
    "            garment = 'Sweater'\n",
    "        else:\n",
    "            garment = 'Coat'\n",
    "            \n",
    "    print('In {0}, day {1} we wear {2}'.format(month, day, garment))\n",
    "#print (\"In day \" + format(date) + \" of \" + \n",
    "#format(month) + \" which is \" + format(season) + \" we wear \"  + format(garment))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "bridal-longer",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter the month: august\n",
      "Enter the date: 21\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "In day 21 of August which is Summer we wear T-shirt\n"
     ]
    }
   ],
   "source": [
    "# S 6:\n",
    "# Read the date from the user\n",
    "def what_to_wear():\n",
    "#ask for month and date\n",
    "    month = input(\"Enter the month:\").title()\n",
    "    date = int(input(\"Enter the date:\"))\n",
    "\n",
    "# Determine the season & garments\n",
    "    if month in (\"January\",\"February\"):\n",
    "        season = \"winter\"\n",
    "        garment = \"Coat\"\n",
    "    elif month == \"March\":\n",
    "        if date >20:\n",
    "            season = \"Spring\"\n",
    "            garment = \"shirt\"\n",
    "        else:\n",
    "            season = \"Winter\"\n",
    "            garment = \"Coat\"\n",
    "        \n",
    "    elif month in (\"April\",\"May\"):\n",
    "        season = \"Spring\"\n",
    "        garment = \"shirt\"\n",
    "    elif month == \"June\":\n",
    "        if date >20:\n",
    "            season = \"Summer\"\n",
    "            garment = \"T-shirt\"\n",
    "        else:\n",
    "            season = \"Spring\"\n",
    "            garment = \"shirt\"\n",
    "        \n",
    "    elif month in (\"July\", \"August\"):\n",
    "        season = \"Summer\"\n",
    "        garment = \"T-shirt\"\n",
    "    elif month == \"September\":\n",
    "        if date > 22:\n",
    "            season = \"Autumn\"\n",
    "            garment = \"Sweater\"\n",
    "        else:\n",
    "            season = \"Summer\"\n",
    "            garment = \"T-shirt\"\n",
    "    \n",
    "    elif month in (\"October\",\"November\",):\n",
    "        season = \"Autumn\"\n",
    "        garment = \"Sweater\"\n",
    "    elif month == \"December\":\n",
    "        if date > 20:\n",
    "            season = \"Winter\"\n",
    "            garment = \"Coat\"\n",
    "        else:\n",
    "            season = \"Autumn\"\n",
    "            garment = \"Sweater\"\n",
    "    \n",
    "    print('In day {0} of {1} which is {2} we wear {3}'.format(date,month, season, garment))\n",
    "    \n",
    "    \n",
    "what_to_wear()\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "instrumental-machinery",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter the month: december\n",
      "Enter the date: 25\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "In day 25 of December which is Winter we wear Coat\n"
     ]
    }
   ],
   "source": [
    "what_to_wear()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "japanese-butter",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "surprising-leone",
   "metadata": {},
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "falling-marker",
   "metadata": {},
   "source": [
    "**Q 7:**\n",
    "\n",
    "Define a function named **which_day**.\n",
    "\n",
    "It will ask for any of the capital letters: F, M, S, T, W\n",
    "\n",
    "These are the first letters of the day names in a week.\n",
    "\n",
    "The function will decide which day by the first letter.\n",
    "\n",
    "It may ask additional questins if needed?\n",
    "\n",
    "Days:\n",
    "* Monday, Tuesday, Wednesday, Thursday, Friday, Saturday, Sunday\n",
    "\n",
    "Additional questions by letter:\n",
    "* S: \n",
    "    * \"first day of weekend\" or \n",
    "    * \"last day of weekend\"\n",
    "* T: \n",
    "    * \"at the beginning of the week\" or \n",
    "    * \"at the middle of the week\"\n",
    "    \n",
    "<pre>\n",
    "Expected Output:\n",
    "Please enter any of the capital letters: F, M, S, T, W :  T\n",
    "Is it at the beginning of the week? Yes - No? No\n",
    "Your day: THURSDAY\n",
    "</pre>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4babbcda-250e-432e-bb8c-b945afbd6830",
   "metadata": {},
   "outputs": [],
   "source": [
    "def which_day():\n",
    "    \n",
    "    # ask for a letter\n",
    "    letter = input(\"Enter one of: F, M, S, T, W  : \")\n",
    "    \n",
    "    # check if the letter is in list\n",
    "    if not (letter == 'F' or letter == 'M' or letter == 'S' or letter == 'T' or letter == 'W'):\n",
    "        print(\"Wrong letter.\")\n",
    "        return\n",
    "    \n",
    "    # if the letter is correct\n",
    "    \n",
    "    else:\n",
    "        \n",
    "        # lettter controls\n",
    "        # F\n",
    "        if letter == 'F':\n",
    "            day = 'FRIDAY'\n",
    "        \n",
    "        # M\n",
    "        elif letter == 'M':\n",
    "            day = 'MONDAY'\n",
    "            \n",
    "        # S\n",
    "        elif letter == 'S':\n",
    "            # ask additional question\n",
    "            first_day_of_weekend = input('Is it the first day of the weekend? Yes - No: ')\n",
    "            \n",
    "            if first_day_of_weekend == 'Yes':\n",
    "                day = 'SATURDAY'\n",
    "            else:\n",
    "                day = 'SUNDAY'\n",
    "                \n",
    "        \n",
    "        # T\n",
    "        elif letter == 'T':\n",
    "            # ask additional question\n",
    "            beginning_of_week = input('Is it at the beginning of the week? Yes - No : ')\n",
    "            \n",
    "            if beginning_of_week == 'Yes':\n",
    "                day = 'TUESDAY'\n",
    "            else:\n",
    "                day = 'THURSDAY'\n",
    "            \n",
    "        # W\n",
    "        elif letter == 'W':\n",
    "            day = 'WEDNESDAY'\n",
    "    \n",
    "        \n",
    "        print('Your day:', day)\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "cardiovascular-yorkshire",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Please enter any of the letters: F, M, S, T, W : t\n",
      "Is it at the beginning of the week?Yes - No?: yes\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Your day: TUESDAY\n"
     ]
    }
   ],
   "source": [
    "# S 7:\n",
    "\n",
    "def which_day():\n",
    "    \n",
    "    Days_of_the_week =input(\"Please enter any of the letters: F, M, S, T, W :\").upper()\n",
    "    D = Days_of_the_week\n",
    "    #define your_day as an empty string\n",
    "    if D ==\"S\":\n",
    "        # ask additional question\n",
    "        first_day_of_the_week=input(\"Is it the first day of weekend?Yes - No?:\").title()\n",
    "        if first_day_of_the_week== \"Yes\":\n",
    "            print(\"Your day: \" \"SATURDAY\")\n",
    "        else:\n",
    "            print(\"Your day: \" \"SUNDAY\")\n",
    "    elif D==\"T\":\n",
    "        # ask additional question\n",
    "        beginning_of_the_weekend=input(\"Is it at the beginning of the week?Yes - No?:\").title()\n",
    "        if beginning_of_the_weekend== \"Yes\":\n",
    "            print(\"Your day: \" \"TUESDAY\")\n",
    "        else:\n",
    "            print(\"Your day: \" \"THURSDAY\")\n",
    "    elif D==\"F\":\n",
    "        print(\"Your day: \" \"FRIDAY\")\n",
    "    elif D==\"M\":\n",
    "        print(\"Your day: \" \"MONDAY\")\n",
    "    elif D==\"W\": \n",
    "        print(\"Your day: \" \"WEDNESDAY\")\n",
    "    \n",
    "    \n",
    "    \n",
    "which_day()\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "id": "binding-profit",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Please enter any of the letters: F, M, S, T, W : T\n",
      "Is it at the beginning of the week?Yes - No?: No\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Your day: THURSDAY\n"
     ]
    }
   ],
   "source": [
    "which_day()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "id": "metropolitan-heritage",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Please enter any of the letters: F, M, S, T, W : W\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Your day: WEDNESDAY\n"
     ]
    }
   ],
   "source": [
    "which_day()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "id": "removable-backing",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Please enter any of the letters: F, M, S, T, W : M\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Your day: MONDAY\n"
     ]
    }
   ],
   "source": [
    "which_day()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "indian-pathology",
   "metadata": {},
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "spiritual-blend",
   "metadata": {},
   "source": [
    "**Q 8:**\n",
    "\n",
    "Define a function named **odds_evens**.\n",
    "\n",
    "It will ask for a pozitif number from the user.\n",
    "\n",
    "Check if the input is an integer or not.\n",
    "\n",
    "Also check if the number is a positive number.\n",
    "\n",
    "Decide if the number is ODD or EVEN and print:\n",
    "* If the number is odd -> ODD\n",
    "* If the number is event and between 1 and 10 (both included) -> EVEN of TEN\n",
    "* If the number is even and between 11 and 20 (both included) -> EVEN of TWENTY\n",
    "* If the number is even and greater than 20 -> EVEN\n",
    "\n",
    "<pre>\n",
    "Expected Output:\n",
    "Plase enter a number:  18\n",
    "EVEN of TWENTY\n",
    "</pre>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "cbf521de-e542-47bc-9ce4-e8609c2545e3",
   "metadata": {},
   "outputs": [],
   "source": [
    "def odds_evens():\n",
    "    \n",
    "    n = input(\"Please enter a number: \")\n",
    "    \n",
    "    # if int\n",
    "    if not n.isdigit():\n",
    "        print('Not a number')\n",
    "        return\n",
    "    \n",
    "    # cast to int\n",
    "    n = int(n)\n",
    "    \n",
    "    # Positivity\n",
    "    if n <= 0:\n",
    "        print('Not Positive.')\n",
    "        return\n",
    "    \n",
    "    # It is positive\n",
    "    else:\n",
    "        \n",
    "        # odd?\n",
    "        if n % 2 == 1:\n",
    "            print('ODD')\n",
    "            \n",
    "        else:\n",
    "            # even\n",
    "            if 1 <= n <= 10:\n",
    "                print('EVEN OF TEN')\n",
    "            elif 11 <= n <= 20:\n",
    "                print('EVEN OF TVENTY')\n",
    "            elif n > 20:\n",
    "                print(\"EVEN\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "acting-wales",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "please enter a number:  16\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "EVEN of TWENTY\n"
     ]
    }
   ],
   "source": [
    "def odds_evens():\n",
    "    x = int(input(\"please enter a number: \"))\n",
    "    #Check if the input is an integer or not.\n",
    "\n",
    "    #Also check if the number is a positive number.\n",
    "\n",
    "    #Decide if the number is ODD or EVEN and print:\n",
    "    if x % 2 ==1:\n",
    "        print('ODD')\n",
    "    else:\n",
    "        if x <=10:\n",
    "            print('EVEN of TEN')\n",
    "        elif x <=20:\n",
    "            print('EVEN of TWENTY')\n",
    "        elif x > 20:\n",
    "            print('EVEN')\n",
    "        \n",
    "odds_evens()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "id": "40790b2e-855f-41fc-a1ba-14655f875501",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "please enter a number:  91\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ODD\n"
     ]
    }
   ],
   "source": [
    "odds_evens()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "id": "238477d1-4b5f-4c21-b6f3-c36f643a77ed",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "please enter a number:  18\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "EVEN of TWENTY\n"
     ]
    }
   ],
   "source": [
    "odds_evens()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "neutral-spider",
   "metadata": {},
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "solar-interpretation",
   "metadata": {},
   "source": [
    "**Q 9:**\n",
    "\n",
    "**Sum of Odds and Evens:** \n",
    "* If the sum of two numbers is Odd then only one of these is Odd.\n",
    "* It the sum of two numbers is Even then both are Odd or both are Even.\n",
    "\n",
    "Define a function named **sum_of_odds_and_evens**.\n",
    "\n",
    "It will ask for two integers from the user.\n",
    "\n",
    "Then it will decide if the sum is Odd or Even.\n",
    "\n",
    "**Important Note:** Do not calculate the actual summation as x + y.\n",
    "\n",
    "<pre>\n",
    "Expected Output:\n",
    "First Number:  8\n",
    "Second Number:  3\n",
    "Sum is ODD\n",
    "</pre>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "several-aggregate",
   "metadata": {},
   "outputs": [],
   "source": [
    "# S 9:\n",
    "def sum_of_odds_and_evens():\n",
    "    \n",
    "    # get numbers\n",
    "    n1 = int(input(\"Number One: \"))\n",
    "    n2 = int(input(\"Number Two: \"))\n",
    "    \n",
    "    # if only one is Odd -> summation ODD\n",
    "    # (n1 is odd and n2 is even)\n",
    "    # (n1 is even and n2 is odd)\n",
    "    if (n1 % 2 == 1 and n2 % 2 == 0) or (n1 % 2 == 0 and n2 % 2 == 1):\n",
    "        print(\"Sum is ODD\")\n",
    "    else:\n",
    "        print(\"Sum is EVEN\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "executive-chester",
   "metadata": {},
   "outputs": [],
   "source": [
    "sum_of_odds_and_evens()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "detailed-generic",
   "metadata": {},
   "outputs": [],
   "source": [
    "sum_of_odds_and_evens()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "binary-banana",
   "metadata": {},
   "outputs": [],
   "source": [
    "sum_of_odds_and_evens()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "thermal-interpretation",
   "metadata": {},
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "obvious-phase",
   "metadata": {},
   "source": [
    "**Q 10:**\n",
    "\n",
    "Define a function named **count_down**.\n",
    "\n",
    "It will ask for two integers from the user.\n",
    "\n",
    "First it will decide which one of them is small and which one is large.\n",
    "\n",
    "Then it will print the numbers starting from the large one up to the small one. (backwards)\n",
    "\n",
    "**Hints:** \n",
    "* Solve with Recursion.\n",
    "* There may be a second function as **print_down** for Recursion.\n",
    "\n",
    "<pre>\n",
    "Expected Output:\n",
    "First Number:  26\n",
    "Second Number:  12\n",
    "small: 12\n",
    "large: 26\n",
    "26\n",
    "25\n",
    "24\n",
    "23\n",
    "22\n",
    "21\n",
    "20\n",
    "19\n",
    "18\n",
    "17\n",
    "16\n",
    "15\n",
    "14\n",
    "13\n",
    "12\n",
    "</pre>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "toxic-branch",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Number One:  26\n",
      "Number Two:  4\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "small 4\n",
      "large 26\n",
      "26\n",
      "25\n",
      "24\n",
      "23\n",
      "22\n",
      "21\n",
      "20\n",
      "19\n",
      "18\n",
      "17\n",
      "16\n",
      "15\n",
      "14\n",
      "13\n",
      "12\n",
      "11\n",
      "10\n",
      "9\n",
      "8\n",
      "7\n",
      "6\n",
      "5\n",
      "4\n"
     ]
    }
   ],
   "source": [
    "# S 10:\n",
    "\n",
    "def count_down():\n",
    "    # get numbers\n",
    "    num1 = int(input(\"Number One: \"))\n",
    "    num2 = int(input(\"Number Two: \"))\n",
    "    \n",
    "    # variables for small and large\n",
    "    small = 0\n",
    "    large = 0\n",
    "    \n",
    "    if num1 <= num2:\n",
    "        small = num1\n",
    "        large = num2\n",
    "    else:\n",
    "        small = num2\n",
    "        large = num1\n",
    "    \n",
    "    print(\"small\", small)\n",
    "    print(\"large\", large)\n",
    "    \n",
    "    # call recursion\n",
    "    print_down(small, large)\n",
    "    \n",
    "    \n",
    "# recursion function\n",
    "def print_down(end, value):\n",
    "    \n",
    "    # exit condition\n",
    "    if value == end:\n",
    "        print(value)\n",
    "        return\n",
    "    else:\n",
    "        print(value)\n",
    "        print_down(end, value - 1)\n",
    "\n",
    "count_down()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "aquatic-looking",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Number One:  10\n",
      "Number Two:  2\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "small 2\n",
      "large 10\n",
      "10\n",
      "9\n",
      "8\n",
      "7\n",
      "6\n",
      "5\n",
      "4\n",
      "3\n",
      "2\n"
     ]
    }
   ],
   "source": [
    "count_down()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "another-emperor",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}