02_Strings(Advanced).ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "d77b1595",
   "metadata": {},
   "source": [
    "# Python Code Challenges: Strings (Advanced)\n",
    "\n",
    "#### Python Code Challenges involving Strings\n",
    "This article will help you review Python functions by providing some code challenges about strings.\n",
    "\n",
    "Some of these challenges are difficult! Take some time to think about them before starting to code.\n",
    "\n",
    "You might not get the solution correct on your first try — look at your output, try to find where you’re going wrong, and iterate on your solution.\n",
    "\n",
    "Finally, if you get stuck, use our solution code! If you “Check Answer” twice with an incorrect solution, you should see an option to get our solution code. However, truly investigate that solution — experiment and play with the solution code until you have a good grasp of how it is working. Good luck!\n",
    "\n",
    "## Function Syntax\n",
    "As a refresher, function syntax looks like this:\n",
    "\n",
    "```py\n",
    "def some_function(some_input1, some_input2):\n",
    "  # … do something with the inputs …\n",
    "  return output\n",
    "````\n",
    "\n",
    "For example, a function that finds the difference in length between two Strings would look like this:\n",
    "\n",
    "```py\n",
    "def lengthDiff(str1, str2):\n",
    "  return len(str1) - len(str2)\n",
    "````\n",
    "\n",
    "And this would produce output like:\n",
    "\n",
    "```\n",
    ">>> lengthDiff(\"Python\", \"rocks\")\n",
    "1\n",
    ">>> lengthDiff(\"Marco\", \"Polo\")\n",
    "1\n",
    ">>> lengthDiff(\"Kevin\", \"Durant\")\n",
    "-1\n",
    "````\n",
    "\n",
    "## Challenges\n",
    "We’ve included 5 challenges below. Try to answer all of them and polish up your problem-solving skills and your string expertise."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "038d65cc",
   "metadata": {},
   "source": [
    "## 1. Check Name\n",
    "You are creating an app that allows users to interact and share their coding project ideas online. The first step is to provide your name in the application and a greeting for other people to see which contains your name. Let’s create a function that is able to check if a user’s name is located within their greeting. We need a function that accepts two parameters, a string for our sentence and a string for a name. The function should return `True` if the name exists within the string (ignoring any differences in capitalization). Here is what we need to do:\n",
    "\n",
    "1. Define the function to accept two parameters, one string for the sentence and one string for the name\n",
    "2. Convert all of the strings to the same case so we don’t have to worry about differences in capitalization\n",
    "3. Check if the name is within the sentence. If so, then return `True`. Otherwise, return `False`\n",
    "\n",
    "### Coding question\n",
    "Write a function called `check_for_name` that takes two strings as parameters named `sentence` and `name`. The function should return `True` if `name` appears in `sentence` in all lowercase letters, all uppercase letters, or with any mix of uppercase and lowercase letters. The function should return `False` otherwise.\n",
    "\n",
    "For example, the following three calls should all return `True`:\n",
    "```py\n",
    "check_for_name(\"My name is Jamie\", \"Jamie\")\n",
    "check_for_name(\"My name is jamie\", \"Jamie\")\n",
    "check_for_name(\"My name is JAMIE\", \"Jamie\")\n",
    "```\n",
    "\n",
    "#### Hint\n",
    "`name.lower() in sentence.lower()` will help you find out if the name is in the sentence."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "76e0f6bf",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "True\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "# Write your check_for_name function here:\n",
    "def check_for_name(sentence, name):\n",
    "    if name.upper() in sentence.upper():\n",
    "        return True\n",
    "    return False\n",
    "\n",
    "# Uncomment these function calls to test your  function:\n",
    "print(check_for_name(\"My name is Jamie\", \"Jamie\"))\n",
    "# should print True\n",
    "print(check_for_name(\"My name is jamie\", \"Jamie\"))\n",
    "# should print True\n",
    "print(check_for_name(\"My name is Samantha\", \"Jamie\"))\n",
    "# should print False"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6147c3c6",
   "metadata": {},
   "source": [
    "#### Here is how we did it:\n",
    "```py\n",
    "def check_for_name(sentence, name):\n",
    "  return name.lower() in sentence.lower()\n",
    "```\n",
    "As you can see, this function can be created using one line. The `in` keyword will return `True` if the first provided string is within the second. So in this case, we’re checking if `name` is in `sentence`. In order to ignore differences in capitalization, we can use the `.lower()` function which converts all characters to lowercase characters."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4e44b8a8",
   "metadata": {},
   "source": [
    "## 2. Every Other Letter\n",
    "For this next challenge, we are going to create a function that extracts every other letter from a string and returns the resulting string. There are a few different ways you can solve this problem. Here are the steps needed for one of the ways:\n",
    "\n",
    "1. Define the function to accept one parameter for the string\n",
    "2. Create a new empty string to hold every other letter from the input string\n",
    "3. Loop through the input string while incrementing by two every time\n",
    "4. Inside the loop, append the character at the current location to the new string we initialized earlier\n",
    "5. Return the new string\n",
    "\n",
    "### Coding question\n",
    "Create a function named `every_other_letter` that takes a string named `word` as a parameter. The function should return a string containing every other letter in `word`.\n",
    "\n",
    "#### Hint\n",
    "The following code will print all letters of a string by index:\n",
    "```py\n",
    "my_string = \"Hello World\"\n",
    "for i in range(len(my_string)):\n",
    "  print my_string[i]\n",
    "```\n",
    "In this code, `i` starts at `0` and increase until it is once less than the length of `my_string`. How could you make `i` increase by more than one each time?\n",
    "\n",
    "Additionally, instead of printing each individual letter, you should add each letter to a new string using `+`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "e00ff568",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Cdcdm\n",
      "Hlowrd\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# Write your every_other_letter function here:\n",
    "def every_other_letter(word):\n",
    "  string = \"\"\n",
    "  for i in range(0,len(word), 2):\n",
    "    string += word[i]\n",
    "  return string\n",
    "# Uncomment these function calls to test your function:\n",
    "print(every_other_letter(\"Codecademy\"))\n",
    "# should print Cdcdm\n",
    "print(every_other_letter(\"Hello world!\"))\n",
    "# should print Hlowrd\n",
    "print(every_other_letter(\"\"))\n",
    "# should print "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "62513672",
   "metadata": {},
   "source": [
    "### Here is one way to do it:\n",
    "```py\n",
    "def every_other_letter(word):\n",
    "  every_other = \"\"\n",
    "  for i in range(0, len(word), 2):\n",
    "    every_other += word[i]\n",
    "  return every_other\n",
    "```\n",
    "In order to alternate which character is added to the `every_other string`, we use a `range` of indices which starts at index 0 (the beginning of our `word`) and ends at the end of our `word`. The third parameter in the `range` function determines what value to increment by. In this case, we want to increment by 2 in order to get every other letter.\n",
    "\n",
    "Another way to loop through all indices of our original string, but only add the letters that correspond to an even index. As a challenge, try solving this problem that way!"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9c61e1ff",
   "metadata": {},
   "source": [
    "## 3. Reverse\n",
    "This one is similar to the last challenge. Instead of selecting every other letter, we want to reverse the entire string. This can be performed in a similar manner, but we will need to modify the `range` we are using. Here is what we need to do:\n",
    "\n",
    "1. Define the function to accept one parameter for the string\n",
    "2. Create a new empty string to hold the reversed string\n",
    "3. Loop through the input string by starting at the end, and working towards the beginning\n",
    "4. Inside the loop, append the character at the current location to the new string we initialized earlier\n",
    "5. Return the result\n",
    "\n",
    "### Coding question\n",
    "Write a function named `reverse_string` that has a string named `word` as a parameter. The function should return `word` in reverse.\n",
    "\n",
    "#### Hint\n",
    "Just like the last challenge, you want to access each letter of `word` by it's index.\n",
    "```py\n",
    "my_string = \"Hello World\"\n",
    "for i in range(len(my_string)):\n",
    "  print my_string[i]\n",
    "```\n",
    "However, you don’t want `i` to start at `0`. Instead you want it to start at the last index of your string (`len(my_string)-1`) and end at `0`.\n",
    "\n",
    "Edit the call to the `range` function to do this. Remember, the `range` function can take three parameters: the starting number (inclusive), the ending number (exclusive), and the step. To count down, make the step `-1`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "f1f00e1a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ymedacedoC\n",
      "!dlrow olleH\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# Write your reverse_string function here:\n",
    "def reverse_string(word):\n",
    "  reversed = \"\"\n",
    "  for i in range(len(word)-1, -1, -1):\n",
    "    reversed += word[i]\n",
    "  return reversed\n",
    "\n",
    "# Uncomment these function calls to test your  function:\n",
    "print(reverse_string(\"Codecademy\"))\n",
    "# should print ymedacedoC\n",
    "print(reverse_string(\"Hello world!\"))\n",
    "# should print !dlrow olleH\n",
    "print(reverse_string(\"\"))\n",
    "# should print"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bac533a4",
   "metadata": {},
   "source": [
    "#### Here is this solution:\n",
    "```py\n",
    "def reverse_string(word):\n",
    "  reverse = \"\"\n",
    "  for i in range(len(word)-1, -1, -1):\n",
    "    reverse += word[i]\n",
    "  return reverse\n",
    "```\n",
    "This is similar to the last solution, but our `range` has been modified in order to start at the last index of the string (length of the string minus one) up to the first index. Since the parameter for the ending index is exclusive we need to provide the index of one more iteration than what we want to stop at. We want to stop at `0`, and since we are incrementing by `-1`, we will set the ending index to -1. Finally, make sure to add the third parameter of `-1`. This makes us increment by -1 at each step."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3f9dfab0",
   "metadata": {},
   "source": [
    "## 4. Make Spoonerism\n",
    "A Spoonerism is an error in speech when the first syllables of two words are switched. For example, a Spoonerism is made when someone says “Belly Jeans” instead of “Jelly Beans”. We are going to make a function that is similar, but instead of using the first syllable, we are going to switch the first character of two words. Here is what we need to do:\n",
    "\n",
    "1. Define the function to accept two parameters for our two words\n",
    "2. Get the first character of the first word and the first character of the second word\n",
    "3. Get the remaining characters of the first word and the remaining characters of the second word.\n",
    "4. Append the first character of the second word to the remaining character of the first word\n",
    "5. Append a space character\n",
    "6. Append the first character of the first word to the remaining characters of the second word.\n",
    "7. Return the result\n",
    "\n",
    "### Coding question\n",
    "Write a function called `make_spoonerism` that takes two strings as parameters named `word1` and `word2`. Finding the first syllable of a word is a difficult task, so for our function, we’re going to switch the first letters of each word. Return the two new words as a single string separated by a space.\n",
    "\n",
    "#### Hint\n",
    "`word2[0]` will access the first letter of `word2`.`word1[1:]` will access everything but the first letter of `word1`. Combining those with a `+` will give you your first new word."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "f60e057e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Lodecademy Cearn\n",
      "wello Horld!\n",
      "b a\n"
     ]
    }
   ],
   "source": [
    "# Write your make_spoonerism function here:\n",
    "def make_spoonerism(word1, word2):\n",
    "  new1 = ''\n",
    "  new2 = ''\n",
    "  new1 += word2[0]\n",
    "  new1 += word1[1:]\n",
    "  new2 += word1[0]\n",
    "  new2 += word2[1:]\n",
    "  return new1 + ' ' + new2\n",
    "\n",
    "\n",
    "# Uncomment these function calls to test your function:\n",
    "print(make_spoonerism(\"Codecademy\", \"Learn\"))\n",
    "# should print Lodecademy Cearn\n",
    "print(make_spoonerism(\"Hello\", \"world!\"))\n",
    "# should print wello Horld!\n",
    "print(make_spoonerism(\"a\", \"b\"))\n",
    "# should print b a"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1b146656",
   "metadata": {},
   "source": [
    "#### Here is how we did it:\n",
    "```py\n",
    "def make_spoonerism(word1, word2):\n",
    "  return word2[0]+word1[1:]+\" \"+word1[0]+word2[1:]\n",
    "```\n",
    "We can accomplish the task in one line by appending and slicing at the same time. We can get the first index of our words by using `word1[0]` and `word2[0]` which gets the letter at the first index. In order to get the remaining letters we can use `word1[1:]` and `word2[1:]`. This returns all characters in the strings starting with index 1 and on. We concatenate everything together to get the result."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bcb6d547",
   "metadata": {},
   "source": [
    "## 5. Add Exclamation\n",
    "Let’s say we are writing a program that displays a large message on a blimp and we need to fill in any missing space if a short phrase is provided. Our function will accept a string and if the size is less than 20, it will fill in the remaining space with exclamation marks until the size reaches 20. If the provided string already has a length greater than 20, then we will simply return the original string. Here are the steps:\n",
    "\n",
    "1. Define the function to accept one parameter for our string\n",
    "2. Loop while the length of our input string is less than 20\n",
    "3. Inside the loop, append an exclamation mark\n",
    "4. Once done, return the result\n",
    "\n",
    "### Coding question\n",
    "Create a function named `add_exclamation` that has one parameter named `word`. This function should add exclamation points to the end of `word` until `word` is `20` characters long. If `word` is already at least `20` characters long, just return `word`.\n",
    "\n",
    "#### Hint\n",
    "Use a `while` loop to add exclamation points to `word`. The `while` loop should stop when the length of `word` is greater than or equal to `20`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "e8430f11",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Codecademy!!!!!!!!!!\n",
      "Codecademy is the best place to learn\n"
     ]
    }
   ],
   "source": [
    "# Write your add_exclamation function here:\n",
    "def add_exclamation(word):\n",
    "  new_word = word\n",
    "  if len(word) <= 20:\n",
    "    for i in range(20 - len(word)):\n",
    "      new_word += '!'\n",
    "    return new_word \n",
    "\n",
    "  return word\n",
    "# Uncomment these function calls to test your function:\n",
    "print(add_exclamation(\"Codecademy\"))\n",
    "# should print Codecademy!!!!!!!!!!\n",
    "print(add_exclamation(\"Codecademy is the best place to learn\"))\n",
    "# should print Codecademy is the best place to learn"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5bc51326",
   "metadata": {},
   "source": [
    "#### Here is this solution:\n",
    "```py\n",
    "def add_exclamation(word):\n",
    "  while(len(word) < 20):\n",
    "    word += \"!\"\n",
    "  return word\n",
    "```\n",
    "This function shows how we can continuously append to our string based on some condition. In this case, we keep testing the length of the string to see if we should keep going. Once the length has reached 20, either by adding exclamation marks or by already being long, we return the result."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8db41bfa",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.11.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}