test_1_written_student_solutions.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Test 1 -- Written Solutions from Students\n",
    "\n",
    "[![Binder](https://mybinder.org/badge.svg)](https://mybinder.org/v2/gh/enactdev/CISC_106_F18/master?filepath=test_1_written_student_solutions.ipynb)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Grading method -- all questions\n",
    "* **No points taken off for things that are not needed if it still works.**\n",
    "* **I did not take points off for indentation or missing colons. I did make comments about  some bad indentation though. **\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "### 26) \n",
    "\n",
    "**3 Points:**\n",
    "\n",
    "**I liked how succinct some of you were.**\n",
    "\n",
    "**If this confuses you remember that only one if-elif-else block will run (the ```else``` makes sure at least that block will run).**"
   ]
  },
  {
   "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 < 6:\n",
    "    print( \"You're a todler\")\n",
    "    \n",
    "# Finish the rest on your own\n",
    "elif user_age < 18:\n",
    "    print( \"You're a child\")\n",
    "\n",
    "# An else statement is ok here\n",
    "else:\n",
    "    print( \"You're an adult\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "### 27) \n",
    "\n",
    "**8 Points:**\n",
    "\n",
    "**A lot of people got partial credit for finding the mistake in the assertEqual, but chaging the value to ```False``` instead of changing the year. Comments in the code state there needs to be two ```True``` and two ```False``` tests. Some changed it to ```False``` but then changed a later assertEqual() so there were two of each, and I gave full credit for that.**\n",
    "\n",
    "**I did not take points off for fixing something that was not broken, and I did not take points off for introducing a new error. Most commonly introduced error was changing line 12, instantiating is_leap to ```True```. Make sure you understand why that would be wrong.**\n",
    "\n",
    "**Some of you pointed out that you can remove the spacing. But that was not an error, because it works with the spacing. It does fully work with the ```if``` statements aligned:**\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": [
    "### But, you can't both remove the spacing *and* make them ```elif``` statements"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "SUCCESS - [line 34] assertEqual(is_leap_year(2000), True)\n",
      "SUCCESS - [line 36] assertEqual(is_leap_year(2012), True)\n",
      "FAILURE - [line 37] assertEqual(is_leap_year(1900), False), predicted answer was False, computed answer was True \n",
      "SUCCESS - [line 38] assertEqual(is_leap_year(1999), False)\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "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",
    "    elif (year % 100) == 0:\n",
    "        # Changed '==' to '=' below\n",
    "        is_leap = False\n",
    "\n",
    "    # Changed '40' to '400' below\n",
    "    elif (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",
    "**Most people did really well on this one. Most common deduction was for missing this assertEqual comment: \"One should test both arguments being 0\"**\n",
    "\n",
    "**I do want everyone to think about what makes a good series of tests. Try to test as many variable outcomes as possible. Ideally, there would be a test for two 0's, a test for 0 children and > 0 adults, a test for 0 adults and > 0 children, and a test for both being > 0.**\n",
    "\n",
    "**This is my answer, for reference.**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "SUCCESS - [line 19] assertEqual(calculate_admission(0, 0), 0)\n",
      "SUCCESS - [line 20] assertEqual(calculate_admission(1, 0), 10)\n",
      "SUCCESS - [line 21] assertEqual(calculate_admission(0, 1), 20)\n",
      "SUCCESS - [line 22] assertEqual(calculate_admission(1, 1), 30)\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 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",
    "# 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",
    "**Two out of four points was pretty high for this question. It can be solved in three lines, and I gave a point for each correct line that was there.**\n",
    "\n",
    "**(Note: Some students mixed looping by index and looping by item. If you set up your answer to loop by one method but then accessed the value by the other method I only gave a half-point for the later line.)**\n",
    "\n",
    "**I gave a half point if something looked like it almost worked.**\n",
    "\n",
    "**Some people attempted list slicing, which could work, but is cumbersome in this example. I did not see any examples that worked.**\n",
    "\n",
    "**Lots of variation in student answers here. I tested some to see if they worked or not. I might have tested your solution wrong. If you test your solution and it works and I took points off, show me.**\n",
    "\n",
    "## Student Examples:\n",
    "\n",
    "### You can also loop through the list by index. This got full credit."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "SUCCESS - [line 16] assertEqual(remove_duplicates([1, 1, 2, 2, 3, 3]), [1, 2, 3])\n",
      "SUCCESS - [line 17] assertEqual(remove_duplicates(['a', 'b', 'c']), ['a', 'b', 'c'])\n",
      "SUCCESS - [line 18] assertEqual(remove_duplicates(['a', 'a', 'a']), ['a'])\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def remove_duplicates(a_list):\n",
    "    \n",
    "    new_list = []\n",
    "    \n",
    "    # You can also loop through the list by index\n",
    "    for i in range(len(a_list)):\n",
    "        if a_list[i] not in new_list:\n",
    "            new_list.append(a_list[i])\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'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### But be careful about adding \"== True\" when you don't need it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "FAILURE - [line 17] assertEqual(remove_duplicates([1, 1, 2, 2, 3, 3]), [1, 2, 3]), predicted answer was [1, 2, 3], computed answer was [] \n",
      "FAILURE - [line 18] assertEqual(remove_duplicates(['a', 'b', 'c']), ['a', 'b', 'c']), predicted answer was ['a', 'b', 'c'], computed answer was [] \n",
      "FAILURE - [line 19] assertEqual(remove_duplicates(['a', 'a', 'a']), ['a']), predicted answer was ['a'], computed answer was [] \n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def remove_duplicates(a_list):\n",
    "    \n",
    "    new_list = []\n",
    "    \n",
    "    for i in range(len(a_list)):\n",
    "        \n",
    "        # Extra == True breaks this line\n",
    "        if a_list[i] not in new_list == True:\n",
    "            \n",
    "            new_list.append(a_list[i])\n",
    "\n",
    "    # Return our new list\n",
    "    return new_list\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'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### If you do add \"== True\" then add parenthesis"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "SUCCESS - [line 16] assertEqual(remove_duplicates([1, 1, 2, 2, 3, 3]), [1, 2, 3])\n",
      "SUCCESS - [line 17] assertEqual(remove_duplicates(['a', 'b', 'c']), ['a', 'b', 'c'])\n",
      "SUCCESS - [line 18] assertEqual(remove_duplicates(['a', 'a', 'a']), ['a'])\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def remove_duplicates(a_list):\n",
    "    \n",
    "    new_list = []\n",
    "    \n",
    "    for i in range(len(a_list)):\n",
    "        \n",
    "        if (a_list[i] not in new_list) == True:\n",
    "            \n",
    "            new_list.append(a_list[i])\n",
    "\n",
    "    # Return our new list\n",
    "    return new_list\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'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### You can also solve this with while loop"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "SUCCESS - [line 20] assertEqual(remove_duplicates([1, 1, 2, 2, 3, 3]), [1, 2, 3])\n",
      "SUCCESS - [line 21] assertEqual(remove_duplicates(['a', 'b', 'c']), ['a', 'b', 'c'])\n",
      "SUCCESS - [line 22] assertEqual(remove_duplicates(['a', 'a', 'a']), ['a'])\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def remove_duplicates(a_list):\n",
    "    \n",
    "    new_list = []\n",
    "    \n",
    "    i = 0\n",
    "    \n",
    "    while i < len(a_list):\n",
    "        \n",
    "        if a_list[i] not in new_list:\n",
    "            \n",
    "            new_list.append(a_list[i])\n",
    "            \n",
    "        i += 1\n",
    "\n",
    "    # Return our new list\n",
    "    return new_list\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'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### A lot of people used \"i\" as an item rather than an index. \n",
    "\n",
    "**I did not like this, but I did not take points off. I will in the future. Only use \"i\" for indexes.**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "SUCCESS - [line 16] assertEqual(remove_duplicates([1, 1, 2, 2, 3, 3]), [1, 2, 3])\n",
      "SUCCESS - [line 17] assertEqual(remove_duplicates(['a', 'b', 'c']), ['a', 'b', 'c'])\n",
      "SUCCESS - [line 18] assertEqual(remove_duplicates(['a', 'a', 'a']), ['a'])\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def remove_duplicates(a_list):\n",
    "    \n",
    "    new_list = []\n",
    "    \n",
    "    for i in a_list:\n",
    "        \n",
    "        if i not in new_list:\n",
    "            \n",
    "            new_list.append(i)\n",
    "\n",
    "    # Return our new list\n",
    "    return new_list\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
}