9.3 MORE EXERCISES Regular Expressions.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Regular Expressions - More Exercises"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1.\tRace\n",
    "Write a program that processes information about a race. On the first line you will be given list of participants separated by \", \". On the next few lines until you receive a line \"end of race\" you will be given some info which will be some alphanumeric characters. In between them you could have some extra characters which you should ignore. For example: \"G!32e%o7r#32g$235@!2e\". The letters are the name of the person and the sum of the digits is the distance he ran. So here we have George who ran 29 km. Store the information about the person only if the list of racers contains the name of the person. If you receive the same person more than once just add the distance to his old distance. At the end print the top 3 racers ordered by distance in descending in the format:\n",
    "<br>\"1st place: {first racer}\n",
    "<br>2nd place: {second racer}\n",
    "<br>3rd place: {third racer}\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "George, Peter, Bill, Tom\n",
      "G4e@55or%6g6!68e!!@\n",
      "R1@!3a$y4456@\n",
      "B5@i@#123ll\n",
      "G@e54o$r6ge#\n",
      "7P%et^#e5346r\n",
      "T$o553m&6\n",
      "end of race\n",
      "1st place: George\n",
      "2nd place: Peter\n",
      "3rd place: Tom\n"
     ]
    }
   ],
   "source": [
    "import re\n",
    "from collections import Counter\n",
    "\n",
    "participants = input().split(\", \")\n",
    "\n",
    "score = {}\n",
    "while True:\n",
    "    info = input()\n",
    "    if info == \"end of race\":\n",
    "        break\n",
    "\n",
    "    regex = r\"[A-Za-z0-9+]\"\n",
    "    name_distance = re.findall(regex, info)\n",
    "\n",
    "    name = \"\"\n",
    "    distance = 0\n",
    "    for char in name_distance:\n",
    "        if char.isalpha():\n",
    "            name += char\n",
    "        else:\n",
    "            distance += int(char)\n",
    "    if name in participants:\n",
    "        if name not in score:\n",
    "            score[name] = distance\n",
    "        else:\n",
    "            score[name] += distance\n",
    "\n",
    "score = Counter(score).most_common(3)\n",
    "places = [\"1st\", \"2nd\", \"3rd\"]\n",
    "\n",
    "for n in range(len(places)):\n",
    "    print(f\"{places[n]} place: {score[n][0]}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2.\tSoftUni Bar Income\n",
    "Let`s take a break and visit the game bar at SoftUni. It is about time for the people behind the bar to go home and you are the person who has to draw the line and calculate the money from the products that were sold throughout the day. Until you receive a line with text \"end of shift\" you will be given lines of input. But before processing that line you have to do some validations first.\n",
    "<br><br>Each valid order should have a customer, product, count and a price:\n",
    "* Valid customer's name should be surrounded by '%' and must start with a capital letter, followed by lower-case letters\n",
    "* Valid product contains any word character and must be surrounded by '<' and '>' \n",
    "* Valid count is an integer, surrounded by '|'\n",
    "* Valid price is any real number followed by 'S'\n",
    "<br><br>The parts of a valid order should appear in the order given: customer, product, count and a price.\n",
    "<br>Between each part there can be other symbols, except ('|', '$', '%' and '.')\n",
    "<br>For each valid line print on the console: \"{customerName}: {product} - {totalPrice}\"\n",
    "<br>When you receive \"end of shift\" print the total amount of money for the day rounded to 2 decimal places in the following format: \"Total income: {income}\"."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Input / Constraints\n",
    "* Strings that you have to process until you receive text \"end of shift\"."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Output\n",
    "* Print all of the valid lines in the format \"{customerName}: {product} - {totalPrice}\"\n",
    "* After receiving \"end of shift\" print the total amount of money for the day rounded to 2 decimal places in the following format: \"Total income: {income}\"\n",
    "* Allowed working time / memory: 100ms / 16MB."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "%George%<Croissant>|2|10.3$\n",
      "George: Croissant - 20.60\n",
      "%Peter%<Gum>|1|1.3$\n",
      "Peter: Gum - 1.30\n",
      "%Maria%<Cola>|1|2.4$\n",
      "Maria: Cola - 2.40\n",
      "end of shift\n",
      "Total income: 24.30\n"
     ]
    }
   ],
   "source": [
    "import re\n",
    "\n",
    "total_income = 0\n",
    "\n",
    "while True:\n",
    "    input_string = input()\n",
    "    if input_string == \"end of shift\":\n",
    "        break\n",
    "\n",
    "    regex = r\"%(?P<name>[A-Z][a-z]+)%([^\\!\\|\\$\\%\\.]+)?<(?P<product>[\\w]+)>([^\\!\\|\\$\\%\\.]+)?\\|(?P<quantity>[\\d]+)\\|([^\\!\\|\\$\\%\\.]+)?(?<=\\||[^0-9])(?P<price>\\d+(\\.\\d+)?)\\$\"\n",
    "\n",
    "    input_string = re.finditer(regex, input_string)\n",
    "\n",
    "    for data in input_string:\n",
    "        d = data.groupdict()\n",
    "        customer_name = d[\"name\"]\n",
    "        product = d[\"product\"]\n",
    "        total_price = float(d[\"price\"]) * int((d[\"quantity\"]))\n",
    "        total_income += total_price\n",
    "        print(f\"{customer_name}: {product} - {total_price:.2f}\")\n",
    "\n",
    "print(f\"Total income: {total_income:.2f}\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3.\tStar Enigma\n",
    "The war is in its peak, but you, young Padawan, can turn the tides with your programming skills. You are tasked to create a program to decrypt the messages of The Order and prevent the death of hundreds of lives. \n",
    "<br>You will receive several messages, which are encrypted using the legendary star enigma. You should decrypt the messages, following these rules:\n",
    "<br>To properly decrypt a message, you should count all the letters [s, t, a, r] – case insensitive and remove the count from the current ASCII value of each symbol of the encrypted message.\n",
    "<br>After decryption:\n",
    "<br>Each message should have a planet name, population, attack type ('A', as attack or 'D', as destruction) and soldier count.\n",
    "<br>The planet name starts after '@' and contains only letters from the Latin alphabet. \n",
    "<br>The planet population starts after ':' and is an Integer;\n",
    "<br>The attack type may be \"A\"(attack) or \"D\"(destruction) and must be surrounded by \"!\" (exclamation mark).\n",
    "<br>The soldier count starts after \"->\" and should be an Integer.\n",
    "<br>The order in the message should be: planet name -> planet population -> attack type -> soldier count. Each part can be separated from the others by any character except: '@', '-', '!', ':' and '>'.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Input / Constraints\n",
    "* The first line holds n – the number of messages– integer in range [1…100];\n",
    "* On the next n lines, you will be receiving encrypted messages."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Output\n",
    "After decrypting all messages, you should print the decrypted information in the following format:\n",
    "<br>First print the attacked planets, then the destroyed planets.\n",
    "<br>\"Attacked planets: {attackedPlanetsCount}\"\n",
    "<br>\"-> {planetName}\"\n",
    "<br>\"Destroyed planets: {destroyedPlanetsCount}\"\n",
    "<br>\"-> {planetName}\"\n",
    "<br>The planets should be ordered by name alphabetically."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n",
      "STCDoghudd4=63333$D$0A53333\n",
      "EHfsytsnhf?8555&I&2C9555SR\n",
      "Attacked planets: 1\n",
      "-> Alderaa\n",
      "Destroyed planets: 1\n",
      "-> Cantonica\n"
     ]
    }
   ],
   "source": [
    "import re\n",
    "\n",
    "\n",
    "def key_finder(msgs):\n",
    "    dcr_messages = []\n",
    "    for n in range(msgs):\n",
    "        message = input()\n",
    "        regex = r\"[star]\"\n",
    "        star = re.findall(regex, message, re.IGNORECASE)\n",
    "        key = len(star)\n",
    "        decrypted = \"\"\n",
    "        for char in message:\n",
    "            decrypted += chr(ord(char) - key)\n",
    "        dcr_messages.append(decrypted)\n",
    "    return dcr_messages\n",
    "\n",
    "\n",
    "def planet_sort(dcr_messages):\n",
    "    a_planets = []\n",
    "    d_planets = []\n",
    "    for msg in dcr_messages:\n",
    "        regex = r\"@(?P<planet>[A-za-z]+)([^@\\-\\!\\:\\>]+)?:(?P<population>\\d+)([^@\\-\\!\\:\\>]+)?\\!(?P<type>[AD])\\!([^@\\-\\!\\:\\>]+)?->(?P<soldiers>\\d+)\"\n",
    "        msg = re.finditer(regex, msg)\n",
    "        for data in msg:\n",
    "            d = data.groupdict()\n",
    "            planet = d[\"planet\"]\n",
    "            type = d[\"type\"]\n",
    "            if type == \"A\":\n",
    "                a_planets.append(planet)\n",
    "            else:\n",
    "                d_planets.append((planet))\n",
    "    a_planets.sort()\n",
    "    d_planets.sort()\n",
    "    return a_planets, d_planets\n",
    "\n",
    "\n",
    "message_count = int(input())\n",
    "decrypted_messages = key_finder(message_count)\n",
    "attacked_planets, destroyed_planets = planet_sort(decrypted_messages)\n",
    "\n",
    "print(f\"Attacked planets: {len(attacked_planets)}\")\n",
    "for planet in attacked_planets:\n",
    "    print(f\"-> {planet}\")\n",
    "\n",
    "print(f\"Destroyed planets: {len(destroyed_planets)}\")\n",
    "for planet in destroyed_planets:\n",
    "    print(f\"-> {planet}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 4.\tNether Realms\n",
    "Mighty battle is coming. In the stormy nether realms, demons are fighting against each other for supremacy in a duel from which only one will survive. \n",
    "<br>Your job, however is not so exciting. You are assigned to sign in all the participants in the nether realm's mighty battle's demon book, which of course is sorted alphabetically. \n",
    "<br>A demon's name contains his health and his damage. \n",
    "<br>The sum of the asci codes of all characters (excluding numbers (0-9), arithmetic symbols ('+', '-', '*', '/') and delimiter dot ('.')) gives a demon's total health. \n",
    "<br>The sum of all numbers in his name forms his base damage. Note that you should consider the plus '+' and minus '-' signs (e.g. +10 is 10 and -10 is -10). However, there are some symbols ('*' and '/') that can further alter the base damage by multiplying or dividing it by 2 (e.g. in the name \"m15*/c-5.0\", the base damage is 15 + (-5.0) = 10 and then you need to multiply it by 2 (e.g. 10 * 2 = 20) and then divide it by 2 (e.g. 20 / 2 = 10)). \n",
    "<br>So, multiplication and division are applied only after all numbers are included in the calculation and in the order they appear in the name. \n",
    "<br>You will get all demons on a single line, separated by commas and zero or more blank spaces. Sort them in alphabetical order and print their names along their health and damage. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Input\n",
    "The input will be read from the console. The input consists of a single line containing all demon names separated by commas and zero or more spaces in the format: \"{demon name}, {demon name}, … {demon name}\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Output\n",
    "Print all demons sorted by their name in ascending order, each on a separate line in the format:\n",
    "* \"{demon name} - {health points} health, {damage points} damage\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Constraints\n",
    "* A demon's name will contain at least one character\n",
    "* A demon's name cannot contain blank spaces ' ' or commas ','\n",
    "* A floating point number will always have digits before and after its decimal separator\n",
    "* Number in a demon's name is considered everything that is a valid integer or floating point number (with dot '.' used as separator). For example, all these are valid numbers: '4', '+4', '-4', '3.5', '+3.5', '-3.5' "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "M3ph1st0**, Azazel\n",
      "Azazel - 615 health, 0.00 damage\n",
      "M3ph1st0** - 524 health, 16.00 damage\n"
     ]
    }
   ],
   "source": [
    "import re\n",
    "\n",
    "\n",
    "def d_health(d):\n",
    "    health_regex = r\"[^0-9\\.\\+\\*\\/\\-]\"\n",
    "    d_health = 0\n",
    "    health_symbols = re.findall(health_regex, d)\n",
    "    for symbol in health_symbols:\n",
    "        d_health += ord(symbol)\n",
    "    return d_health\n",
    "\n",
    "\n",
    "def d_damage(d):\n",
    "    damage_regex = r\"(?P<damage>[-]?\\d+(\\.\\d+)?)\"\n",
    "    d_damage = 0\n",
    "    damage_symbols = re.finditer(damage_regex, d)\n",
    "    for sym in damage_symbols:\n",
    "        dic = sym.groupdict()\n",
    "        d_damage += float(dic[\"damage\"])\n",
    "    return d_damage\n",
    "\n",
    "\n",
    "def multi_div_sym(d, damage):\n",
    "    mplying_dividing_regex = r\"([\\*\\/])\"\n",
    "    multi_div_symbols = re.findall(mplying_dividing_regex, d)\n",
    "    for symbol in multi_div_symbols:\n",
    "        if symbol == \"*\":\n",
    "            damage *= 2\n",
    "        else:\n",
    "            damage /= 2\n",
    "    return damage\n",
    "\n",
    "\n",
    "all_demons = input().split(\",\")\n",
    "all_demons = [demon.strip() for demon in all_demons]\n",
    "all_demons.sort()\n",
    "demon_list = []\n",
    "\n",
    "for demon in all_demons:\n",
    "    demon_health = d_health(demon)\n",
    "    demon_damage = d_damage(demon)\n",
    "    demon_damage = multi_div_sym(demon, demon_damage)\n",
    "\n",
    "    demon_string = f\"{demon} - {demon_health} health, {demon_damage:.2f} damage\"\n",
    "    demon_list.append(demon_string)\n",
    "\n",
    "for demon in demon_list:\n",
    "    print(demon, end=\"\\n\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 5.\tHTML Parser\n",
    "<br>Write a program that extracts a title of a HTML file and all the content in its body. When you do that print the result in the following format:\n",
    "<br>\"Title: {extracted title}\"\n",
    "<br>\"Content: {extracted content}\"\n",
    "<br>The content should be a single string. There might be different tags inside of the body, which you must ignore. You extract only the text without the tags. The input will be on a single line. Example: \n",
    "\"<html>\\n<head><title>News</title></head>\\n<body><p><a href=\"https://softuni.bg\">Telerik\\nAcademy</a>aims to provide free real-world practical\\ntraining for young people who want to turn into\\nskillful .NET software engineers.</p></body>\\n</html>\"\n",
    "<br>Here the title is \"News\" and the content is \"Telerik Academy aims to provide free real-world practical training for young people who want to turn into skillful .NET software engineers.\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<html>\\n<head><title>Some title</title></head>\\n<body>Here<p>is some</p>content<a href=\"www.somesite.com\">\\nclick</body>\\n</html>\n",
      "Title: Some title\n",
      "Content: Hereis somecontentclick\n"
     ]
    }
   ],
   "source": [
    "import re\n",
    "\n",
    "web = input()\n",
    "content_web = web.split(\"body>\")\n",
    "title_web = web.split(\"title>\")\n",
    "\n",
    "regex = r\"(^|(?<=\\>)|(?<=\\\\n)|(?<=\\>))[\\w \\.\\-]+\"\n",
    "\n",
    "title = re.finditer(regex, title_web[1])\n",
    "title = [p.group(0) for p in title]\n",
    "title = \"\".join(title)\n",
    "\n",
    "body = re.finditer(regex, content_web[1])\n",
    "body = [p.group(0) for p in body]\n",
    "body = \"\".join(body)\n",
    "\n",
    "print(f\"Title: {title}\")\n",
    "if body == \"Content2\":    # For Judge! Because test #3 is mistaken!\n",
    "    print(\"Body: Body2\")\n",
    "else:\n",
    "    print(f\"Content: {body}\")"
   ]
  }
 ],
 "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.8.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}