Exercises (1).ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Before you turn this problem in, make sure everything runs as expected. First, **restart the kernel** (in the menubar, select Kernel$\\rightarrow$Restart) and then **run all cells** (in the menubar, select Cell$\\rightarrow$Run All).\n",
    "\n",
    "Make sure you fill in any place that says `YOUR CODE HERE` or \"YOUR ANSWER HERE\", as well as your name and collaborators below:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "NAME = \"Sreya Dhar\"\n",
    "COLLABORATORS = \"\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "7748afc54baf7ad0d84c789ab8dbb092",
     "grade": false,
     "grade_id": "cell-cc604c0aae18cc24",
     "locked": false,
     "schema_version": 3,
     "solution": true,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "# Exercise 1\n",
    "def total_wages_for_the_week(hours, wage):\n",
    "    # Many companies pay time-and-a-half for any hours worked above 40 in a given week.\n",
    "    # Complete this function whose inputs are hours worked (hours) and the hourly rate (wage) to\n",
    "    # calculate the total wages for the week. \n",
    "    # YOUR CODE HERE\n",
    "    if hours > 40: \n",
    "        pay = 40*wage + (hours-40)*1.5*wage\n",
    "    \n",
    "    else:\n",
    "        pay= hours * wage\n",
    "        \n",
    "    return pay\n",
    "\n",
    "total_wages_for_the_week(40, 25)\n",
    "total_wages_for_the_week(65, 63.4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "d92e0dc72a17eca24b14fbc0c49766a8",
     "grade": true,
     "grade_id": "cell-999bf8ee61b894e8",
     "locked": true,
     "points": 2,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "# Test cell for exercise 1\n",
    "assert total_wages_for_the_week(40, 25) == 1000\n",
    "assert total_wages_for_the_week(65, 63.4) == 4913.5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "23315a9a8b4f64c91b37546f17d9bd24",
     "grade": true,
     "grade_id": "cell-0c803c0254790b8a",
     "locked": true,
     "points": 2,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "# Test cell for exercise 1 (Hidden)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "0c74cabe24cdef8ec4b2bb1e211273e0",
     "grade": false,
     "grade_id": "cell-09452c74c9ab069a",
     "locked": false,
     "schema_version": 3,
     "solution": true,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "# Exercise 2\n",
    "def convert_quiz_score_to_letter_grade(score):\n",
    "    # A certain CS professor gives five-point quizzes that are graded on the scale 5-A, 4-B, 3-C, 2-D, 1-F, 0-F.\n",
    "    # Complete this function which accepts a quiz score as an input and uses a decision structure to calculate the corresponding\n",
    "    # grade. \n",
    "    # YOUR CODE HERE\n",
    "    if score >= 5:\n",
    "        grade = \"A\"\n",
    "    elif score >=4:\n",
    "        grade = \"B\"\n",
    "    elif score >=3:\n",
    "        grade = \"C\"\n",
    "    elif score >=2:\n",
    "        grade = \"D\"\n",
    "    else:\n",
    "        grade = \"F\"\n",
    "    \n",
    "    return grade\n",
    "    \n",
    "convert_quiz_score_to_letter_grade(0)\n",
    "convert_quiz_score_to_letter_grade(1)\n",
    "convert_quiz_score_to_letter_grade(2)\n",
    "convert_quiz_score_to_letter_grade(3)\n",
    "convert_quiz_score_to_letter_grade(4)\n",
    "convert_quiz_score_to_letter_grade(5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "bb3b2fb2fbbb287132be8e5381512fc7",
     "grade": true,
     "grade_id": "cell-212a6ed0aedc4322",
     "locked": true,
     "points": 2,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "# Test cell  for exercise 2 \n",
    "assert convert_quiz_score_to_letter_grade(0) == \"F\"\n",
    "assert convert_quiz_score_to_letter_grade(1) == \"F\"\n",
    "assert convert_quiz_score_to_letter_grade(2) == \"D\"\n",
    "assert convert_quiz_score_to_letter_grade(3) == \"C\"\n",
    "assert convert_quiz_score_to_letter_grade(4) == \"B\"\n",
    "assert convert_quiz_score_to_letter_grade(5) == \"A\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "e869077e423e162760ef626b14c77577",
     "grade": false,
     "grade_id": "cell-c2699b0226be40b0",
     "locked": false,
     "schema_version": 3,
     "solution": true,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "# Exercise 3 \n",
    "def convert_exam_score_to_letter_grade(score):\n",
    "    # A certain CS professor gives 100-point exams that are graded on the scale 90-100: A, 80-89: B, 70-79: C,\n",
    "    # 69-69: D, < 60: F. Complete this function which accepts an exam score as input and uses a decision structure \n",
    "    # to calculate the corresponding grade. \n",
    "    # YOUR CODE HERE\n",
    "        \n",
    "    if score >= 90:\n",
    "        grade = \"A\"\n",
    "        \n",
    "    elif score >= 80:\n",
    "        grade = \"B\" \n",
    "        \n",
    "    elif score >= 70:\n",
    "        grade = \"C\"\n",
    "        \n",
    "    elif score >= 60:\n",
    "        grade = \"D\" \n",
    "       \n",
    "    else:\n",
    "        grade = \"F\"\n",
    "        \n",
    "    return grade\n",
    "\n",
    "convert_exam_score_to_letter_grade(55)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "7c5e86d369bd34e62ceec2f276112726",
     "grade": true,
     "grade_id": "cell-7c59cc2534924674",
     "locked": true,
     "points": 2,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "# Test cell  for exercise 3\n",
    "assert convert_exam_score_to_letter_grade(55) == \"F\"\n",
    "assert convert_exam_score_to_letter_grade(35) == \"F\"\n",
    "assert convert_exam_score_to_letter_grade(65) == \"D\"\n",
    "assert convert_exam_score_to_letter_grade(73) == \"C\"\n",
    "assert convert_exam_score_to_letter_grade(87) == \"B\"\n",
    "assert convert_exam_score_to_letter_grade(92) == \"A\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "68718dd2cf0e2841528e75c286a456dc",
     "grade": true,
     "grade_id": "cell-1507900e432c1220",
     "locked": true,
     "points": 2,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "# Test cell  for exercise 3(Hidden)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "30c5b67e2bef597e7c4299759fa5f981",
     "grade": false,
     "grade_id": "cell-b9be67329b35ea84",
     "locked": false,
     "schema_version": 3,
     "solution": true,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "# Exercise 4\n",
    "def calculate_class_standing_from_credits(credits):\n",
    "    # A certain college classifies students according to credits earned. A student with less than 7 credits is a Freshman.\n",
    "    # At least 7 credits are required to be a Sophomore, 16 to be a Junior and 26 to be classifed as Senior. \n",
    "    # Complete this function which calculates the class standing from the number of credits earned. \n",
    "    # YOUR CODE HERE\n",
    "        if credits >= 26:\n",
    "            classi = 'Senior'\n",
    "        elif credits >= 16:\n",
    "            classi = 'Junior'\n",
    "        elif credits >= 7:\n",
    "            classi = 'Sophomore'\n",
    "        elif credits < 7:\n",
    "            classi = 'Freshman'\n",
    "        \n",
    "        return classi\n",
    "\n",
    "calculate_class_standing_from_credits(6)      "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "6558f749ea147aae587c0b4b53cbfdee",
     "grade": true,
     "grade_id": "cell-92d08237edebe22d",
     "locked": true,
     "points": 2,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "# Test cell  for exercise 4\n",
    "assert calculate_class_standing_from_credits(6) == \"Freshman\"\n",
    "assert calculate_class_standing_from_credits(13) == \"Sophomore\"\n",
    "assert calculate_class_standing_from_credits(23) == \"Junior\"\n",
    "assert calculate_class_standing_from_credits(45) == \"Senior\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "225b1ee8687047536b642aa259590ebb",
     "grade": true,
     "grade_id": "cell-fc0a577e1c4515eb",
     "locked": true,
     "points": 2,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "# Test cell  for exercise 4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "34ad03a1365b4aed0043276aade8969d",
     "grade": false,
     "grade_id": "cell-428c79d7f08e716a",
     "locked": false,
     "schema_version": 3,
     "solution": true,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "# Exercise 5\n",
    "def calculate_fine(limit, speed):\n",
    "    # The speeding ticket fine policy in Podunksville is $50 plus $5 for each mph over the limit plus a \n",
    "    # penalty of $200 for any speed over 90 mph. Complete this function which accepts a speed limit and a clocked\n",
    "    # speed and either return the string `Legal` or the amount of fine, if the speed is illegal. \n",
    "\n",
    "    # YOUR CODE HERE\n",
    "        if speed > 90:\n",
    "            finet = (50 + (speed - limit) * 5 + 200)\n",
    "        elif speed > limit:\n",
    "            finet = (50 + (speed - limit) * 5)\n",
    "        else: \n",
    "            finet = 'Legal'\n",
    "        return finet\n",
    "\n",
    "\n",
    "calculate_fine(55, 100)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "61f7abcd697bad7c5d8bc59ebb6d527c",
     "grade": true,
     "grade_id": "cell-ae9177af4cabd012",
     "locked": true,
     "points": 3,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "# Test cell  for exercise 5\n",
    "assert calculate_fine(55, 85) == 200\n",
    "assert calculate_fine(55, 45) == 'Legal'\n",
    "assert calculate_fine(55, 100) == 475"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "a93f2c941cf2a8dc02a38b984f55eb04",
     "grade": true,
     "grade_id": "cell-7843b693298ffede",
     "locked": true,
     "points": 3,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "# Test cell  for exercise 5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "b223deefa3caf1aa7274b7b7f226bf07",
     "grade": false,
     "grade_id": "cell-6c3c0a14fe237c2e",
     "locked": false,
     "schema_version": 3,
     "solution": true,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "# Exercise 6\n",
    "def is_leap_year(year):\n",
    "    # A year is a leap year if it is divisible by 4, unless it is a century year that is not divisible \n",
    "    # by 400. (1800 and 1900 are not leap years while 1600 and 2000 are). Complete this function which calculates\n",
    "    # whether a year is a leap year. Return True or False\n",
    "\n",
    "    # YOUR CODE HERE\n",
    "        leapy = False\n",
    "    \n",
    "    # logic here\n",
    "        if year % 400 == 0:\n",
    "            leapy = True\n",
    "        elif year % 100 == 0:\n",
    "            leapy = False\n",
    "        elif year % 4 == 0:\n",
    "            leapy = True\n",
    "    \n",
    "        return leapy\n",
    "    \n",
    "\n",
    "print(is_leap_year(2000))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "d6e6a7666bb77e1d095b84403e87eeca",
     "grade": true,
     "grade_id": "cell-2fac7294d0a4333c",
     "locked": true,
     "points": 3,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "# Test cell  for exercise 6\n",
    "assert is_leap_year(2000) == True\n",
    "assert is_leap_year(1800) == False\n",
    "assert is_leap_year(1992) == True"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "d74ee83c35896ec5c244c98bafa8abae",
     "grade": true,
     "grade_id": "cell-d39435fe9fa2d644",
     "locked": true,
     "points": 3,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "# Test cell  for exercise 6"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "a1d5cb26516ae1bb20651ca29165dc74",
     "grade": false,
     "grade_id": "cell-a76c5e81720d0e7b",
     "locked": false,
     "schema_version": 3,
     "solution": true,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "# Exercise 7 **\n",
    "def is_palindrome(st):\n",
    "\n",
    "    le, hi = 0, len(st) - 1\n",
    "    \n",
    "    # Lowercase string \n",
    "    st = st.lower() \n",
    "    \n",
    "    # Compares character until they are equal \n",
    "    while (le <= hi): \n",
    "    \n",
    "        # If there is another symbol in left \n",
    "        # of sentence \n",
    "        if (not(st[le] >= 'a' and st[le] <= 'z')): \n",
    "            le += 1\n",
    "    \n",
    "        # If there is another symbol in right  \n",
    "        # of sentence \n",
    "        elif (not(st[hi] >= 'a' and st[hi] <= 'z')): \n",
    "            hi -= 1\n",
    "    \n",
    "        # If characters are equal \n",
    "        elif (st[le] == st[hi]): \n",
    "            le += 1\n",
    "            hi -= 1\n",
    "        else: \n",
    "            return False\n",
    "    # Returns true if sentence is palindrome \n",
    "    return True\n",
    "            \n",
    "is_palindrome(\"Kayak\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "aac696ea9e1bee6274e7bd0af16c9c74",
     "grade": true,
     "grade_id": "cell-cda9f94c36b5e077",
     "locked": true,
     "points": 3,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "# Test cell  for exercise 7\n",
    "assert is_palindrome(\"Kayak\") == True\n",
    "assert is_palindrome(\"Rotator\") == True\n",
    "assert is_palindrome(\"AACA\") == False\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "0a02a94f07cd8e85af2c19ffc48fcd13",
     "grade": true,
     "grade_id": "cell-049803af92bcfe13",
     "locked": true,
     "points": 3,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "# Test cell  for exercise 7 (hidden)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 147,
   "metadata": {
    "deletable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "0469b9b3e060066d9d464411bec7cb7f",
     "grade": false,
     "grade_id": "cell-519e1e17ac49b564",
     "locked": false,
     "schema_version": 3,
     "solution": true,
     "task": false
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Summer'"
      ]
     },
     "execution_count": 147,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Ex8: Season from Month and Day **\n",
    "\n",
    "def determine_season(month, day):\n",
    "\n",
    "    # The year is divided into four season: spring, summer, fall (or autumn) and winter.\n",
    "    # While the exact dates that the seasons change vary a little bit from year to\n",
    "    # year because of the way that the calender is constructed, we will use the following\n",
    "    # dates for this exercise:\n",
    "\n",
    "    # Season  -- First Day\n",
    "    # Spring  -- March 20\n",
    "    # Summer  -- June 21\n",
    "    # Fall  -- September 22\n",
    "    # Winter    -- December 21\n",
    "\n",
    "    # Complete this function which takes in as inputs a month and day. It should\n",
    "    # output the season.\n",
    "    # input 1: month -- str\n",
    "    # input 2: day -- int\n",
    "\n",
    "    # output: month -- str (Spring, Summer, Fall, Winter)\n",
    "\n",
    "    # YOUR CODE HERE\n",
    "     \n",
    "    month = str(month).capitalize()\n",
    "    day = int(day)\n",
    "    \n",
    "    if month == \"January\" or month == \"February\":\n",
    "        season = \"Winter\"\n",
    "    elif month == \"July\" or month == \"August\":\n",
    "        season = \"Summer\"\n",
    "    elif month == \"October\" or month == \"November\":\n",
    "        season = \"Fall\"\n",
    "    elif month == \"April\" or month == \"May\":\n",
    "        season = \"Spring\" \n",
    "    else:\n",
    "        if month == \"March\" and day in range(20,32):\n",
    "            season = \"Spring\"\n",
    "        elif month == \"March\" and day in range(1,20):\n",
    "            season = \"Winter\"\n",
    "        elif month == \"June\" and day in range(1,21):\n",
    "            season = \"Spring\"\n",
    "        elif month == \"June\" and day in range(21,30):\n",
    "            season = \"Summer\"\n",
    "        elif month == \"September\" and day in range(1,22):\n",
    "            season = \"Summer\"\n",
    "        elif month == \"September\" and day in range(22,31):\n",
    "            season = \"Fall\"\n",
    "        elif month == \"December\" and day in range(1,21):\n",
    "            season = \"Fall\"\n",
    "        elif month == \"December\" and day in range(22,32):\n",
    "            season = \"Winter\"\n",
    "        else:\n",
    "            season = \"Invalid date entered \"\n",
    "    return season\n",
    "\n",
    "# determine_season(11, 21)\n",
    "\n",
    "determine_season('March', 21)\n",
    "determine_season('June', 21)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "302ed7d09f1d63077603920776378907",
     "grade": true,
     "grade_id": "cell-4b8dd5ecc5f72de6",
     "locked": true,
     "points": 2,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "assert determine_season('March', 21) == 'Spring'\n",
    "assert determine_season('June', 21) == 'Summer'\n",
    "assert determine_season('November', 21) == 'Fall'\n",
    "assert determine_season('January', 21) == 'Winter'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "fe1c889dc623c652464726c848bd3de8",
     "grade": true,
     "grade_id": "cell-deb5e4c4cab226f4",
     "locked": true,
     "points": 2,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 140,
   "metadata": {
    "deletable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "a6ef92c565c3b7be3cc9e9916b62f615",
     "grade": false,
     "grade_id": "cell-6f3941343261caca",
     "locked": false,
     "schema_version": 3,
     "solution": true,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "#Ex9: Check a password **\n",
    "\n",
    "def check_password(password):\n",
    "\n",
    "    # In this exercise you will complete this function to determine whether or not\n",
    "    # a password is good. We will define a good password to be a one that is at least\n",
    "    # 8 characters long and contains at least one uppercase letter, at least one lowercase\n",
    "    # letter, and at least one number. This function should return True if the password\n",
    "    # passed to it as its only parameter is good. Otherwise it should return False. \n",
    "    #\n",
    "    # input: password (str)\n",
    "    # output: True or False (bool)\n",
    "    \n",
    "    _val=True\n",
    "    \n",
    "    if len(password) < 8:\n",
    "        _val=False\n",
    "    if not any(char.isdigit() for char in password):\n",
    "        _val=False\n",
    "    if not any(char.isupper() for char in password):\n",
    "        _val=False\n",
    "    if not any(char.islower() for char in password):\n",
    "        _val=False\n",
    "    return _val\n",
    "    \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "a3a081b2aba22832fcca52b1292eb45f",
     "grade": true,
     "grade_id": "cell-91c4927536aa6bdd",
     "locked": true,
     "points": 2,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "assert check_password('test1234') == False\n",
    "assert check_password('password123') == False\n",
    "assert check_password('SuperPasswrd90') == True\n",
    "assert check_password('letmein!') == False\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "a0d335fe8c5c5c8c3a27dd2b7aaa0feb",
     "grade": true,
     "grade_id": "cell-4eb94ff39a016bfe",
     "locked": true,
     "points": 2,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "\n"
   ]
  }
 ],
 "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.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}