test_1_written_solutions.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Test 1 -- Written Solutions\n",
    "\n",
    "[![Binder](https://mybinder.org/badge.svg)](https://mybinder.org/v2/gh/enactdev/CISC_106_F18/master?filepath=test_1_written_solutions.ipynb)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "### 26) \n",
    "\n",
    "**3 Points:**\n",
    "\n",
    "**Given: A variable ```user_age``` has already been declared. It is a positive integer, but you do not know the value.** \n",
    "\n",
    "**Some code has been written, you need to finish it. Write a series of ```if```, ```elif```, and (if needed) an ```else``` statement that checks the age held in ```user_age```. If the age is under 3, print \"You're a baby\" , if the age is 3 or older and less than 6 print \"You're a todler\", if the user is 6 or older and less than 18 print \"You're a child\", and finally if the user is 18 or older then print \"You're an adult.\"**\n",
    "\n",
    "**Note: There are 4 possible things that can be printed. Some people will use an ```else``` statement. Some will not. Either can be correct, it depends on how you solve it.**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "You're a child\n"
     ]
    }
   ],
   "source": [
    "# Added for testing:\n",
    "user_age = 10\n",
    "\n",
    "# Check whether age value in variable user_age is a baby\n",
    "if user_age < 3:\n",
    "    \n",
    "    # Print that the user is a baby\n",
    "    print( \"You're a baby\")\n",
    "    \n",
    "# Check whether user is a todler\n",
    "elif (user_age >= 3) and (user_age < 6):\n",
    "    print( \"You're a todler\")\n",
    "    \n",
    "# Finish the rest on your own\n",
    "elif (user_age >= 6) and (user_age < 18):\n",
    "    print( \"You're a child\")\n",
    "\n",
    "# An else statement is ok here\n",
    "elif user_age >= 18:\n",
    "    print( \"You're an adult\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "### 27) \n",
    "\n",
    "**8 Points:**\n",
    "\n",
    "**Debug the provided Function Design Recipe. The Docstring comments will be completely correct. Use the problem definition and the Docstring to fix the rest of the code (including the assertEqual statements if applicable). There will be 4 things wrong. You'll get 1 point for finding it (circle it), 1 point for properly correcting it.**\n",
    "\n",
    "**In the Gregorian calendar three criteria must be taken into account to identify leap years:**\n",
    "\n",
    "* The year can be evenly divided by 4, is a leap year, unless:\n",
    "  * The year can be evenly divided by 100, it is NOT a leap year, unless:\n",
    "    * The year is also evenly divisible by 400. Then it is a leap year.\n",
    "    \n",
    "    \n",
    "**This means that in the Gregorian calendar, the years 2000 and 2400 are leap years, while 1800 and 1900 are not.**\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "SUCCESS - [line 36] assertEqual(is_leap_year(2000), True)\n",
      "SUCCESS - [line 38] assertEqual(is_leap_year(2012), True)\n",
      "SUCCESS - [line 39] assertEqual(is_leap_year(1900), False)\n",
      "SUCCESS - [line 40] assertEqual(is_leap_year(1999), False)\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from cisc106 import assertEqual\n",
    "\n",
    "def is_leap_year(year):\n",
    "    \"\"\"\n",
    "    Tests whether given year is a leap year, based on the Gregorian calendar\n",
    "    Parameters:\n",
    "        year (int)\n",
    "    Returns:\n",
    "        is_leap (bool)\n",
    "    \"\"\"\n",
    "    \n",
    "    # Instantiate variable is_leap\n",
    "    is_leap = False\n",
    "    \n",
    "    # Check if year is evenly divisible by 4\n",
    "    if (year % 4) == 0:\n",
    "        \n",
    "        is_leap = True\n",
    "\n",
    "        if (year % 100) == 0:\n",
    "            # Changed '==' to '=' below\n",
    "            is_leap = False\n",
    "            \n",
    "            # Changed '40' to '400' below\n",
    "            if (year % 400) == 0:\n",
    "                is_leap = True\n",
    "                \n",
    "    # Added return statement below\n",
    "    return is_leap\n",
    "            \n",
    "\n",
    "\n",
    "\n",
    "# Write test cases for your function.\n",
    "# Two should evaluate to True and two should evaluate to False\n",
    "assertEqual(is_leap_year(2000), True)\n",
    "# Fixed year below, was 2010, any leap year is ok\n",
    "assertEqual(is_leap_year(2012), True)\n",
    "assertEqual(is_leap_year(1900), False)\n",
    "assertEqual(is_leap_year(1999), False)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "\n",
    "### 28) \n",
    "\n",
    "**10 Points**\n",
    "\n",
    "**Given a description, write a full Function Design Recipe -- 3 points for the Docstring comments, 4 points for the assertEqual statements (write 4), and 3 for a working function. You can use the Docstring comments in the previous question as a template.**\n",
    "\n",
    "**Your function will accept two arguments and return a single numerical value. For full credit make sure your function and variables names are descriptive.**\n",
    "\n",
    "**Write a function that calculates the cost of admission to an amusement park for an entire family. The cost of admission for children is \\$10 and the price for adults is \\$20.**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Grading notes:\n",
    "* Your function can return either an int or a float, as long as the value is correct\n",
    "* This example only has a single line, the return statement. Yours can have more lines as long as there are no errors\n",
    "* Your assertEqual calls can have different quantites, as long as they are correct"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "SUCCESS - [line 24] assertEqual(calculate_admission(0, 0), 0)\n",
      "SUCCESS - [line 25] assertEqual(calculate_admission(1, 0), 10)\n",
      "SUCCESS - [line 26] assertEqual(calculate_admission(0, 1), 20)\n",
      "SUCCESS - [line 27] assertEqual(calculate_admission(1, 1), 30)\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\n",
    "\n",
    "# Write you function with Docstring here.\n",
    "\n",
    "def calculate_admission(num_children, num_adults):\n",
    "    \"\"\"\n",
    "    Calculates the cost of admission for a family depending on the number of children\n",
    "    and adults. \n",
    "    Parameters:\n",
    "        num_children (int)\n",
    "        num_adults (int)\n",
    "    Returns:\n",
    "        price (int)\n",
    "    \"\"\"\n",
    "    \n",
    "    return (num_children * 10) + (num_adults * 20)\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "# Write 4 assertEqual statements that test your function. One should test both \n",
    "# arguments being 0, at least one should test when both arguments are greater \n",
    "# than zero, the other two are your choice.\n",
    "assertEqual(calculate_admission(0, 0), 0)\n",
    "assertEqual(calculate_admission(1, 0), 10)\n",
    "assertEqual(calculate_admission(0, 1), 20)\n",
    "assertEqual(calculate_admission(1, 1), 30)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "### 29) \n",
    "\n",
    "**4 Points -- This is the hardest question on the test. Attempt it last.**\n",
    "\n",
    "**A Function Design Recipe has been started for you, and the Docstring and assertEqual statements are finished and correct. However, you need to finish the function ```remove_duplicates``` which accepts a list as a parameter, and returns a list of all unique items from the list it recieved. Example, if the list ```[1, 1, 2, 2, 3, 3]``` is passed, the function returns the list ```[1, 2, 3]```**\n",
    "\n",
    "**You will use:**\n",
    "* The list method append() will add an element to the list and return ```None```. Your line using the append() method will look like this, and will not have an ```=``` sign on it:\n",
    "    * ```my_list_name.append('new list item')```\n",
    "* In order to test if an item is not in a list, use the ```not in``` condition. For example:\n",
    "    * ```'a' not in ['a', 'b', 'c']``` == ```False```\n",
    "    * ```'d' not in ['a', 'b', 'c']``` == ```True```\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "SUCCESS - [line 25] assertEqual(remove_duplicates([1, 1, 2, 2, 3, 3]), [1, 2, 3])\n",
      "SUCCESS - [line 26] assertEqual(remove_duplicates(['a', 'b', 'c']), ['a', 'b', 'c'])\n",
      "SUCCESS - [line 27] assertEqual(remove_duplicates(['a', 'a', 'a']), ['a'])\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def remove_duplicates(a_list):\n",
    "    \"\"\"\n",
    "    Returns a new list without any duplicates\n",
    "    Parameters:\n",
    "        a_list (list)\n",
    "    Returns:\n",
    "        new_list (list)\n",
    "    \"\"\"\n",
    "    \n",
    "    # Instantiate to an empty list\n",
    "    new_list = []\n",
    "    \n",
    "    # Fixed comment below: \n",
    "    # Loop through items in a_list. If item not in new_list then append it to new_list\n",
    "    for item in a_list:\n",
    "        if item not in new_list:\n",
    "            new_list.append(item)\n",
    "    \n",
    "    # Return our new list\n",
    "    return new_list\n",
    "\n",
    "\n",
    "# Write test cases for your function.\n",
    "# These are correct, you can use them to work through the function\n",
    "assertEqual(remove_duplicates([1, 1, 2, 2, 3, 3]), [1, 2, 3])\n",
    "assertEqual(remove_duplicates(['a', 'b', 'c']), ['a', 'b', 'c'])\n",
    "assertEqual(remove_duplicates(['a', 'a', 'a']), ['a'])"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "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.6.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}