Final Exam - 04 April 2020 Group 2.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Final Exam - 04 April 2020 Group 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Problem 1. Password Reset"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Yet again you have forgotten your password... Naturally it`s not the first time this has happened. Actually you got so tired of it that you decided to help yourself with a smart solution. \n",
    "\n",
    "<br><br>Write a password reset program that performs a series of commands upon a predefined string. First, you will receive a string and afterwards, until the command \"Done\" is given, you will be receiving strings with commands split by a single space. The commands will be the following:\n",
    "* TakeOdd\n",
    "    * Takes only the characters at odd indices and concatenates them together to obtain the new raw password and then prints it.\n",
    "* Cut {index} {length}\n",
    "    * Gets the substring with the given length starting from the given index from the password and removes its first occurrence of it, then prints the password on the console.\n",
    "    * The given index and length will always be valid.\n",
    "* Substitute {substring} {substitute}\n",
    "* If the raw password contains the given substring, replaces all of its occurrences with the substitute text given and prints the result.\n",
    "* If it doesn’t, prints \"Nothing to replace!\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Input\n",
    "* You will be receiving strings until the \"Done\" command is given."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Output\n",
    "* After the \"Done\" command is received, print:\n",
    "    * \"Your password is: {password}\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Constraints\n",
    "* The indexes from the \"Cut {index} {length}\" command will always be valid."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Siiceercaroetavm!:?:ahsott.:i:nstupmomceqr \n",
      "TakeOdd\n",
      "icecream::hot::summer\n",
      "Cut 15 3\n",
      "icecream::hot::mer\n",
      "Substitute :: -\n",
      "icecream-hot-mer\n",
      "Substitute | ^\n",
      "Nothing to replace!\n",
      "Done\n",
      "Your password is: icecream-hot-mer\n"
     ]
    }
   ],
   "source": [
    "def odd(input_password):\n",
    "    raw_pass = \"\"\n",
    "    for i in range(len(input_password)):\n",
    "        if i % 2 != 0:\n",
    "            raw_pass += input_password[i]\n",
    "    print(raw_pass)\n",
    "    return raw_pass\n",
    "\n",
    "\n",
    "def cut(raw_pass, index, length):\n",
    "    raw_pass = raw_pass[:index] + raw_pass[index + length:]\n",
    "    print(raw_pass)\n",
    "    return raw_pass\n",
    "\n",
    "\n",
    "def substitute(raw_pass, substring, substitute):\n",
    "    if substring in raw_pass:\n",
    "        raw_pass = raw_pass.replace(substring, substitute)\n",
    "        print(raw_pass)\n",
    "    else:\n",
    "        print(\"Nothing to replace!\")\n",
    "    return raw_pass\n",
    "\n",
    "\n",
    "password = input()\n",
    "\n",
    "while True:\n",
    "    command = input()\n",
    "    if command == \"Done\":\n",
    "        break\n",
    "\n",
    "    command = command.split(\" \")\n",
    "    action = command[0]\n",
    "\n",
    "    if action == \"TakeOdd\":\n",
    "        password = odd(password)\n",
    "    elif action == \"Cut\":\n",
    "        password = cut(password, int(command[1]), int(command[2]))\n",
    "    elif action == \"Substitute\":\n",
    "        password = substitute(password, command[1], command[2])\n",
    "\n",
    "print(f\"Your password is: {password}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Problem 2. Fancy Barcodes"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Your first task is to determine if the given sequence of characters is a valid barcode or not. \n",
    "<br><br>Each line must not contain anything else but a valid barcode. A barcode is valid when:\n",
    "* Is surrounded with a \"@\" followed by one or more \"#\" \n",
    "* Is at least 6  characters long (without the surrounding \"@\" or \"#\")\n",
    "* Starts with a capital letter\n",
    "* Contains only letters (lower and upper case) and digits\n",
    "* Ends with a capital letter\n",
    "<br><br>Examples of valid barcodes: @#FreshFisH@#, @###Brea0D@###, @##Che46sE@##, @##Che46sE@###\n",
    "<br><br>Examples of invalid barcodes: ##InvaliDiteM##, @InvalidIteM@, @#Invalid_IteM@#\n",
    "<br><br>Next you have to determine the product group of the item from the barcode. The product group is obtained by concatenating all the digits found in the barcode. If there are no digits present in the barcode, the default product group is \"00\".\n",
    "<br><br>Examples:  \n",
    "<br>@#FreshFisH@# -> product group: 00\n",
    "<br>@###Brea0D@### -> product group: 0\n",
    "<br>@##Che4s6E@## -> product group: 46"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Input\n",
    "On the first line you will be given an integer n – the count of barcodes that you will be receiving next. \n",
    "On the next n lines, you will receive different strings."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Output\n",
    "For each barcode that you process, you need to print a message.\n",
    "<br>If the barcode is invalid:\n",
    "* \"Invalid barcode\"\n",
    "<br>If the barcode is valid:\n",
    "* \"Product group: {product group}\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n",
      "@#FreshFisH@#\n",
      "Product group: 00\n",
      "@###Brea0D@###\n",
      "Product group: 0\n",
      "@##Che4s6E@##\n",
      "Product group: 46\n"
     ]
    }
   ],
   "source": [
    "import re\n",
    "\n",
    "count_of_barcodes = int(input())\n",
    "\n",
    "for n in range(count_of_barcodes):\n",
    "    product_group = \"\"\n",
    "    barcode = input()\n",
    "    regex = r\"@[#]+[A-Z](?P<product>[A-Za-z0-9]{4,})[A-Z]@[#]+\"\n",
    "    code = re.findall(regex, barcode)\n",
    "    if code:\n",
    "        code = \"\".join(code)\n",
    "        for symbol in code:\n",
    "            if symbol.isdigit():\n",
    "                product_group += symbol\n",
    "        if product_group == \"\":\n",
    "            product_group = \"00\"\n",
    "        print(f\"Product group: {product_group}\")\n",
    "    else:\n",
    "        print(\"Invalid barcode\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Problem 3. Heroes of Code and Logic VII"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You got your hands on the most recent update on the best MMORPG of all time – Heroes of Code and Logic. You want to play it all day long! So cancel all other arrangements and create your party!\n",
    "<br><br>On the first line of the standard input you will receive an integer n – the number of heroes that you can choose for your party. On the next n lines, the heroes themselves will follow with their hit points and mana points separated by empty space in the following format: \n",
    "<br>{hero name} {HP} {MP} \n",
    "-\twhere HP stands for hit points and MP for mana points\n",
    "-\ta hero can have a maximum of 100 HP and 200 MP\n",
    "<br>After you have successfully picked your heroes, you can start playing the game.  You will be receiving different commands, each on a new line, separated by \" – \", until the \"End\" command is given. \n",
    "<br>There are several actions that can be performed by the heroes:\n",
    "<br>CastSpell – {hero name} – {MP needed} – {spell name} \n",
    "* If the hero has the required MP, he casts the spell, thus reducing his MP. Print this message: \n",
    "    * \"{hero name} has successfully cast {spell name} and now has {mana points left} MP!\"\n",
    "* If the hero is unable to cast the spell print:\n",
    "    * \"{hero name} does not have enough MP to cast {spell name}!\"\n",
    "<br>TakeDamage – {hero name} – {damage} – {attacker}\n",
    "* Reduce the hero HP by the given damage amount. If the hero is still alive (his HP is greater than 0) print:\n",
    "    * \"{hero name} was hit for {damage} HP by {attacker} and now has {current HP} HP left!\"\n",
    "* If the hero has died, remove him from your party and print:\n",
    "    * \"{hero name} has been killed by {attacker}!\"\n",
    "<br>Recharge – {hero name} – {amount}\n",
    "* The hero increases his MP. If a command is given that would bring the MP of the hero above 200, MP is increased so that it reaches the maximum. Print the following message:\n",
    "    * \"{hero name} recharged for {amount recovered} MP!\"\n",
    "<br>Heal – {hero name} – {amount}\n",
    "* The hero increases his HP. If a command is given that would bring the HP of the hero above 100, HP is increased so that it reaches the maximum. Print the following message:\n",
    "    * \"{hero name} healed for {amount recovered} HP!\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Input\n",
    "* On the first line of the standard input you will receive an integer n\n",
    "* On the next n lines, the heroes themselves will follow with their hit points and mana points separated by empty space in the following format\n",
    "* You will be receiving different commands, each on a new line, separated by \" – \", until the \"End\" command is given"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Output\n",
    "* Print all members of your party who are still alive, sorted by their HP in descending order, then by their name in ascending order, in the following format (their HP/MP need to be indented 2 spaces):\n",
    "<br>\"{hero name}\n",
    "<br>HP: {current HP}\n",
    "<br>MP: {current MP}\n",
    "<br>...\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Constraints\n",
    "* The starting HP/MP of the heroes will be valid, 32-bit integers, will never be negative or exceed the respective limits.\n",
    "* The HP/MP amounts in the commands will never be negative.\n",
    "* The hero names in the commands will always be valid members of your party. No need to check that explicitly"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n",
      "Solmyr 85 120\n",
      "Kyrre 99 50\n",
      "Heal - Solmyr - 10\n",
      "Solmyr healed for 10 HP!\n",
      "Recharge - Solmyr - 50\n",
      "Solmyr recharged for 50 MP!\n",
      "TakeDamage - Kyrre - 66 - Orc\n",
      "Kyrre was hit for 66 HP by Orc and now has 33 HP left!\n",
      "CastSpell - Kyrre - 15 - ViewEarth\n",
      "Kyrre has successfully cast ViewEarth and now has 35 MP!\n",
      "End\n",
      "Solmyr\n",
      "HP: 95\n",
      "MP: 170\n",
      "Kyrre\n",
      "HP: 33\n",
      "MP: 35\n"
     ]
    }
   ],
   "source": [
    "def all_heroes(count):\n",
    "    my_heroes = {}\n",
    "    for n in range(count):\n",
    "        hero, hp, mp = input().split()\n",
    "        hp = int(hp)\n",
    "        mp = int(mp)\n",
    "        if hero not in my_heroes:\n",
    "            my_heroes[hero] = [hp, mp]\n",
    "    return my_heroes\n",
    "\n",
    "\n",
    "def cast_spell(mp, my_hero, second, third):\n",
    "    if mp >= second:\n",
    "        mp -= second\n",
    "        print(f\"{my_hero} has successfully cast {third} and now has {mp} MP!\")\n",
    "    else:\n",
    "        print(f\"{my_hero} does not have enough MP to cast {third}!\")\n",
    "    return mp\n",
    "\n",
    "\n",
    "def take_damage(my_heroes, my_hero, second, third):\n",
    "    my_heroes[my_hero][0] -= second\n",
    "    if my_heroes[my_hero][0] <= 0:\n",
    "        my_heroes.pop(my_hero)\n",
    "        print(f\"{my_hero} has been killed by {third}!\")\n",
    "    else:\n",
    "        print(f\"{my_hero} was hit for {second} HP by {third} and now has {my_heroes[my_hero][0]} HP left!\")\n",
    "    return my_heroes\n",
    "\n",
    "\n",
    "def recharge_or_heal(second, hp_or_mp, max_pts):\n",
    "    hp_or_mp += second\n",
    "    if hp_or_mp > max_pts:\n",
    "        recovered_amount = second - (hp_or_mp - max_pts)\n",
    "        hp_or_mp = max_pts\n",
    "    else:\n",
    "        recovered_amount = second\n",
    "    return hp_or_mp, recovered_amount\n",
    "\n",
    "\n",
    "heroes = all_heroes(int(input()))\n",
    "\n",
    "while True:\n",
    "    command = input()\n",
    "    if command == \"End\":\n",
    "        break\n",
    "    command = command.split(\" - \")\n",
    "    action = command[0]\n",
    "    hero_name = command[1]\n",
    "\n",
    "    if action == \"CastSpell\":\n",
    "        heroes[hero_name][1] = cast_spell(heroes[hero_name][1], hero_name, int(command[2]), command[3])\n",
    "    elif action == \"TakeDamage\":\n",
    "        heroes = take_damage(heroes, hero_name, int(command[2]), command[3])\n",
    "    elif action == \"Recharge\":\n",
    "        max_points = 200\n",
    "        heroes[hero_name][1], recovered = recharge_or_heal(int(command[2]), heroes[hero_name][1], max_points)\n",
    "        print(f\"{hero_name} recharged for {recovered} MP!\")\n",
    "    elif action == \"Heal\":\n",
    "        max_points = 100\n",
    "        heroes[hero_name][0], recovered = recharge_or_heal(int(command[2]), heroes[hero_name][0], max_points)\n",
    "        print(f\"{hero_name} healed for {recovered} HP!\")\n",
    "\n",
    "heroes = dict(sorted(heroes.items(), key=lambda x: (-x[1][0], x[0])))\n",
    "\n",
    "for key, value in heroes.items():\n",
    "    print(key)\n",
    "    print(f\"HP: {heroes[key][0]}\")\n",
    "    print(f\"MP: {heroes[key][1]}\")"
   ]
  }
 ],
 "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
}