_FINAL RE Assign Answer Key (5).ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "93239329-7702-40fe-b043-51d6195d6712",
   "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 below."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "87a707c9-09eb-4486-9df2-2410424c00d0",
   "metadata": {},
   "outputs": [],
   "source": [
    "NAME = \"\""
   ]
  },
  {
   "cell_type": "markdown",
   "id": "045e5c6c-9af1-4f3f-ba46-417ed22b6bf4",
   "metadata": {},
   "source": [
    "# Assignment 4 (Regular Expressions)\n",
    "### Learning Objectives\n",
    "For this assignment, the main learning objectives would be:\n",
    "1. __Get Comfortable with Regular Expressions:__ Learn how to create and apply regular expression patterns to find, match, split, and replace text in documents.\n",
    "2. __Master Text Processing Techniques:__ Practice using `re.findall()`, `re.sub()`, and `re.split()` to effectively extract, modify, and organize text.\n",
    "3. __Apply Your Skills:__ Use your knowledge in regular expressions to solve real-world problems--in this case, organizing and managing structured data like recipes!"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "39d26dc7-e3db-4274-b262-bc951527ff21",
   "metadata": {},
   "source": [
    "# Cooking Activity\n",
    "### Reduce Cooking Time for Time Efficiency!\n",
    "\n",
    "In this assignment, you will be doing a cooking activity to apply regular expressions. Daphne, a mother of one daughter named Lucy, who is happily married to her husband, Cole--are planning to have a Sunday family cooking session and she wants to be fully prepared for it! Because Daphne is on a time crunch to make the dishes, you will be using regular expressions to effectively extracting, modifying, and organizing in the recipe text!\n",
    "\n",
    "Note: Regular Expressions will also be called \"RE\" or \"Regex\" in this activity. Additionaly, in the definitions below, `regex_pattern` is a variabe refering to the regex pattern that is being implemented and `recipe_text` is a variable refering to text trying to find the pattern.\n",
    "\n",
    "| RE Methods | Meaning |\n",
    "| --- | --- |\n",
    "| `re.finditer()` | Find all substrings where regular expression matches, and returns them as a list. <br> Example: __finditer_method = re.match(regex_pattern, recipe_text)__ </br>|\n",
    "| `re.split()` | Returns a list where the string has been split at each match. <br> Example: `split_method = re.split = (regex_pattern, recipe_text)`</br>|\n",
    "| `re.sub()` | Replaces one or more matches with a string. <br> Example: __sub_method = re.sub(regex_pattern,replacement, recipe_text)__. In this case, replacement is the phrase that will replace the pattern within `recipe_text`. </br> |\n",
    "| `re.findall()` | Matches one or more of the previous expression. <br> Example __findall_method = regex_pattern.findall(recipe_text)\"__ </br>|\n",
    "| `re.IGNORECASE` | Does case-insensitive matches. <br> Example: __regex_pattern = re.compile(r'(hour)+[s]', re.IGNORECASE\")__ </br>|\n",
    "\n",
    "| Python Method | Meaning |\n",
    "| --- | --- |\n",
    "| `strip()` | Remove any spaces at the beginning and end of a string. <br>Example: __strip_method = recipe_text.strip()__  </br> |\n",
    "| `str()` | Converts an object into its string representation. <br> Example: __print(str(item))__ </br> |"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3a698a32-30b9-471e-b183-b2bc76d360f0",
   "metadata": {},
   "source": [
    "| RE Character | Meaning |\n",
    "| --- | --- |\n",
    "| `*` | Matches zero, one or more of the previous expression. <br> Example: __regex_pattern = re.compile(r'[0-9]*')__--which matches phrase(s) that contains digits from 0 to 9. </br>|\n",
    "| `?` | Matches zero or one of the previous expression. <br> Example: __regex_pattern = re.compile(r'colou?r')__--which matches the string \"color\" or \"colour\" because 'u' is optional. </br> |\n",
    "| `+` | Matches one or more of the previous expression. <br> Example: __regex_pattern = re.compile(r'\\d+')__--which matches with one or more digits. </br> |\n",
    "| `\\` | Used to escape a special character. <br> Example: __regex_pattern = re.compile(r'\\.')__--which matches a literal period dot '.' </br>|\n",
    "| `.` | Matches any character. </br> Example: __regex_pattern = re.compile(r'a.b')__--which matches any string where 'a' is followed by a single character and then 'b'. </br> |\n",
    "| `()` | Creates capture groups to extract adn refer to specific parts of a matched string. <br> Example: __regex_pattern = re.compile(r'(\\d{3}')__--which matches to any phrase with 3 consecutive digits. </br> |\n",
    "| `(?:)` | Non-capturing group that are group parts of a pattern togetehr but do not create a capturing group that you can refer to later. This is useful when you want to apply quantifiers to part of a pattern but don't need to capture the matched text for later. <br> Example: __regex_pattern = re.compile(r'\\d+(?:-\\d+)*')__--which is a non-capturing group that matches a hyphen followed by one or more digits, zero or one more times. </br>  |\n",
    "| `\\|` | Serves as an \"or\"/\"and\" statement that will match the pattern either on the right or left of the bar. <br> Example: `regex_pattern = re.compile(r'apple|orange')`--which matches either \"apple\" or \"orange\". </br>  |\n",
    "| `[]` | Matches a range of characters. <br> Example: __regex_pattern = re.compile(r'[0-9]')__--which matches to any single digit. </br>  |\n",
    "| `{}` | Matches a specific number of occurrences <br> Example: __regex_pattern = re.compile(r'a{3}')__--which matches exactly three consecutive 'a' characters. |\n",
    "| `^` | Matches the start of a string. <br> Example: __regex_pattern = re.compile(r'^Hello')__--which matches 'Hello' only if it appears at the start of the string. |\n",
    "| `$` | Matches the end of a string. <br> Example: __regex_pattern = re.compile(r'world!$')__--which matches 'world!' only if it appears at the end of the string.|\n",
    "| `\\d` | Matches a digit [0-9]. <br> Example: __regex_pattern = re.compile(r'\\d')__--which matches to any single digit. |\n",
    "| `\\D` | Matches a non-digit <br> Example: __regex_pattern = re.compile(r'\\D')__--which matches any character that is not a digit [0-9] |\n",
    "| `\\w` | Matches an alphanumeric character (letters [a-zA-Z]) and digits [0-9, and underscores.]<br> Example: __regex_pattern = re.compile(r'\\w')--which matches all alphanumeric characters and underscores in the text, ignoring spaces and puncutation. |\n",
    "| `\\W` | Matches an non-alphanumeric character <br> Example: __regex_pattern = re.compile(r'\\W')__--which matches to punctuation and spaces in the text.  |\n",
    "| `\\s` | Matches a whitespace character. <br> Example: __regex_pattern = re.compile(r'\\s')--which matches all whitespace characters in the text, including a |\n",
    "| `\\S` | Matches a non-whitespace character <br> Example: __regex_pattern = re.compile(r'\\S')__--which matches all characters in the text that are not whitespace characters (including letters, punctuation, and digits). |\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "Also, for all the regular expressions you define in the assignment, make sure to define them using [raw string notation](https://docs.python.org/3/library/re.html#raw-string-notation). This will make it easier for you to understand and debug your expressions, as discussed in the readings this week.\n",
    "\n",
    "RE Definitions Source Reference: https://www.python-engineer.com/posts/regular-expressions/"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "28cc58d6-7313-4b52-8b5c-27c58c9bd03b",
   "metadata": {},
   "outputs": [],
   "source": [
    "import re\n",
    "from feedback import *"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7328182f-0d6b-445b-9ea7-a1e5f586f426",
   "metadata": {},
   "outputs": [],
   "source": [
    "recipe_text = r'''\n",
    "Recipe 1: 194_Cabbage_Kielbara_Supper\n",
    "1) In a 5-qt. slow cooker, combine the cabbage, potatoes, onion, salt and pepper.\n",
    "2) Pour broth over all for 2 HOURS.\n",
    "3) Place sausage on top (slow cooker will be full, but cabbage will cook down).\n",
    "4) Cover and cook on low for 4-5 hours or until vegetables are tender and sausage is heated through.\n",
    "Recipe 2: 195_Chocolate_Chip_Cookie_Ice_Cream_Cake\n",
    "1) Crush half the cookies (about 20 cookies) to make crumbs.\n",
    "2) Combine crumbs with melted margarine and press into the bottom of a 9-inch springform pan or pie plate.\n",
    "3) Stand remaining cookies around edge of pan.\n",
    "4) Spread 3/4 cup fudge topping over crust.\n",
    "5) Freeze 1.5 hours.\n",
    "6) Meanwhile, soften 1 quart of ice cream in microwave or on countertop.\n",
    "7) After crust has chilled, spread softened ice cream over fudge layer.\n",
    "8) Freeze 30 minutes.\n",
    "9) Scoop remaining quart of ice cream into balls and arrange over spread ice cream layer.\n",
    "10) Freeze until firm, 3.5-4.5 Hours.\n",
    "11) To serve, garnish with remainder of fudge topping, whipped cream and cherries.'''"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e1ea6043-d84d-49f3-95e6-f4019618c991",
   "metadata": {},
   "source": [
    "# PART 1: Searching Within Recipe Text\n",
    "\n",
    "In this section, you will utilize a few more examples of regular expressions. Note that you want the regular expression to an __*exact match*__ to the word(s) you are looking for. Thereby, when making regular expressions, make sure to be specific in the pattern you create to make sure it does not capture words you are not looking for.\n",
    "\n",
    "So, in this section, you will be using regular expressions to find the exact timeframes that are above an hour--which will later be replaced with a shorter timeframe. Based on this task, you will want to make regular expression patterns to find the following phrases.\n",
    "\n",
    "Here is a __quick summary of coding sections for Part 1.__\n",
    "- __Recipe 1: Regex Pattern for *Only* Integer Hours:__ create a regex pattern that can match to all integer hours--whether it is in the form of a single integer hour or a range of integer hours.  \n",
    "- __Recipe 2: Regex Pattern for *Only* Decimal Hours:__ create regex pattern(s) that can match to all decimal hours--whether it is in the form of a single decimal hour or a range of decimal hours."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "af614504-12b8-49ca-b86f-f3ed2fb5a6b7",
   "metadata": {},
   "source": [
    "## Task 1: Regex Pattern for Integer Hours\n",
    "For Task 1, you want to create a regex pattern that can match to all integer hours within the recipe text--whether it is in the form of a single integer hour (ex: \"2 HOURS\") or a range of integer hours (ex: \"4-5 hours\"). \n",
    "\n",
    "Things to Note: \n",
    "1. Create a variable called `integer_hour_pattern` and use the `re.compile()` method to store your regex pattern. Ensure sure that the regex pattern is written as a raw string by prefixing it with `r`.\n",
    "    - Make this that regular expression is __*case-insensitive*__--where the regex pattern matches to non-capitalized or capitalized words such as \"hours\" or \"HOURS\".\n",
    "    - Additionally, make sure the regular expression pattern should __*only extract to integer hours*__ and should not match '5 hours' if is part of a range like '4.5-5.5 hours'.\n",
    "4. Create a variable called `matches`. Within this variable use the correct regex method to find all the matches.\n",
    "5. Create a for-loop that goes through every `item` in `matches`. Then, the `item` is printed out.\n",
    "\n",
    "Based on this, your regex pattern should output EXACTLY to the phrases below (where there should not be any more or any less ouputs):\n",
    "* \"2 HOURS\"\n",
    "* \"4-5 hours\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a5b345f2-bcc4-4ec7-ac50-1e1d6c453516",
   "metadata": {},
   "outputs": [],
   "source": [
    "# YOUR CODE HERE\n",
    "integer_hour_pattern = re.compile(r'(?<!\\S)\\d{1,2}(?:-\\d{1,2})?\\s*hours?\\b', re.IGNORECASE)\n",
    "matches = integer_hour_pattern.findall(recipe_text)\n",
    "\n",
    "for item in matches:\n",
    "    print(item)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3bb43081-0ebc-4093-813e-e6cf20e5b149",
   "metadata": {},
   "outputs": [],
   "source": [
    "assert integer_hour_pattern.findall(recipe_text) == ['2 HOURS'] or [' 2 HOURS'], \"Assertion failed for '2 HOURS'.\"\n",
    "assert integer_hour_pattern.findall(recipe_text) == ['4-5 hours'] or [' 4-5 hours'], \"Assertion failed for '4-5 hours'.\"\n",
    "assert '5 hours' not in matches, \"Assertion failed because 5 hours in matches\"\n",
    "assert '5 hours' not in matches, \"Assertion failed because 5 hours in matches\"\n",
    "assert '5 Hours' not in matches, \"Assertion failed because 5 Hours in matches\"\n",
    "assert '5 hours' not in matches, \"Assertion failed because 5 Hours in matches\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9c78804b",
   "metadata": {},
   "outputs": [],
   "source": [
    "# these would be hidden from the student\n",
    "positive_test_cases=['2 hours','4-5 hours','1 hour','2-3 hours','1 HOUR','24 hours']\n",
    "negative_test_cases=['Overnight','Hour','two']\n",
    "\n",
    "# this is all you need to generate feedback\n",
    "feedback = return_feedback(integer_hour_pattern,positive_test_cases,negative_test_cases,NAME)\n",
    "print(feedback)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8c76da8e-92f4-40f3-8ce9-392568c77e51",
   "metadata": {},
   "source": [
    "## Task 2: Regex Pattern for Decimal Hours\n",
    "For Task 2, you want to create a regex pattern that can match to all decimal hours--whether it is in the form of a single decimal hour (ex: \"1.5 hours\") or a range of integer hours (ex: \"4.5-5.5 hours\"). \n",
    "\n",
    "Things to Note: \n",
    "1. Create a variable called `decimal_hour_pattern` and use the `re.compile()` method to store your regex pattern. Ensure sure that the regex pattern is written as a raw string by prefixing it with `r`.\n",
    "    - Make this that regular expression is __*case-insensitive*__--where the regex pattern matches to non-capitalized or capitalized words such as \"hours\" or \"HOURS\".\n",
    "4. Create a variable called `matches`. Within this variable use the correct regex method to match the integer hours.\n",
    "5. Create a for-loop that goes through every `item` in `matches` and prints it out as a string.\n",
    "\n",
    "Based on this, your regex pattern should output EXACTLY to the phrases below (where there should not be any more or any less ouputs):\n",
    "- \"4.5-5.5 Hours\"\n",
    "- \"1.5 hours\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5b5da515-1854-4c01-b9c2-de7ad291f9f1",
   "metadata": {},
   "outputs": [],
   "source": [
    "# YOUR CODE HERE\n",
    "decimal_hour_pattern=re.compile(r'\\b\\d+\\.\\d+(?:\\s*-\\s*\\d+\\.\\d+)?\\s*hours?\\b', re.IGNORECASE)\n",
    "matches = re.findall(decimal_hour_pattern, recipe_text)\n",
    "\n",
    "for item in matches:\n",
    "    print(str(item))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6c05ccbb-dc6f-4d79-8033-82588a06f706",
   "metadata": {},
   "outputs": [],
   "source": [
    "assert decimal_hour_pattern.findall(recipe_text) == ['4.5-5.5 Hours'] or [' 4.5-5.5 Hours'], \"Assertion failed for '4.5-5.5 Hours'.\"\n",
    "assert decimal_hour_pattern.findall(recipe_text) == ['1.5 hours'] or [' 1.5 Hours'], \"Assertion failed for '1.5 hours'.\"\n",
    "assert '1 hour' not in matches, \"Assertion failed because 1 Hour (an integer hour) is in matches\"\n",
    "assert '4-5 hours' not in matches, \"Assertion failed because 4-5 Hours (an integer hour range) is in matches\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3348c098",
   "metadata": {},
   "outputs": [],
   "source": [
    "# these would be hidden from the student\n",
    "positive_test_cases=['1.5 hours','3.5-4.5 Hours']\n",
    "negative_test_cases=['Overnight','Hour','two','1 hour']\n",
    "\n",
    "# this is all you need to generate feedback\n",
    "feedback = return_feedback(decimal_hour_pattern,positive_test_cases,negative_test_cases,NAME)\n",
    "print(feedback)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5ccf4709-433e-430a-8053-c5691374e2b1",
   "metadata": {},
   "source": [
    "# PART 2: Improving the Recipe Text\n",
    "Congrats to finding all of the recipe timeframes! Now that you have gotten more practice with regular expressions, you will now be using regular expression methods to make `recipe_text`much easier to read and extract necessary information! Since Daphne is most concerned about saving the most amount of time, the second part will be focused on answering important questions that will save Daphne the most amount of time!\n",
    "\n",
    "Here is a __quick summary of questions/coding sections for Part 2.__\n",
    "- __Q1: How to make the recipe easier to read?__ divide `recipe_text` to have spacing\n",
    "- __Q2: How to shorten the recipe timeframes to save time?__ replace the timeframes\n",
    "- __Q3: Which recipe has the most number of steps?__ find the recipes with the most number of steps"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c9b652e4-7f45-4757-ad73-4b375bce184b",
   "metadata": {},
   "source": [
    "## Q1: How to make the recipe_text easier to read?\n",
    "For Question 1, you want to use regex method(s) to divide the `recipe_text` docstring with a new line of whitespace between each recipe.\n",
    "\n",
    "1. Create a variable called `spaced_regex_pattern` and use the `re.compile()` method to store your regex pattern. Ensure sure that the regex pattern is written as a raw string by prefixing it with `r`.\\\n",
    "2. Create a variable called `spaced_recipe_text`. Within this variable, use the correct regex method to split the `recipe_text` docstring.\n",
    "3. Use both `spaced_regex_pattern` and `spaced_recipe_text` to create a function, which, given a string of recipes, will split them.\n",
    "\n",
    "Note: You can also print `spaced_recipe_text` to see if the necessary changes were made!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2dc40caf-2f2c-42af-8efc-fd72768f673d",
   "metadata": {},
   "outputs": [],
   "source": [
    "# YOUR CODE HERE\n",
    "def split_recipes(recipe_text):\n",
    "    spaced_regex_pattern = re.compile(r'(?=Recipe \\d+:)')\n",
    "    #spaced_regex_pattern = re.compile(r'(?=Recipe)')\n",
    "    spaced_recipe_text = re.split(spaced_regex_pattern, recipe_text.strip())\n",
    "    return spaced_recipe_text\n",
    "\n",
    "# Print each recipe + add a blank space between the line\n",
    "for recipe in split_recipes(recipe_text):\n",
    "    print(recipe.strip())\n",
    "    print()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "64978dd3",
   "metadata": {},
   "outputs": [],
   "source": [
    "spaced_recipe_text = split_recipes(recipe_text)\n",
    "is_Correct,feedback = test_split_function(split_recipes)\n",
    "#assert(is_Correct)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0ec5fe57-6828-4b02-9976-0dfa44f81cce",
   "metadata": {},
   "outputs": [],
   "source": [
    "return_feedback_split(split_recipes,NAME)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "654158b6-21ee-46e8-9b1b-5ddb52128e30",
   "metadata": {},
   "source": [
    "## Q2: How to shorten the recipe timeframes to save time?\n",
    "For Question 1, you want to use __one__ regex method(s) to divide the `recipe_text` docstring with a new line of whitespace between each recipe.\n",
    "\n",
    "1. Create a variable called `replace_regex_pattern` and use the `re.compile()` method to store your regex pattern. Ensure sure that the regex pattern is written as a raw string by prefixing it with `r`.\n",
    "2. Create a variable called `organized_recipe_text`. Within this variable use __one__ correct regex method to substitute 'two hours' and '2 Hours' with '1.5 hours'\n",
    "\n",
    "Note: You can also print `organized_recipe_text` to see if the necessary changes were made!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "17f4c112-b46f-4dc4-8c59-0bca649c2f94",
   "metadata": {},
   "outputs": [],
   "source": [
    "# YOUR CODE HERE\n",
    "replace_regex_pattern = re.compile(r'two hours | 2 Hours')\n",
    "\n",
    "for recipe in spaced_recipe_text:\n",
    "    organized_recipe_text = re.sub(replace_regex_pattern,'1.5 hours', recipe_text)\n",
    "    print(organized_recipe_text)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9ccbbd82-4571-48d7-b9ea-4327a35a5651",
   "metadata": {},
   "outputs": [],
   "source": [
    "assert 'two hours' not in organized_recipe_text\n",
    "assert '2 Hours' not in organized_recipe_text\n",
    "assert '1.5 hours' in organized_recipe_text"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python [conda env:python_primers]",
   "language": "python",
   "name": "conda-env-python_primers-py"
  },
  "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.12.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}