7.2 EXERCISE Dictionaries.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 09.10.2020 EXERCISE:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Exercise: Dictionaries"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1.\tCount Chars in a String"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Write a program that counts all characters in a string except for space (' '). \n",
    "<br><br>Print all the occurrences in the following format:\n",
    "<br><br>{char} -> {occurrences}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "text text text\n",
      "t -> 6\n",
      "e -> 3\n",
      "x -> 3\n"
     ]
    }
   ],
   "source": [
    "string = input()\n",
    "counter = {}\n",
    "for char in string:\n",
    "    if char == \" \":\n",
    "        continue\n",
    "\n",
    "    counter_key = char\n",
    "\n",
    "    if counter_key not in counter:\n",
    "        counter[counter_key] = 1\n",
    "    else:\n",
    "        counter[counter_key] += 1\n",
    "\n",
    "for counter_key, value in counter.items():\n",
    "    print(f\"{counter_key} -> {value}\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2.\tA Miner Task"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You will be given a sequence of strings, each on a new line. Every odd line on the console is representing a resource (e.g. Gold, Silver, Copper, and so on) and every even – quantity. Your task is to collect the resources and print them each on a new line.\n",
    "<br><br>Print the resources and their quantities in the following format:\n",
    "<br><br>{resource} –> {quantity}\n",
    "<br><br>The quantities will be in the range [1 … 2 000 000 000]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Gold\n",
      "155\n",
      "Silver\n",
      "10\n",
      "Copper\n",
      "17\n",
      "stop\n",
      "Gold -> 155\n",
      "Silver -> 10\n",
      "Copper -> 17\n"
     ]
    }
   ],
   "source": [
    "miner = {}\n",
    "\n",
    "while True:\n",
    "    resource = input()\n",
    "    if resource == \"stop\":\n",
    "        break\n",
    "    quantity = int(input())\n",
    "\n",
    "    if resource not in miner:\n",
    "        miner[resource] = quantity\n",
    "    else:\n",
    "        miner[resource] += quantity\n",
    "\n",
    "for resource, quantity in miner.items():\n",
    "    print(f\"{resource} -> {quantity}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3.\tLegendary Farming"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You've done all the work and the last thing left to accomplish is to own a legendary item. However, it's a tedious process and it requires quite a bit of farming. Anyway, you are not too pretentious – any legendary item will do. The possible items are:\n",
    "* Shadowmourne – requires 250 Shards;\n",
    "* Valanyr – requires 250 Fragments;\n",
    "* Dragonwrath – requires 250 Motes;\n",
    "<br><br>Shards, Fragments and Motes are the key materials and everything else is junk. You will be given lines of input, in the format: \n",
    "<br><br>2 motes 3 ores 15 stones\n",
    "<br><br>Keep track of the key materials - the first one that reaches the 250 mark, wins the race. At that point you have to print that the corresponding legendary item is obtained. Then, print the remaining shards, fragments, motes, ordered by quantity in descending order, then by name in ascending order, each on a new line. Finally, print the collected junk items in alphabetical order."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Input"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Each line comes in the following format: {quantity} {material} {quantity} {material} … {quantity} {material}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Output"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* On the first line, print the obtained item in the format: {Legendary item} obtained!\n",
    "* On the next three lines, print the remaining key materials in descending order by quantity\n",
    "    * If two key materials have the same quantity, print them in alphabetical order\n",
    "* On the final several lines, print the junk items in alphabetical order\n",
    "    * All materials are printed in format {material}: {quantity}\n",
    "    * The output should be lowercase, except for the first letter of the legendary"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "123 silver 6 shards 8 shards 5 motes\n",
      "9 fangs 75 motes 103 MOTES 8 Shards\n",
      "86 Motes 7 stones 19 silver\n",
      "Dragonwrath obtained!\n",
      "shards: 22\n",
      "motes: 19\n",
      "fragments: 0\n",
      "fangs: 9\n",
      "silver: 123\n"
     ]
    }
   ],
   "source": [
    "legendary = {}\n",
    "junk = {}\n",
    "break_flag = False\n",
    "\n",
    "while not break_flag:\n",
    "    materials = input().lower().split()\n",
    "\n",
    "    for i in range(0, len(materials), 2):\n",
    "        quantity = int(materials[i])\n",
    "        material = materials[i + 1]\n",
    "\n",
    "        if material == \"shards\" or material == \"fragments\" or material == \"motes\":\n",
    "            if material not in legendary:\n",
    "                legendary[material] = quantity\n",
    "            else:\n",
    "                legendary[material] += quantity\n",
    "\n",
    "            if legendary[material] >= 250:\n",
    "                legendary[material] -= 250\n",
    "\n",
    "\n",
    "                if material == \"shards\":\n",
    "                    print(\"Shadowmourne obtained!\")\n",
    "                elif material == \"fragments\":\n",
    "                    print(\"Valanyr obtained!\")\n",
    "                elif material == \"motes\":\n",
    "                    print(\"Dragonwrath obtained!\")\n",
    "\n",
    "                if \"fragments\" not in legendary:\n",
    "                    legendary[\"fragments\"] = 0\n",
    "                if \"shards\" not in legendary:\n",
    "                    legendary[\"shards\"] = 0\n",
    "                if \"motes\" not in legendary:\n",
    "                    legendary[\"motes\"] = 0\n",
    "\n",
    "                break_flag = True\n",
    "                break\n",
    "\n",
    "        else:\n",
    "            if material not in junk:\n",
    "                junk[material] = quantity\n",
    "            else:\n",
    "                junk[material] += quantity\n",
    "\n",
    "legendary = dict(sorted(legendary.items(), key=lambda x: (-x[1], x[0])))\n",
    "for material, quantity in legendary.items():\n",
    "    print(f\"{material}: {legendary[material]}\")\n",
    "\n",
    "junk = dict(sorted(junk.items(), key=lambda x: x[0]))\n",
    "\n",
    "for material, quantity in junk.items():\n",
    "    print(f\"{material}: {junk[material]}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 4.\tOrders"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Write a program that keeps information about products and their prices. Each product has a name, a price and a quantity. If the product doesn't exist yet, add it with its starting quantity.\n",
    "<br><br>If you receive a product, which already exists, increase its quantity by the input quantity and if its price is different, replace the price as well.\n",
    "<br><br>You will receive products' names, prices and quantities on new lines. Until you receive the command \"buy\", keep adding items. When you do receive the command \"buy\", print the items with their names and total price of all the products with that name. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Input"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Until you receive \"buy\", the products will be coming in the format: \"{name} {price} {quantity}\".\n",
    "* The product data is always delimited by a single space."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Output"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Print information about each product in the following format: \n",
    "<br>\"{productName} -> {totalPrice}\"\n",
    "* Format the average grade to the 2nd digit after the decimal separator."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Beer 2.20 100\n",
      "IceTea 1.50 50\n",
      "NukaCola 3.30 80\n",
      "Water 1.00 500\n",
      "buy\n",
      "Beer -> 220.00\n",
      "IceTea -> 75.00\n",
      "NukaCola -> 264.00\n",
      "Water -> 500.00\n"
     ]
    }
   ],
   "source": [
    "database_quantity = {}\n",
    "database_price = {}\n",
    "\n",
    "while True:\n",
    "    product = input()\n",
    "    if product == \"buy\":\n",
    "        break\n",
    "\n",
    "    name, price, quantity = product.split()\n",
    "    price = float(price)\n",
    "    quantity = int(quantity)\n",
    "\n",
    "    if name not in database_quantity:\n",
    "        database_quantity[name] = quantity\n",
    "    else:\n",
    "        database_quantity[name] += quantity\n",
    "\n",
    "    database_price[name] = price\n",
    "\n",
    "for product_quantity, quantity in database_quantity.items():\n",
    "    for product_price, prices in database_price.items():\n",
    "        if product_price == product_quantity:\n",
    "            database_quantity[product_quantity] = quantity * prices\n",
    "            break\n",
    "\n",
    "    print(f\"{product_quantity} -> {database_quantity[product_quantity]:.2f}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 5.\tSoftUni Parking"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "SoftUni just got a new parking lot. It's so fancy, it even has online parking validation. Except the online service doesn't work. It can only receive users' data, but it doesn't know what to do with it. Good thing you're on the dev team and know how to fix it, right?\n",
    "<br><brWrite a program, which validates a parking place for an online service. Users can register to park and unregister to leave.\n",
    "The program receives 2 types of commands:\t\n",
    "* \"register {username} {licensePlateNumber}\":\n",
    "    * The system only supports one car per user at the moment, so if a user tries to register another license plate, using the same username, the system should print: \"ERROR: already registered with plate number {licensePlateNumber}\"\n",
    "    * If the aforementioned checks passes successfully, the plate can be registered, so the system should print:\"{username} registered {licensePlateNumber} successfully\"\n",
    "* \"unregister {username}\":\n",
    "    * If the user is not present in the database, the system should print:\"ERROR: user {username} not found\"\n",
    "    * If the aforementioned check passes successfully, the system should print:\"{username} unregistered successfully\"\n",
    "<br><br>After you execute all of the commands, print all the currently registered users and their license plates in the format: \n",
    "* \"{username} => {licensePlateNumber}\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Input"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* First line: n – number of commands – integer\n",
    "* Next n lines: commands in one of the two possible formats:\n",
    "    * Register: \"register {username} {licensePlateNumber}\"\n",
    "    * Unregister: \"unregister {username}\"\n",
    "<br><br>The input will always be valid and you do not need to check it explicitly."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5\n",
      "register John CS1234JS\n",
      "John registered CS1234JS successfully\n",
      "register George JAVA123S\n",
      "George registered JAVA123S successfully\n",
      "register Andy AB4142CD\n",
      "Andy registered AB4142CD successfully\n",
      "register Jesica VR1223EE\n",
      "Jesica registered VR1223EE successfully\n",
      "unregister Andy\n",
      "Andy unregistered successfully\n",
      "John => CS1234JS\n",
      "George => JAVA123S\n",
      "Jesica => VR1223EE\n"
     ]
    }
   ],
   "source": [
    "def register(username, plate):\n",
    "    if username not in registered:\n",
    "        registered[username] = plate\n",
    "        print(f\"{username} registered {plate} successfully\")\n",
    "    else:\n",
    "        print(f\"ERROR: already registered with plate number {plate}\")\n",
    "    return registered\n",
    "\n",
    "\n",
    "def unregister(username):\n",
    "    if username not in registered:\n",
    "        print(f\"ERROR: user {username} not found\")\n",
    "    else:\n",
    "        print(f\"{username} unregistered successfully\")\n",
    "        del registered[username]\n",
    "    return registered\n",
    "\n",
    "\n",
    "n = int(input())\n",
    "\n",
    "registered = {}\n",
    "\n",
    "for i in range(n):\n",
    "    command = input().split()\n",
    "\n",
    "    if command[0] == \"register\":\n",
    "        registered = register(command[1], command[2])\n",
    "\n",
    "    elif command[0] == \"unregister\":\n",
    "        registered = unregister(command[1])\n",
    "\n",
    "for username, plate in registered.items():\n",
    "    print(f\"{username} => {registered[username]}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 6.\tCourses"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Write a program that keeps information about courses. Each course has a name and registered students.\n",
    "<br><br>You will be receiving a course name and a student name, until you receive the command \"end\". Check if such course already exists, and if not, add the course. Register the user into the course. When you receive the command \"end\", print the courses with their names and total registered users, ordered by the count of registered users in descending order. For each contest print the registered users ordered by name in ascending order."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Input\n",
    "* Until the \"end\" command is received, you will be receiving input in the format: \"{courseName} : {studentName}\".\n",
    "* The product data is always delimited by \" : \".\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Output\n",
    "* Print the information about each course in the following the format: \n",
    "<br>\"{courseName}: {registeredStudents}\"\n",
    "* Print the information about each student, in the following the format:\n",
    "<br>\"-- {studentName}\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Programming Fundamentals : John Smith\n",
      "Programming Fundamentals : Linda Johnson\n",
      "JS Core : Will Wilson\n",
      "Java Advanced : Harrison White\n",
      "end\n",
      "Programming Fundamentals: 2\n",
      "-- John Smith\n",
      "-- Linda Johnson\n",
      "JS Core: 1\n",
      "-- Will Wilson\n",
      "Java Advanced: 1\n",
      "-- Harrison White\n"
     ]
    }
   ],
   "source": [
    "database = {}\n",
    "\n",
    "while True:\n",
    "    course_student = input()\n",
    "    if course_student == \"end\":\n",
    "        break\n",
    "\n",
    "    course_name, student_name = course_student.split(\" : \")\n",
    "\n",
    "    if course_name not in database:\n",
    "        database[course_name] = []\n",
    "        database[course_name].append(student_name)\n",
    "    else:\n",
    "        database[course_name].append(student_name)\n",
    "\n",
    "database = dict(sorted(database.items(), key=lambda v: len(v[1]), reverse=True))\n",
    "\n",
    "for key in database:\n",
    "    database[key].sort()\n",
    "\n",
    "for course, students in database.items():\n",
    "    print(f\"{course}: {len(students)}\")\n",
    "    for el in students:\n",
    "        print(f\"-- {el}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 7.\t Student Academy"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Write a program that keeps information about students and their grades. \n",
    "<br><br>You will receive n pair of rows. First you will receive the student's name, after that you will receive his grade. Check if the student already exists and if not, add him. Keep track of all grades for each student.\n",
    "<br><br>When you finish reading the data, keep the students with average grade higher than or equal to 4.50. Order the filtered students by average grade in descending order.\n",
    "<br><br>Print the students and their average grade in the following format:\n",
    "<br><br>{name} –> {averageGrade}\n",
    "<br><br>Format the average grade to the 2nd decimal place."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5\n",
      "John\n",
      "5.5\n",
      "John\n",
      "4.5\n",
      "Alice\n",
      "6\n",
      "Alice\n",
      "3\n",
      "George\n",
      "5\n",
      "John -> 5.00\n",
      "George -> 5.00\n",
      "Alice -> 4.50\n"
     ]
    }
   ],
   "source": [
    "n = int(input())\n",
    "\n",
    "students_database = {}\n",
    "students_grade_counter = {}\n",
    "\n",
    "for i in range(n):\n",
    "    name = input()\n",
    "    grade = float(input())\n",
    "\n",
    "    if name not in students_database:\n",
    "        students_database[name] = grade\n",
    "        students_grade_counter[name] = 1\n",
    "    else:\n",
    "        students_database[name] += grade\n",
    "        students_grade_counter[name] += 1\n",
    "\n",
    "students_database = {name: grade / students_grade_counter[name] for name, grade in students_database.items()}\n",
    "students_database = {name: grade for name, grade in students_database.items() if students_database[name] >= 4.5}\n",
    "\n",
    "students_database = dict(sorted(students_database.items(), key=lambda x: x[1], reverse=True))\n",
    "\n",
    "for name, grade in students_database.items():\n",
    "    print(f\"{name} -> {students_database[name]:.2f}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 8.\tCompany Users\n",
    "Write a program that keeps information about companies and their employees. \n",
    "<br><br>You will be receiving a company name and an employee's id, until you receive the command \"End\" command. Add each employee to the given company. Keep in mind that a company cannot have two employees with the same id.\n",
    "<br><br>When you finish reading the data, order the companies by the name in ascending order. \n",
    "<br><br>Print the company name and each employee's id in the following format:\n",
    "<br><br>{companyName}\n",
    "<br><br>-- {id1}\n",
    "<br><br>-- {id2}\n",
    "<br><br>-- {idN}\n",
    "### Input / Constraints\n",
    "* Until you receive the \"End\" command, you will be receiving input in the format: \"{companyName} -> {employeeId}\".\n",
    "* The input always will be valid."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "SoftUni -> AA12345\n",
      "SoftUni -> BB12345\n",
      "Microsoft -> CC12345\n",
      "HP -> BB12345\n",
      "End\n",
      "HP\n",
      "-- BB12345\n",
      "Microsoft\n",
      "-- CC12345\n",
      "SoftUni\n",
      "-- AA12345\n",
      "-- BB12345\n"
     ]
    }
   ],
   "source": [
    "database_company = {}\n",
    "\n",
    "while True:\n",
    "    receiving = input()\n",
    "    if receiving == \"End\":\n",
    "        break\n",
    "\n",
    "    company, employ = receiving.split(\" -> \")\n",
    "\n",
    "    if company not in database_company:\n",
    "        database_company[company] = []\n",
    "        database_company[company].append(employ)\n",
    "    else:\n",
    "        if employ not in database_company[company]:\n",
    "            database_company[company].append(employ)\n",
    "\n",
    "database_company = dict(sorted(database_company.items(), key=lambda k: k[0]))\n",
    "\n",
    "for company, employ in database_company.items():\n",
    "    print(f\"{company}\")\n",
    "    for el in database_company[company]:\n",
    "        print(f\"-- {el}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 9.\t*ForceBook\n",
    "<br><br>The force users are struggling to remember which side are the different forceUsers from, because they switch them too often. So you are tasked to create a web application to manage their profiles. You should store an information for every unique forceUser, registered in the application.\n",
    "<br><br>You will receive several input lines in one of the following formats:\n",
    "<br><br>{forceSide} | {forceUser}\n",
    "<br><br>{forceUser} -> {forceSide}\n",
    "<br><br>The forceUser and forceSide are strings, containing any character. \n",
    "<br><br>If you receive forceSide | forceUser, you should check if such forceUser already exists, and if not, add him/her to the corresponding side. \n",
    "<br><br>If you receive a forceUser -> forceSide, you should check if there is such a forceUser already and if so, change his/her side. If there is no such forceUser, add him/her to the corresponding forceSide, treating the command as a new registered forceUser.\n",
    "<br><br>Then you should print on the console: \"{forceUser} joins the {forceSide} side!\" \n",
    "<br><br>You should end your program when you receive the command \"Lumpawaroo\". At that point you should print each force side, ordered descending by forceUsers count, than ordered by name. For each side print the forceUsers, ordered by name.\n",
    "<br><br>In case there are no forceUsers in a side, you shouldnt print the side information. \n",
    "### Input / Constraints\n",
    "* The input comes in the form of commands in one of the formats specified above.\n",
    "* The input ends, when you receive the command \"Lumpawaroo\".\n",
    "### Output\n",
    "* As output for each forceSide, ordered descending by forceUsers count, then by name,  you must print all the forceUsers, ordered by name alphabetically.\n",
    "* The output format is:\n",
    "<br><br>Side: {forceSide}, Members: {forceUsers.Count}\n",
    "<br><br>! {forceUser}\n",
    "<br><br>! {forceUser}\n",
    "<br><br>! {forceUser}\n",
    "* In case there are NO forceUsers, don`t print this side. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Lighter | Royal\n",
      "Darker | DCay\n",
      "Ivan Ivanov -> Lighter\n",
      "Ivan Ivanov joins the Lighter side!\n",
      "DCay -> Lighter\n",
      "DCay joins the Lighter side!\n",
      "Lumpawaroo\n",
      "Side: Lighter, Members: 3\n",
      "! DCay\n",
      "! Ivan Ivanov\n",
      "! Royal\n"
     ]
    }
   ],
   "source": [
    "def user_input(database, side, user):\n",
    "    for sides, users in database.items():\n",
    "        if user in users:\n",
    "            return database\n",
    "    if side not in database:\n",
    "        database[side] = []\n",
    "        database[side].append(user)\n",
    "    else:\n",
    "        if user not in database[side]:\n",
    "            database[side].append(user)\n",
    "    return database\n",
    "\n",
    "\n",
    "def user_transfer(database, side, user):\n",
    "    for sides, users in database.items():\n",
    "        if user in database[sides]:\n",
    "            database[sides].remove(user)\n",
    "            return user_input(database, side, user)\n",
    "    return user_input(database, side, user)\n",
    "\n",
    "\n",
    "database = {}\n",
    "\n",
    "while True:\n",
    "    receive = input()\n",
    "    if receive == \"Lumpawaroo\":\n",
    "        break\n",
    "\n",
    "    if \" | \" in receive:\n",
    "        force_side, force_user = receive.split(\" | \")\n",
    "        database = user_input(database, force_side, force_user)\n",
    "    elif \" -> \" in receive:\n",
    "        force_user, force_side = receive.split(\" -> \")\n",
    "        database = user_transfer(database, force_side, force_user)\n",
    "        print(f\"{force_user} joins the {force_side} side!\")\n",
    "\n",
    "database = dict(sorted(database.items(), key=lambda k: (-len(k[1]), k[0])))\n",
    "\n",
    "for f_side, f_user in database.items():\n",
    "    if len(database[f_side]) > 0:\n",
    "        print(f\"Side: {f_side}, Members: {len(database[f_side])}\")\n",
    "        database[f_side] = sorted(database[f_side])\n",
    "        for el in database[f_side]:\n",
    "            print(f\"! {el}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 10.\t*SoftUni Exam Results\n",
    "<br><br>Judge statistics on the last Programing Fundamentals exam was not working correctly, so you have the task to take all the submissions and analyze them properly. You should collect all the submissions and print the final results and statistics about each language that the participants submitted their solutions in.\n",
    "<br><br>You will be receiving lines in the following format: \"{username}-{language}-{points}\" until you receive \"exam finished\". You should store each username and his submissions and points. \n",
    "<br><br>You can receive a command to ban a user for cheating in the following format: \"{username}-banned\". In that case, you should remove the user from the contest, but preserve his submissions in the total count of submissions for each language.\n",
    "<br><br>After receiving \"exam finished\" print each of the participants, ordered descending by their max points, then by username, in the following format:\n",
    "<br><br>Results:\n",
    "<br><br>{username} | {points}\n",
    "<br><br>…\n",
    "<br><br>After that print each language, used in the exam, ordered descending by total submission count and then by language name, in the following format:\n",
    "<br><br>Submissions:\n",
    "<br><br>{language} – {submissionsCount}\n",
    "<br><br>…\n",
    "### Input / Constraints\n",
    "Until you receive \"exam finished\" you will be receiving participant submissions in the following format: \"{username}-{language}-{points}\".\n",
    "<br><br>You can receive a ban command -> \"{username}-banned\"\n",
    "<br><br>The points of the participant will always be a valid integer in the range [0-100];\n",
    "### Output\n",
    "* Print the exam results for each participant, ordered descending by max points and then by username, in the following format: \n",
    "<br><br>Results:\n",
    "<br><br>{username} | {points}\n",
    "<br><br>…\n",
    "* After that print each language, ordered descending by total submissions and then by language name, in the following format:\n",
    "<br><br>Submissions:\n",
    "<br><br>{language} – {submissionsCount}\n",
    "<br><br>…\n",
    "* Allowed working time / memory: 100ms / 16MB."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Pesho-Java-91\n",
      "Gosho-C#-84\n",
      "Kiro-Java-90\n",
      "Kiro-C#-50\n",
      "Kiro-banned\n",
      "exam finished\n",
      "Results:\n",
      "Pesho | 91\n",
      "Gosho | 84\n",
      "Submissions:\n",
      "C# - 2\n",
      "Java - 2\n"
     ]
    }
   ],
   "source": [
    "def stat(language, points):\n",
    "    if name not in statistic:\n",
    "        statistic[name] = points\n",
    "    else:\n",
    "        if statistic[name] < points:\n",
    "            statistic[name] = points\n",
    "\n",
    "    if language in language_submissions:\n",
    "        language_submissions[language] += 1\n",
    "    else:\n",
    "        language_submissions[language] = 1\n",
    "    return statistic, language_submissions\n",
    "\n",
    "\n",
    "statistic = {}\n",
    "language_submissions = {}\n",
    "\n",
    "while True:\n",
    "    receive = input()\n",
    "    if receive == \"exam finished\":\n",
    "        break\n",
    "\n",
    "    receive = receive.split(\"-\")\n",
    "    name = receive[0]\n",
    "\n",
    "    if \"banned\" in receive:\n",
    "        del statistic[name]\n",
    "\n",
    "    else:\n",
    "        statistic, language_submissions = stat(receive[1], int(receive[2]))\n",
    "\n",
    "statistic = dict(sorted(statistic.items(), key=lambda k: (-k[1], k[0])))\n",
    "language_submissions = dict(sorted(language_submissions.items(), key=lambda k: (-k[1], k[0])))\n",
    "\n",
    "print(\"Results:\")\n",
    "for name, points in statistic.items():\n",
    "    print(f\"{name} | {statistic[name]}\")\n",
    "\n",
    "print(\"Submissions:\")\n",
    "for language, submission in language_submissions.items():\n",
    "    print(f\"{language} - {language_submissions[language]}\")"
   ]
  }
 ],
 "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
}