python_exercise_notebook_1.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "67d06672",
   "metadata": {},
   "source": [
    "## Exercise: Python Basic Conceptual (Example Codes).\n",
    "![greed_div](https://user-images.githubusercontent.com/7065401/52071924-c003ad80-2562-11e9-8297-1c6595f8a7ff.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8c8bdbc4",
   "metadata": {},
   "source": [
    "### Problem 1:\n",
    "The following equation estimates the average calories burned for a person when exercising, which is based on a scientific journal article:\n",
    "\n",
    "Calories = ( (Age x 0.2757) + (Weight x 0.03295) + (Heart Rate x 1.0781) — 75.4991 ) x Time / 8.368\n",
    "\n",
    "Write a program using inputs age (years), weight (pounds), heart rate (beats per minute), and time (minutes), respectively. Output the average calories burned for a person.\n",
    "\n",
    "## Solution:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "80e19fcf",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter the person's age:\n",
      "32\n",
      "Enter weight (in lbs):\n",
      "71\n",
      "What the value of heart beats per minute:\n",
      "34\n",
      "Time (in min):\n",
      "5\n",
      "Calories: -16.54 calories\n"
     ]
    }
   ],
   "source": [
    "age_in_years = int(input(\"Enter the person's age:\\n\"))\n",
    "weight_in_lbs = int(input(\"Enter weight (in lbs):\\n\"))\n",
    "heart_beats_per_min = int(input('What the value of heart beats per minute:\\n'))\n",
    "time_in_min = int(input('Time (in min):\\n'))\n",
    "\n",
    "calories = ((age_in_years * 0.2757) + (weight_in_lbs * 0.03295) + (heart_beats_per_min * 1.0781) - 75.4991) * time_in_min / 8.368\n",
    "print(f'Calories: {calories:.2f} calories')\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0b89772f",
   "metadata": {},
   "source": [
    "### Problem 2:\n",
    "\n",
    "Given three floating-point numbers x, y, and z, output x to the power of z, x to the power of (y to the power of z), the absolute value of (x minus y), and the square root of (x to the power of z).\n",
    "\n",
    "\n",
    "## Solution:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "02cc9734",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "X:2\n",
      "y:1\n",
      "z:2\n",
      "\n",
      "Required Output:\n",
      "2.0 to the power of 2.0 is 4.0\n",
      "2.0 to the power 1.0^2.0 is 2.0\n",
      "|2.0 - 1.0| = 1.0\n",
      "Sq.Root 4.0 = 2.0\n"
     ]
    }
   ],
   "source": [
    "import math\n",
    "\n",
    "x = float(input('X:'))\n",
    "y = float(input('y:'))\n",
    "z = float(input('z:'))\n",
    "\n",
    "out1 = math.pow(x,z)\n",
    "out2 = x**(math.pow(y,z))\n",
    "\n",
    "abs_val = math.fabs(x - y)\n",
    "\n",
    "sq_root = math.sqrt(out1)\n",
    "print('\\nRequired Output:')\n",
    "print(f'{x} to the power of {z} is {out1}\\n{x} to the power {y}^{z} is {out2}\\n|{x} - {y}| = {abs_val}\\nSq.Root {out1} = {sq_root}')\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "96f7e6d9",
   "metadata": {},
   "source": [
    "### Problem 3:\n",
    "\n",
    "On a piano, a key has a frequency, say f0. Each higher key (black or white) has a frequency of f0 * rn, where n is the distance (number of keys) from that key, and r is 2(1/12). Given an initial key frequency, output that frequency and the next 4 higher key frequencies.\n",
    "\n",
    "Note: Use one statement to compute r = 2(1/12) using the pow function (remember to import the math module). Then use that r in subsequent statements that use the formula fn = f0 * rn with n being 1, 2, 3, and finally 4.\n",
    "\n",
    "## Solution:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "9324994a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter initial key freq: 440\n",
      "\n",
      "The next four key frequencies higher than 440.0 are: 466.16 493.88 523.25 554.37\n"
     ]
    }
   ],
   "source": [
    "f0 = float(input('Enter initial key freq: '))\n",
    "\n",
    "r = math.pow(2,1/12)\n",
    "\n",
    "higher_key_f1 = f0 * math.pow(r,1)\n",
    "\n",
    "higher_key_f2 = f0 * math.pow(r,2)\n",
    "\n",
    "higher_key_f3 = f0 * math.pow(r,3)\n",
    "\n",
    "higher_key_f4 = f0 * math.pow(r,4)\n",
    "\n",
    "print(f'\\nThe next four key frequencies higher than {f0} are:', end = ' ')\n",
    "print(f'{higher_key_f1:.2f}' , f'{higher_key_f2:.2f}' ,f'{higher_key_f3:.2f}',f'{higher_key_f4:.2f}')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1d2fc4db",
   "metadata": {},
   "source": [
    "### Problem 4:\n",
    "\n",
    "1. Prompt the user for the number of cups of lemon juice, water, and agave nectar needed to make lemonade. Prompt the user to specify the number of servings the recipe yields. Output the ingredients and serving size.\n",
    "2. Prompt the user to specify the desired number of servings. Adjust the amounts of each ingredient accordingly, and then output the ingredients and serving size.\n",
    "3. Convert the ingredient measurements from (2) to gallons. Output the ingredients and serving size. Note: There are 16 cups in a gallon.\n",
    "\n",
    "## Solution:\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "b1c3ef1b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter amount of lemon juice (in cups):\n",
      "2\n",
      "Enter amount of water (in cups):\n",
      "1\n",
      "Enter amount of agave nectar (in cups):\n",
      "2\n",
      "How many servings does this make?\n",
      "5\n",
      "\n",
      "Lemonade ingredients - yields 5.00 servings\n",
      "2.00 cup(s) lemon juice\n",
      "1.00 cup(s) water\n",
      "2.00 cup(s) agave nectar\n",
      "\n",
      "How many servings would you like to make?\n",
      "50\n",
      "\n",
      "Required Output:\n",
      "Lemonade ingredients - yields 50.00 servings\n",
      "20.00 cup(s) lemon juice\n",
      "10.00 cup(s) water\n",
      "20.00 cup(s) agave nectar\n",
      "\n",
      "Lemonade ingredients - yields 50.00 servings\n",
      "1.25 gallon(s) lemon juice\n",
      "0.62 gallon(s) water\n",
      "1.25 gallon(s) agave nectar\n"
     ]
    }
   ],
   "source": [
    "#1 Propmting all the required data from the user.\n",
    "\n",
    "lemon_juice_cups = float(input(\"Enter amount of lemon juice (in cups):\\n\"))\n",
    "water_cups = float(input(\"Enter amount of water (in cups):\\n\"))\n",
    "agave_nectar_cups = float(input(\"Enter amount of agave nectar (in cups):\\n\"))\n",
    "\n",
    "serving_size = float(input(\"How many servings does this make?\\n\"))\n",
    "print()\n",
    "\n",
    "print(f'Lemonade ingredients - yields {serving_size:.2f} servings')\n",
    "print(f'{lemon_juice_cups:.2f} cup(s) lemon juice')\n",
    "print(f'{water_cups:.2f} cup(s) water')\n",
    "print(f'{agave_nectar_cups:.2f} cup(s) agave nectar\\n')\n",
    "\n",
    "#2 servings to make\n",
    "\n",
    "servings_to_be_made = float(input(\"How many servings would you like to make?\\n\"))\n",
    "\n",
    "\n",
    "calc_serving = servings_to_be_made / serving_size\n",
    "\n",
    "\n",
    "print('\\nRequired Output:')\n",
    "\n",
    "print(f'Lemonade ingredients - yields {servings_to_be_made:.2f} servings')\n",
    "print(f'{lemon_juice_cups * calc_serving:.2f} cup(s) lemon juice')\n",
    "print(f'{water_cups * calc_serving:.2f} cup(s) water')\n",
    "print(f'{agave_nectar_cups * calc_serving:.2f} cup(s) agave nectar\\n')\n",
    "\n",
    "#3 convert from cups to gallons given 1 gallon = 16 cups\n",
    "print(f'Lemonade ingredients - yields {servings_to_be_made:.2f} servings')\n",
    "print(f'{(lemon_juice_cups * calc_serving)/16:.2f} gallon(s) lemon juice')\n",
    "print(f'{(water_cups * calc_serving)/16:.2f} gallon(s) water')\n",
    "print(f'{(agave_nectar_cups * calc_serving)/16:.2f} gallon(s) agave nectar')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7ef75f21",
   "metadata": {},
   "source": [
    "### Problem 5:\n",
    "\n",
    "1. Prompt the user to input a food item name, price, and quantity. Output an itemized receipt. \n",
    "2. Extend the program to prompt the user for a second item. Output an itemized receipt.\n",
    "3. Extend again to output a third receipt that adds a mandatory 15% gratuity to the total cost. Output the total cost, the cost of gratuity, and the grand total.\n",
    "\n",
    "## Solution:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "a3622ed2",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter food item name:\n",
      "Hot Dog\n",
      "Enter item price:\n",
      "15\n",
      "Enter item quantity:\n",
      "4\n",
      "\n",
      "RECEIPT\n",
      "4 Hot Dog @ $15.00 = $60.00\n",
      "Total cost: $60.00\n",
      "\n",
      "\n",
      "Enter second food item name:\n",
      "Panini Bread Sandwich\n",
      "Enter item price:\n",
      "25\n",
      "Enter item quantity:\n",
      "2\n",
      "\n",
      "RECEIPT\n",
      "4 Hot Dog @ $15.00 = $60.00\n",
      "2 Panini Bread Sandwich @ $25.00 = $50.00\n",
      "Total cost: $110.00\n",
      "\n",
      "15% gratuity: $16.50\n",
      "Total with tip: $126.50\n"
     ]
    }
   ],
   "source": [
    "food_item = input(\"Enter food item name:\\n\")\n",
    "price = float(input(\"Enter item price:\\n\"))\n",
    "quantity = int(input(\"Enter item quantity:\\n\"))\n",
    "\n",
    "total_cost = price * quantity\n",
    "print()\n",
    "print(\"RECEIPT\")\n",
    "print(quantity,food_item,'@',f'${price:.2f}','=',f'${total_cost:.2f}')\n",
    "print(f'Total cost: ${total_cost:.2f}')\n",
    "print()\n",
    "print()\n",
    "\n",
    "second_food_item = input(\"Enter second food item name:\\n\")\n",
    "price2 = float(input(\"Enter item price:\\n\"))\n",
    "quantity2 = int(input(\"Enter item quantity:\\n\"))\n",
    "\n",
    "total_cost2 = price2 * quantity2\n",
    "\n",
    "final_cost = total_cost + total_cost2\n",
    "\n",
    "\n",
    "#15% gratuity: $3.00 Total with tip: $23.\n",
    "gratuity_15_per_cent = final_cost * 0.15\n",
    "\n",
    "total_with_tip = final_cost + gratuity_15_per_cent \n",
    "\n",
    "print()\n",
    "print(\"RECEIPT\")\n",
    "print(quantity,food_item,'@',f'${price:.2f}','=',f'${total_cost:.2f}')\n",
    "\n",
    "print(quantity2,second_food_item,'@',f'${price2:.2f}','=',f'${total_cost2:.2f}')\n",
    "print(f'Total cost: ${final_cost:.2f}')\n",
    "\n",
    "print()\n",
    "print(f'15% gratuity: ${gratuity_15_per_cent:.2f}')\n",
    "\n",
    "print(f'Total with tip: ${total_with_tip:.2f}')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9d2f8322",
   "metadata": {},
   "source": [
    "### Problem 6:\n",
    "\n",
    "Given an integer representing a 10-digit phone number, output the area code, prefix, and line number using the format (800) 555-1212.\n",
    "\n",
    "## Solution:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "33fa6583",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter the phone number:7745843734\n",
      "Formated phone number: (774) 584-3734\n"
     ]
    }
   ],
   "source": [
    "num10d = int(input('Enter the phone number:'))\n",
    "area_code = num10d // 10000000\n",
    "\n",
    "#print(area_code)\n",
    "intermediate = num10d % 10000000\n",
    "\n",
    "#print(intermediate)\n",
    "prefix = intermediate // 10000\n",
    "\n",
    "#print(prefix)\n",
    "line_num = intermediate % 10000\n",
    "\n",
    "#print(line_num)\n",
    "print(f'Formated phone number: ({area_code}) {prefix}-{line_num}')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c909e6a3",
   "metadata": {},
   "source": [
    "## Problem 7:\n",
    "\n",
    "A half-life is the amount of time it takes for a substance or entity to fall to half its original value. Caffeine has a half-life of about 6 hours in humans. Given caffeine amount (in mg) as input, output the caffeine level after 6, 12, and 24 hours. Use a string formatting expression with conversion specifiers to output the caffeine amount as floating-point numbers.\n",
    "\n",
    "### Solution:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "ff4a0f78",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Caffein amount(in mg): 110\n",
      "After 6 hours: 55.00 mg\n",
      "After 12 hours: 27.50 mg\n",
      "After 24 hours: 6.88 mg\n"
     ]
    }
   ],
   "source": [
    "caffeine_mg = float(input('Caffein amount(in mg): '))\n",
    "\n",
    "after_hours_6 = caffeine_mg /2\n",
    "after_hours_12 = after_hours_6 /2\n",
    "after_hours_24 = after_hours_12 /4\n",
    "\n",
    "print(f'After 6 hours: {after_hours_6:.2f} mg')\n",
    "print(f'After 12 hours: {after_hours_12:.2f} mg')\n",
    "print(f'After 24 hours: {after_hours_24:.2f} mg')\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3120e129",
   "metadata": {},
   "source": [
    "### Problem 8: Painting a Wall\n",
    "1. Prompt the user to input a wall's height and width. Calculate and output the wall's area.\n",
    "2. Extend to also calculate and output the amount of paint in gallons needed to paint the wall (floating point). Assume a gallon of paint covers 350 square feet. Store this value in a variable. Output the amount of paint needed using the %f conversion specifier.\n",
    "3. Extend to also calculate and output the number of 1 gallon cans needed to paint the wall. Hint: Use a math function to round up to the nearest gallon.\n",
    "4. Extend by prompting the user for a color they want to paint the walls. Calculate and output the total cost of the paint cans depending on which color is chosen. \n",
    "\n",
    "Hint: Use a dictionary to associate each paint color with its respective cost. Red paint costs dollar 35 per gallon can, blue paint costs dollar 25 per gallon can, and green paint costs dollar 23 per gallon can.\n",
    "\n",
    "\n",
    "## Solution:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "3aec2b65",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter wall height (feet):\n",
      "12\n",
      "Enter wall width (feet):\n",
      "18\n",
      "Wall area: 216 square feet\n",
      "Paint needed: 0.62 gallons\n",
      "Cans needed: 1 can(s)\n",
      "\n",
      "Choose a color to paint the wall:\n",
      "blue\n",
      "Cost of purchasing blue paint: $25\n"
     ]
    }
   ],
   "source": [
    "wall_height = int(input(\"Enter wall height (feet):\\n\"))\n",
    "wall_width = int(input(\"Enter wall width (feet):\\n\"))\n",
    "\n",
    "wall_area = wall_height * wall_width\n",
    "print(\"Wall area:\",wall_area,'square feet')\n",
    "\n",
    "paint_per_sqft = 1/350\n",
    "paint_needed=paint_per_sqft * wall_area\n",
    "print(f'Paint needed: {paint_needed:.2f} gallons')\n",
    "cans = math.ceil(paint_needed)\n",
    "print('Cans needed:',cans,'can(s)')\n",
    "\n",
    "print()\n",
    "choose_colour = input(\"Choose a color to paint the wall:\\n\")\n",
    "colours = {'red':35,'blue':25,'green':23}\n",
    "selected_colour = colours[choose_colour]\n",
    "paint_cost = selected_colour * cans\n",
    "print(f\"Cost of purchasing {choose_colour} paint: ${paint_cost}\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "49eaec35",
   "metadata": {},
   "source": [
    "### Problem 9:\n",
    "Sites like Zillow get input about house prices from a database and provide nice summaries for readers. Write a program with two inputs, current price and last month's price (both integers). Then, output a summary listing the price, the change since last month, and the estimated monthly mortgage computed as (current_price * 0.051) / 12.\n",
    "\n",
    "## Solution:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "01755ccc",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter the current house price:4535000\n",
      "Enter previous month's price:3350000\n",
      "This house is $4535000. The change is $1185000 since last month.\n",
      "The estimated monthly mortgage is $19273.75.\n"
     ]
    }
   ],
   "source": [
    "current_price = int(input('Enter the current house price:'))\n",
    "last_months_price = int(input('Enter previous month\\'s price:'))\n",
    "\n",
    "\n",
    "change_price = current_price - last_months_price\n",
    "estimated_mortage = (current_price * 0.051) / 12\n",
    "\n",
    "print(f'This house is ${current_price}. The change is ${change_price} since last month.')\n",
    "print(f'The estimated monthly mortgage is ${estimated_mortage:.2f}.')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f0ce654c",
   "metadata": {},
   "source": [
    "### Problem 10:\n",
    "\n",
    "Primary U.S. interstate highways are numbered 1-99. Odd numbers (like the 5 or 95) go north/south, and evens (like the 10 or 90) go east/west. Auxiliary highways are numbered 100-999, and service the primary highway indicated by the rightmost two digits. Thus, I-405 services I-5, and I-290 services I-90. Note: 200 is not a valid auxiliary highway because 00 is not a valid primary highway number.\n",
    "\n",
    "Given a highway number, indicate whether it is a primary or auxiliary highway. If auxiliary, indicate what primary highway it serves. Also indicate if the (primary) highway runs north/south or east/west.\n",
    "\n",
    "\n",
    "## Solution:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "id": "ee2ef5c7",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter th Highway Number: 293\n",
      "I-293 is auxiliary, serving I-93, going north/south.\n"
     ]
    }
   ],
   "source": [
    "\n",
    "highway_num = int(input('Enter th Highway Number: '))\n",
    "\n",
    "if highway_num > 0 and highway_num < 100:\n",
    "    print(f'I-{highway_num} is primary,' , end='')\n",
    "    \n",
    "    if highway_num % 2 == 0:        #primary case\n",
    "        print(\" going east/west.\")  #if even: west/east\n",
    "    else:\n",
    "        print(\" going north/south.\")  #if odd: north/south\n",
    "        \n",
    "elif (highway_num >= 100 and highway_num < 1000) and highway_num % 100 != 0:\n",
    "    print(f\"I-{highway_num} is auxiliary,\", end='')\n",
    "    serving = highway_num % 100\n",
    "    print(f' serving I-{serving},', end='')\n",
    "    \n",
    "    if highway_num % 2 == 0:        #auxilary case\n",
    "        print(\" going east/west.\")  #if even: east/west\n",
    "    else:\n",
    "        print(\" going north/south.\")  #if odd: north/south\n",
    "    \n",
    "else:\n",
    "    print(f'{highway_num} is not a valid interstate highway number.')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8ac62414",
   "metadata": {},
   "source": [
    "### Problem 11:\n",
    "\n",
    "*Summary: Given integer values for red, green, and blue, subtract the gray from each value.*\n",
    "\n",
    "Computers represent color by combining the sub-colors red, green, and blue (rgb). Each sub-color's value can range from 0 to 255. Thus (255, 0, 0) is bright red, (130, 0, 130) is a medium purple, (0, 0, 0) is black, (255, 255, 255) is white, and (40, 40, 40) is a dark gray. (130, 50, 130) is a faded purple, due to the (50, 50, 50) gray part. (In other words, equal amounts of red, green, blue yield gray).\n",
    "\n",
    "Given values for red, green, and blue, remove the gray part.\n",
    "\n",
    "## Solution:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "id": "37a1a1c7",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Red Code:130\n",
      "Green Code:50\n",
      "Blue Code:130\n",
      "\n",
      "Desired result:\n",
      "(80 0 80)\n"
     ]
    }
   ],
   "source": [
    "\n",
    "red = int(input('Red Code:'))\n",
    "green = int(input('Green Code:'))\n",
    "blue = int(input('Blue Code:'))\n",
    "gray = 0\n",
    "if red < blue and red < green:\n",
    "    gray = red\n",
    "    \n",
    "elif blue < red and blue < green:\n",
    "    gray = blue\n",
    "    \n",
    "elif green < red and green < blue:\n",
    "    gray = green\n",
    "\n",
    "elif red == green and green == blue:\n",
    "    gray = red\n",
    "print('\\nDesired result:')    \n",
    "print(f'({red - gray} {green-gray} {blue-gray})')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f8a430ba",
   "metadata": {},
   "source": [
    "### Problem 12:\n",
    "1. Output a menu of automotive services and the corresponding cost of each service. \n",
    "2. Prompt the user for two services from the menu.\n",
    "3. Output an invoice for the services selected. Output the cost for each service and the total cost.\n",
    "4. Extend the program to allow the user to enter a dash (-), which indicates no service\n",
    "\n",
    "\n",
    "## Solution:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "id": "ccf7d332",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Davy's auto shop services\n",
      "Oil change -- $35\n",
      "Tire rotation -- $19\n",
      "Car wash -- $7\n",
      "Car wax -- $12\n",
      "\n",
      "Select first service:\n",
      "Car wash\n",
      "Select second service:\n",
      "Tire rotation\n",
      "\n",
      "Davy's auto shop invoice\n",
      "\n",
      "Service 1: Car wash, $7\n",
      "Service 2: Tire rotation, $19\n",
      "\n",
      "Total: $26\n"
     ]
    }
   ],
   "source": [
    "\n",
    "shop_service = {'Oil change': 35, 'Tire rotation':19,'Car wash':7,'Car wax':12}\n",
    "print(\"Davy's auto shop services\")\n",
    "print(f\"Oil change -- ${shop_service['Oil change']}\")\n",
    "print(f\"Tire rotation -- ${shop_service['Tire rotation']}\")\n",
    "print(f\"Car wash -- ${shop_service['Car wash']}\")\n",
    "print(f\"Car wax -- ${shop_service['Car wax']}\")\n",
    "\n",
    "print()\n",
    "service1 = input('Select first service:\\n')\n",
    "service2 = input(\"Select second service:\\n\")\n",
    "print()\n",
    "print(\"Davy's auto shop invoice\")\n",
    "print()\n",
    "if service1 in shop_service and service2 in shop_service:\n",
    "    print(f'Service 1: {service1}, ${shop_service[service1]}')\n",
    "    print(f'Service 2: {service2}, ${shop_service[service2]}')\n",
    "    print()\n",
    "    print(f'Total: ${shop_service[service1] + shop_service[service2]}')\n",
    "    \n",
    "elif (service1 in shop_service) and (service2 not in shop_service):\n",
    "    print(f'Service 1: {service1}, ${shop_service[service1]}')\n",
    "    print(f'Service 2: No service')\n",
    "    print()\n",
    "    print(f\"Total: ${shop_service[service1]}\")\n",
    "    \n",
    "elif (service1 not in shop_service) and (service2 in shop_service):\n",
    "    print(f'Service 1: No service')\n",
    "    print(f'Service 2: {service2}, ${shop_service[service2]}')\n",
    "    print()\n",
    "    print(f\"Total: ${shop_service[service2]}\")\n",
    "\n",
    "else:\n",
    "    print(f'Service 1: No service')\n",
    "    print(f'Service 2: No service')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0a144c1a",
   "metadata": {},
   "source": [
    "### Problem 13:\n",
    "\n",
    "Write a program that takes in a positive integer as input, and outputs a string of 1's and 0's representing the integer in reverse binary.\n",
    "```\n",
    "As long as x is greater than 0\n",
    "   Output x modulo 2 (remainder is either 0 or 1)\n",
    "   Assign x with x divided by 2\n",
    "```\n",
    "\n",
    "## Solution:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "id": "b0f0826a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter a decimal number: 6\n",
      "011\n",
      "The above is it's reverse binary equivalent value.\n"
     ]
    }
   ],
   "source": [
    "\n",
    "user_input = int(input('Enter a decimal number: '))\n",
    "rev_bin = []\n",
    "while user_input > 0:\n",
    "    rem = user_input % 2\n",
    "    user_input//=2\n",
    "    print(rem,end = '')\n",
    "print('\\nThe above is it\\'s reverse binary equivalent value.' )"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f2b07149",
   "metadata": {},
   "source": [
    "### Problem 14:\n",
    "\n",
    "***Brute Force Equation Solver***\n",
    "\n",
    "Numerous engineering and scientific applications require finding solutions to a set of equations. Ex: 8x + 7y = 38 and 3x - 5y = -1 have a solution x = 3, y = 2. Given integer coefficients of two linear equations with variables x and y, use brute force to find an integer solution for x and y in the range -10 to 10.\n",
    "\n",
    "* Use this brute force approach:\n",
    "```\n",
    "For every value of x from -10 to 10\n",
    "   For every value of y from -10 to 10\n",
    "      Check if the current x and y satisfy both equations. If so, output the solution, and finish.\n",
    "```\n",
    "\n",
    "## Solution:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "id": "39ad2bab",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Coefficient of x for eq(1): 8\n",
      "Coefficient of y for eq(1): 7\n",
      "RHS Eq(1): 38\n",
      "Coefficient of x for eq(2): 3\n",
      "Coefficient of y for eq(2): -5\n",
      "RHS Eq(2): -1\n",
      "\n",
      "x = 3 , y = 2\n"
     ]
    }
   ],
   "source": [
    "#collecting all the inputs\n",
    "inp_x1 = int(input('Coefficient of x for eq(1): '))\n",
    "inp_y1 = int(input('Coefficient of y for eq(1): '))\n",
    "sol1 = int(input('RHS Eq(1): '))\n",
    "\n",
    "inp_x2 = int(input('Coefficient of x for eq(2): '))\n",
    "inp_y2 = int(input('Coefficient of y for eq(2): '))\n",
    "sol2 = int(input('RHS Eq(2): '))\n",
    "print()\n",
    "\n",
    "#implementing the approach\n",
    "solution = False\n",
    "for i in range(-10,11):\n",
    "    for j in range(-10,11):\n",
    "        if ((inp_x1 * i) + (inp_y1 *j) == sol1) and ((inp_x2 * i) + (inp_y2 *j) == sol2):\n",
    "            solution = True\n",
    "            print(f'x = {i} , y = {j}')\n",
    "\n",
    "\n",
    "if solution == False:\n",
    "    print(\"There is no solution\")\n",
    "             "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "502f8b5b",
   "metadata": {},
   "source": [
    "### Problem 15:\n",
    "Write a program with total change amount as an integer input, and output the change using the fewest coins, one coin type per line. The coin types are Dollars, Quarters, Dimes, Nickels, and Pennies. Use singular and plural coin names as appropriate, like 1 Penny vs. 2 Pennies.\n",
    "\n",
    "## Solution:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "id": "2e771e3d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter the Amount: 458\n",
      "4 Dollars\n",
      "2 Quarters\n",
      "1 Nickel\n",
      "1 Penny\n"
     ]
    }
   ],
   "source": [
    "# 100 pennies, 20 nickels, 10 dimes, or 4 quarters; each = 1 dollar\n",
    "# Therefore, 0.01 pennies, 0.20 nickles, 0.10 dimes , 0.25 quarters (each)\n",
    "\n",
    "num_input = int(input('Enter the Amount: '))\n",
    "\n",
    "if num_input <= 0:\n",
    "    print(\"No change\")\n",
    "else:\n",
    "    num_dollars = num_input // 100\n",
    "    num_input %= 100\n",
    "    \n",
    "    num_quarter = num_input // 25\n",
    "    num_input %= 25\n",
    "    \n",
    "    num_dimes = num_input // 10\n",
    "    num_input %= 10\n",
    "    \n",
    "    num_nickles = num_input // 5\n",
    "    num_nickles %= 5\n",
    "    \n",
    "    pennies = num_nickles\n",
    "    \n",
    "    if num_dollars > 1:\n",
    "        print(num_dollars, 'Dollars')\n",
    "    elif num_dollars == 1:\n",
    "        print(num_dollars, 'Dollar') \n",
    "        \n",
    "    if num_quarter > 1:\n",
    "        print(num_quarter, 'Quarters')\n",
    "    elif num_quarter == 1:\n",
    "        print(num_quarter, 'Quarter')   \n",
    "    \n",
    "    if num_dimes > 1:\n",
    "        print(num_dimes, 'Dimes')\n",
    "    elif num_dimes == 1:\n",
    "        print(num_dimes,'Dime')\n",
    "        \n",
    "    if num_nickles > 1:\n",
    "        print(num_nickles,'Nickels')\n",
    "    elif num_nickles == 1:\n",
    "        print(num_nickles, 'Nickel')\n",
    "        \n",
    "    if pennies > 1:\n",
    "        print(pennies,'Pennies')\n",
    "    elif pennies == 1:\n",
    "        print(pennies,\"Penny\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "eccfb184",
   "metadata": {},
   "source": [
    "### Problem 16:\n",
    "\n",
    "Many user-created passwords are simple and easy to guess. Write a program that takes a simple password and makes it stronger by replacing characters using the key below, and by appending \"!\" to the end of the input string.\n",
    "\n",
    "* i becomes 1\n",
    "* a becomes @\n",
    "* m becomes M\n",
    "* B becomes 8\n",
    "* s becomes $\n",
    "\n",
    "## Solution"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "id": "6099803a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter a noramal password: someBluerice\n",
      "The modified password is: $oMe8luer1ce!\n"
     ]
    }
   ],
   "source": [
    "word = input('Enter a noramal password: ')\n",
    "password = ''\n",
    "\n",
    "\n",
    "for char in word:\n",
    "    if char == 'i':\n",
    "        password += '1'\n",
    "    elif char == 'a':\n",
    "        password += '@'\n",
    "    elif char == 'm':\n",
    "        password += 'M'\n",
    "    elif char == 'B':\n",
    "        password += '8'\n",
    "    elif char == 's':\n",
    "        password += '$'\n",
    "    else:\n",
    "        password += char\n",
    "password += '!'\n",
    "print('The modified password is:',password)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "93462f8c",
   "metadata": {},
   "source": [
    "### Problem 17:\n",
    "\n",
    "Write a program that takes in a line of text as input, and outputs that line of text in reverse. The program repeats, ending when the user enters \"Done\", \"done\", or \"d\" for the line of text.\n",
    "\n",
    "## Solution:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "id": "330fcdb2",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello Nobita\n",
      "atiboN olleH\n",
      "evenisnotodd\n",
      "ddotonsineve\n",
      "done\n"
     ]
    }
   ],
   "source": [
    "text =  input()\n",
    "\n",
    "while text != 'done' and text != 'Done' and text != 'd':\n",
    "    for characters in reversed(text):\n",
    "        print(characters, end ='')\n",
    "    print()\n",
    "    text = input()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c123698f",
   "metadata": {},
   "source": [
    "### Problem 18:\n",
    "Write a function driving_cost() with input parameters miles_per_gallon, dollars_per_gallon, and miles_driven, that returns the dollar cost to drive those miles. All items are of type float. The function called with arguments (20.0, 3.1599, 50.0) returns 7.89975.\n",
    "\n",
    "Define that function in a program whose inputs are the car's miles per gallon and the price of gas in dollars per gallon (both float). Output the gas cost for 10 miles, 50 miles, and 400 miles, by calling your driving_cost() function three times.\n",
    "\n",
    "## Solution:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "id": "b8dbbdf7",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "35\n",
      "6.889\n",
      "The gas cost of 10 miles is $1.97\n",
      "The gas cost of 50 miles is $9.84\n",
      "The gas cost of 400 miles is $78.73\n"
     ]
    }
   ],
   "source": [
    "#defining the function\n",
    "def driving_cost(miles_per_gallon, dollars_per_gallon, miles_driven):\n",
    "    gas_cost = dollars_per_gallon / miles_per_gallon\n",
    "    \n",
    "    total_miles_cost = gas_cost * miles_driven\n",
    "    \n",
    "    return total_miles_cost     #dollar cost to those miles\n",
    "\n",
    "if __name__ == '__main__':\n",
    "    \n",
    "    #taking the function arguments from the user\n",
    "    dist_gallon = float(input())\n",
    "    dollars_gallon = float(input())\n",
    "    \n",
    "    \n",
    "    x = driving_cost(dist_gallon, dollars_gallon,10)\n",
    "    print(f'The gas cost of 10 miles is ${x:.2f}')\n",
    "    \n",
    "    x = driving_cost(dist_gallon, dollars_gallon,50)\n",
    "    print(f'The gas cost of 50 miles is ${x:.2f}')\n",
    "    \n",
    "    x = driving_cost(dist_gallon, dollars_gallon,400)\n",
    "    print(f'The gas cost of 400 miles is ${x:.2f}')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f88a9ad6",
   "metadata": {},
   "source": [
    "### Problem 19:\n",
    "**Step Counter**\n",
    "\n",
    "A pedometer treats walking 1 step as walking 2.5 feet. Define a function named feet_to_steps that takes a float as a parameter, representing the number of feet walked, and returns an integer that represents the number of steps walked. Then, write a main program that reads the number of feet walked as an input, calls function feet_to_steps() with the input as an argument, and outputs the number of steps.\n",
    "\n",
    "\n",
    "## Solution:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "id": "8e675f3f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter distance walked (in ft's):189\n",
      "189.0 feet = 75 steps\n"
     ]
    }
   ],
   "source": [
    "def feet_to_steps(feet_walked):\n",
    "    s = (feet_walked / 2.5)\n",
    "    steps_walked = math.floor(s)\n",
    "    return steps_walked\n",
    "\n",
    "\n",
    "if __name__ == '__main__':\n",
    "    \n",
    "    user_feet_walked = float(input(\"Enter distance walked (in ft's):\") )\n",
    "    \n",
    "    print(f'{user_feet_walked} feet =',feet_to_steps(user_feet_walked),'steps')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "531af957",
   "metadata": {},
   "source": [
    "### Problem 20:\n",
    "A common year in the modern Gregorian Calendar consists of 365 days. In reality, Earth takes longer to rotate around the sun. To account for the difference in time, every 4 years, a leap year takes place. A leap year is when a year has 366 days: An extra day, February 29th. The requirements for a given year to be a leap year are:\n",
    "\n",
    "1. The year must be divisible by 4\n",
    "\n",
    "2. If the year is a century year (1700, 1800, etc.), the year must be evenly divisible by 400\n",
    "\n",
    "Some example leap years are 1600, 1712, and 2016.\n",
    "\n",
    "Write a program that takes in a year and determines the number of days in February for that year.\n",
    "\n",
    "## Solution:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "id": "affbacab",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2032\n",
      "2032 has 29 days in February.\n"
     ]
    }
   ],
   "source": [
    "\n",
    "def days_in_feb(year):\n",
    "    days = 28\n",
    "    if (year % 400 == 0) and (year % 100 == 0):\n",
    "        days = 29\n",
    "    elif (year % 4 == 0) and (year % 100 != 0):\n",
    "        days = 29\n",
    "    return days\n",
    "    \n",
    "if __name__ == '__main__':\n",
    "    user_year = int(input())\n",
    "    print(f\"{user_year} has {days_in_feb(user_year)} days in February.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c9d71746",
   "metadata": {},
   "source": [
    "![](https://user-images.githubusercontent.com/7065401/52071924-c003ad80-2562-11e9-8297-1c6595f8a7ff.png)\n",
    "$End$ $of$  $the$  $notebook...$"
   ]
  }
 ],
 "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.10.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}