7.3 MORE EXERCISES Dictionaries.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Dictionaries - More Exercises"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1.\tRanking"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here comes the final and the most interesting part – the Final ranking of the candidate-interns. The final ranking is determined by the points of the interview tasks and from the exams in SoftUni. Here is your final task. You will receive some lines of input in the format \"{contest}:{password for contest}\" until you receive \"end of contests\". Save that data because you will need it later. After that you will receive other type of inputs in format \"{contest}=>{password}=>{username}=>{points}\" until you receive \"end of submissions\". Here is what you need to do. \n",
    "* Check if the contest is valid (if you received it in the first type of input)\n",
    "* Check if the password is correct for the given contest\n",
    "* Save the user with the contest they take part in (a user can take part in many contests) and the points the user has in the given contest. If you receive the same contest and the same user update the points only if the new ones are more than the older ones.\n",
    "<br><br>At the end you have to print the info for the user with the most points in the format \"Best candidate is {user} with total {total points} points.\". After that print all students ordered by their names. For each user print each contest with the points in descending order. See the examples.\n",
    "\n",
    "\n",
    "### Input\n",
    "* strings in format \"{contest}:{password for contest}\" until the \"end of contests\" command. There will be no case with two equal contests\n",
    "* strings in format \"{contest}=>{password}=>{username}=>{points}\" until the \"end of submissions\" command.\n",
    "* There will be no case with 2 or more users with same total points!\n",
    "\n",
    "### Output\n",
    "* On the first line print the best user in format \"Best candidate is {user} with total {total points} points.\". \n",
    "* Then print all students ordered as mentioned above in format:\n",
    "{user1 name}\n",
    "\\#  {contest1} -> {points}\n",
    "\\#  {contest2} -> {points} \n",
    "\n",
    "### Constraints\n",
    "* the strings may contain any ASCII character except from (:, =, >)\n",
    "* the numbers will be in range [0 - 10000]\n",
    "* second input is always valid"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Java Advanced:funpass\n",
      "Part Two Interview:success\n",
      "Math Concept:asdasd\n",
      "Java Web Basics:forrF\n",
      "end of contests\n",
      "Math Concept=>ispass=>Monika=>290\n",
      "Java Advanced=>funpass=>Simona=>400\n",
      "Part Two Interview=>success=>Drago=>120\n",
      "Java Advanced=>funpass=>Petyr=>90\n",
      "Java Web Basics=>forrF=>Simona=>280\n",
      "Part Two Interview=>success=>Petyr=>0\n",
      "Math Concept=>asdasd=>Drago=>250\n",
      "Part Two Interview=>success=>Simona=>200\n",
      "end of submissions\n",
      "Best candidate is Simona with total 880 points.\n",
      "Ranking:\n",
      "Drago\n",
      "#  Math Concept -> 250\n",
      "#  Part Two Interview -> 120\n",
      "Petyr\n",
      "#  Java Advanced -> 90\n",
      "#  Part Two Interview -> 0\n",
      "Simona\n",
      "#  Java Advanced -> 400\n",
      "#  Java Web Basics -> 280\n",
      "#  Part Two Interview -> 200\n"
     ]
    }
   ],
   "source": [
    "def contest_validator(dbase_f_receive, contest_s_receive, pass_s_receive):\n",
    "    if contest_s_receive in dbase_f_receive:\n",
    "        if pass_s_receive == dbase_f_receive[contest_s_receive]:\n",
    "            return True\n",
    "\n",
    "\n",
    "def user_operator(dbase_f_receive, contest_s_receive, user_s_receive, points_s_receive):\n",
    "    if user_s_receive not in dbase_f_receive:\n",
    "        dbase_f_receive[user_s_receive] = []\n",
    "        dbase_f_receive[user_s_receive].append([contest_s_receive, points_s_receive])\n",
    "    else:\n",
    "        new_contest = True\n",
    "        for key, value in dbase_f_receive.items():\n",
    "            if key == user_s_receive:\n",
    "                for el in dbase_f_receive[user_s_receive]:\n",
    "                    if contest_s_receive in el:\n",
    "                        new_contest=False\n",
    "                        if el[1] < points_s_receive:\n",
    "                            el[1] = points_s_receive\n",
    "                            break\n",
    "                        else:\n",
    "                            break\n",
    "        if new_contest:\n",
    "            dbase_f_receive[user_s_receive].append([contest_s_receive, points])\n",
    "    return dbase_f_receive\n",
    "\n",
    "\n",
    "def best_result(dbase):\n",
    "    max_points = 0\n",
    "\n",
    "    for key, value in dbase.items():\n",
    "        current_points = 0\n",
    "        for el in value:\n",
    "            current_points += el[1]\n",
    "        if max_points < current_points:\n",
    "            max_points = current_points\n",
    "            the_best = key\n",
    "    return max_points, the_best\n",
    "\n",
    "\n",
    "contest_dbase = {}\n",
    "while True:\n",
    "    first_receive = input()\n",
    "    if first_receive == \"end of contests\":\n",
    "        break\n",
    "    contest, password = first_receive.split(\":\")\n",
    "    contest_dbase[contest] = password\n",
    "\n",
    "user_dbase = {}\n",
    "while True:\n",
    "    second_receive = input()\n",
    "    if second_receive == \"end of submissions\":\n",
    "        break\n",
    "    contest, password, username, points = second_receive.split(\"=>\")\n",
    "    points = int(points)\n",
    "    is_valid = contest_validator(contest_dbase, contest, password)\n",
    "    if is_valid:\n",
    "        user_dbase = user_operator(user_dbase, contest, username, points)\n",
    "\n",
    "user_dbase = dict(sorted(user_dbase.items(), key=lambda k: k[0]))\n",
    "\n",
    "best = best_result(user_dbase)\n",
    "print(f\"Best candidate is {best[1]} with total {best[0]} points.\")\n",
    "\n",
    "print(\"Ranking:\")\n",
    "for key, value in user_dbase.items():\n",
    "    print(key)\n",
    "    user_dbase[key] = [sorted(user_dbase[key], key=lambda x: x[1], reverse=True)]\n",
    "    for v in user_dbase[key]:\n",
    "        for el in v:\n",
    "            print(f\"#  {el[0]} -> {el[1]}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2.\tJudge"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You know the jude system, right?! Your job is to create a program similar to the Judge system. \n",
    "<br><br>\n",
    "You will receive several input lines in one of the following formats:\n",
    "{username} -> {contest} -> {points}\n",
    "<br><br>\n",
    "The constestName and username are strings, the given points will be an integer number. You need to keep track of every contest and individual statistics of every user. You should check if such contest already exists, and if not, add it, otherwise check if the current user Is participating in the contest, if he is participating take the higher score, otherwise just add it. \n",
    "<br><br>\n",
    "Also you need to keep individual statistics for each user - the total points of all constests. \n",
    "<br><br>\n",
    "You should end your program when you receive the command \"no more time\". At that point you should print each contest in order of input, for each contest print the participants ordered by points in desecending order, than ordered by name in ascending order.  After that, you should print individual statistics for every participant ordered by total points in desecnding order, and then by alphabetical order.\n",
    "\n",
    "### Input / Constraints\n",
    "* The input comes in the form of commands in one of the formats specified above.\n",
    "* Username and contest name always will be one word.\n",
    "* Points will be an integer will be an integer in range [0, 1000].\n",
    "* There will be no invalid input lines.\n",
    "* If all sorting criteria fail, the order should be by order of input.\n",
    "* The input ends when you receive the command \"no more time\".\n",
    "\n",
    "### Output\n",
    "* The output format for the contests is:\n",
    "<br>{constestName}: {participants.Count} participants\n",
    "<br>{position}. {username} <::> {points}\n",
    "*After you print all contests, print the individual statistics for every participant.\n",
    "*The output format is:\n",
    "<br>Individual standings:\n",
    "<br>{position}. {username} -> {totalPoints}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Pesho -> OOP -> 350\n",
      "Gosho -> OOP -> 250\n",
      "Stamat -> Advanced -> 600\n",
      "Gosho -> OOP -> 300\n",
      "Prakash -> OOP -> 300\n",
      "Prakash -> Advanced -> 250\n",
      "Ani -> JSCore -> 400\n",
      "no more time\n",
      "OOP: 3 participants\n",
      "1. Pesho <::> 350\n",
      "2. Gosho <::> 300\n",
      "3. Prakash <::> 300\n",
      "Advanced: 2 participants\n",
      "1. Stamat <::> 600\n",
      "2. Prakash <::> 250\n",
      "JSCore: 1 participants\n",
      "1. Ani <::> 400\n",
      "Individual standings:\n",
      "1. Stamat -> 600\n",
      "2. Prakash -> 550\n",
      "3. Ani -> 400\n",
      "4. Pesho -> 350\n",
      "5. Gosho -> 300\n"
     ]
    }
   ],
   "source": [
    "def contest_validator(cont_db, c_user, user_db, cont, name, pt):\n",
    "    cont_db[cont] = []\n",
    "    cont_db[cont].append([name, pt])\n",
    "    c_user[cont] = []\n",
    "    c_user[cont].append(name)\n",
    "    user_db[name] += pt\n",
    "    return cont_db, c_user, user_db\n",
    "\n",
    "\n",
    "def user_validator(cont_db, c_user, user_db, cont, name, pt):\n",
    "    cont_db[cont].append([name, pt])\n",
    "    c_user[cont].append(name)\n",
    "    user_db[name] += pt\n",
    "    return cont_db, c_user, user_db\n",
    "\n",
    "\n",
    "def higher_score(cont_db, user_db, name, pt):\n",
    "    for key, value in cont_db.items():\n",
    "        for el in cont_db[key]:\n",
    "            if el[0] == name:\n",
    "                if el[1] <= pt:\n",
    "                    user_db[name] -= el[1]\n",
    "                    user_db[name] += pt\n",
    "                    el[1] = pt\n",
    "    return cont_db, user_db\n",
    "\n",
    "\n",
    "contest_dbase = {}\n",
    "user_dbase = {}\n",
    "cont_user = {}\n",
    "\n",
    "while True:\n",
    "    receive = input()\n",
    "    if receive == \"no more time\":\n",
    "        break\n",
    "\n",
    "    username, contest, points = receive.split(\" -> \")\n",
    "    points = int(points)\n",
    "\n",
    "    if username not in user_dbase:\n",
    "        user_dbase[username] = 0\n",
    "\n",
    "    if contest not in contest_dbase:\n",
    "        contest_dbase, cont_user, user_dbase = contest_validator(contest_dbase, cont_user, user_dbase, contest,\n",
    "                                                                 username, points)\n",
    "    elif contest in contest_dbase and username not in cont_user[contest]:\n",
    "        contest_dbase, cont_user, user_dbase = user_validator(contest_dbase, cont_user, user_dbase, contest, username,\n",
    "                                                              points)\n",
    "    else:\n",
    "        contest_dbase, user_dbase = higher_score(contest_dbase, user_dbase, username, points)\n",
    "\n",
    "for key, value in contest_dbase.items():\n",
    "    print(f\"{key}: {len(cont_user[key])} participants\")\n",
    "    position = 1\n",
    "    contest_dbase[key] = list(sorted(contest_dbase[key], key=lambda x: (-x[1], x[0])))\n",
    "    for el in contest_dbase[key]:\n",
    "        print(f\"{position}. {el[0]} <::> {el[1]}\")\n",
    "        position += 1\n",
    "\n",
    "print(\"Individual standings:\")\n",
    "user_dbase = dict(sorted(user_dbase.items(), key=lambda k: (-k[1], k[0])))\n",
    "position = 1\n",
    "for k, v in user_dbase.items():\n",
    "    print(f\"{position}. {k} -> {user_dbase[k]}\")\n",
    "    position += 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3.\tMOBA Challenger"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Pesho is a pro MOBA player, he is struggling to become а master of the Challenger tier. So he watches carefully the statistics in the tier.\n",
    "<br><br>You will receive several input lines in one of the following formats:\n",
    "<br>\"{player} -> {position} -> {skill}\"\n",
    "<br>\"{player} vs {player}\"\n",
    "<br><br>The player and position are strings, the given skill will be an integer number. You need to keep track of every player. \n",
    "<br><br>When you receive a player and his position and skill, add him to the player pool, if he isnt present, else add his position and skill or update his skill, only if the current position skill is lower than the new value.\n",
    "<br><br>If you receive \"{player} vs {player}\" and both players exist in the tier, they duel with the following rules:\n",
    "<br><br>Compare their positions, if they got at least one in common, the player with better total skill points wins and the other is demoted from the tier -> remove him. If they have same total skill points, the duel is tie and they both continue in the Season.\n",
    "<br><br>If they don\\`t have positions in common, the duel isn\\`t happening and both continue in the Season.\n",
    "<br><br>You should end your program when you receive the command \"Season end\". At that point you should print the players, ordered by total skill in desecending order, then ordered by player name in ascending order. Foreach player print their position and skill, ordered desecending by skill, then ordered by position name in ascending order.\n",
    "\n",
    "### Input / Constraints\n",
    "* The input comes in the form of commands in one of the formats specified above.\n",
    "* Player and position will always be one word string, containing no whitespaces.\n",
    "* Skill will be an integer in the range [0, 1000].\n",
    "* There will be no invalid input lines.\n",
    "* The programm ends when you receive the command \"Season end\".\n",
    "\n",
    "### Output\n",
    "* The output format for each player is:\n",
    "<br>\"{player}: {totalSkill} skill\"\n",
    "<br>\"- {position} <::> {skill}\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Pesho -> Adc -> 400\n",
      "Gosho -> Jungle -> 300\n",
      "Stamat -> Mid -> 200\n",
      "Stamat -> Support -> 250\n",
      "Season end\n",
      "Stamat: 450 skill\n",
      "- Support <::> 250\n",
      "- Mid <::> 200\n",
      "Pesho: 400 skill\n",
      "- Adc <::> 400\n",
      "Gosho: 300 skill\n",
      "- Jungle <::> 300\n"
     ]
    }
   ],
   "source": [
    "def new_player(p_pool, p_pos, p_skill, pl, pos, sk):\n",
    "    p_pool[player] = []\n",
    "    p_pool[player].append([pos, sk])\n",
    "    p_pos[position].append(pl)\n",
    "    p_skill[player] = 0\n",
    "    p_skill[player] += sk\n",
    "    return p_pool, p_pos, p_skill\n",
    "\n",
    "\n",
    "def existing_player(p_pool, p_pos, p_skill, pl, pos, sk):\n",
    "    for key, value in p_pool.items():\n",
    "        if key == pl:\n",
    "            res = any(pos in sublist for sublist in value)\n",
    "            if res:\n",
    "                for el in value:\n",
    "                    if pos in el:\n",
    "                        if el[1] < sk:\n",
    "                            p_skill[pl] -= el[1]\n",
    "                            p_skill[pl] += sk\n",
    "                            el[1] = sk\n",
    "            else:\n",
    "                p_pool[player].append([pos, sk])\n",
    "                p_pos[position].append(pl)\n",
    "                p_skill[player] += sk\n",
    "    return p_pool, p_pos, p_skill\n",
    "\n",
    "\n",
    "def player_remover(p_pool, p_skill, p_pos, r_player):\n",
    "    del p_pool[r_player]\n",
    "    del p_skill[r_player]\n",
    "    for key, value in p_pos.items():\n",
    "        if r_player in p_pos[key]:\n",
    "            p_pos[key].remove(r_player)\n",
    "    return p_pool, p_pos, p_skill\n",
    "\n",
    "\n",
    "player_pool = {}\n",
    "player_skill = {}\n",
    "player_pos = {}\n",
    "\n",
    "while True:\n",
    "    receive = input()\n",
    "    if receive == \"Season end\":\n",
    "        break\n",
    "\n",
    "    if \" -> \" in receive:\n",
    "        player, position, skill = receive.split(\" -> \")\n",
    "        skill = int(skill)\n",
    "\n",
    "        if position not in player_pos:\n",
    "            player_pos[position] = []\n",
    "\n",
    "        if player not in player_pool:\n",
    "            player_pool, player_pos, player_skill = new_player(player_pool, player_pos, player_skill, player, position,\n",
    "                                                               skill)\n",
    "        else:\n",
    "            player_pool, player_pos, player_skill = existing_player(player_pool, player_pos, player_skill, player,\n",
    "                                                                    position, skill)\n",
    "\n",
    "    elif \" vs \" in receive:\n",
    "        player_one, player_two = receive.split(\" vs \")\n",
    "        if player_one in player_pool and player_two in player_pool:\n",
    "            for pos, pl in player_pos.items():\n",
    "                if player_one in player_pos[pos] and player_two in player_pos[pos]:\n",
    "                    if player_skill[player_one] > player_skill[player_two]:\n",
    "                        player_pool, player_pos, player_skill = player_remover(player_pool, player_skill, player_pos,\n",
    "                                                                               player_two)\n",
    "                    elif player_skill[player_one] < player_skill[player_two]:\n",
    "                        player_pool, player_pos, player_skill = player_remover(player_pool, player_skill, player_pos,\n",
    "                                                                               player_one)\n",
    "\n",
    "player_skill = dict(sorted(player_skill.items(), key=lambda x: (-x[1], x[0])))\n",
    "for key, value in player_skill.items():\n",
    "    print(f\"{key}: {player_skill[key]} skill\")\n",
    "    for k, v in player_pool.items():\n",
    "        if k == key:\n",
    "            player_pool[k].sort(key=lambda x: (-x[1], x[0]))\n",
    "            for el in player_pool[k]:\n",
    "                print(f\"- {el[0]} <::> {el[1]}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 4.\tSnowwhite"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Snow White loves her dwarfs, but there are so many and she doesn't know how to order them. Does she order them by name? Or by color of their hat? Or by physics? She can't decide, so its up to you to write a program that does it for her.\n",
    "<br><br>You will be receiving several input lines which contain data about dwarfs in the following format:\n",
    "<br>{dwarfName} <:> {dwarfHatColor} <:> {dwarfPhysics}\n",
    "<br>The dwarfName and the dwarfHatColor are strings. The dwarfPhysics is an integer.\n",
    "<br><br>You must store the dwarfs in your program. There are several rules though:\n",
    "* If 2 dwarfs have the same name but different color, they should be considered different dwarfs, and you should store both of them.\n",
    "* If 2 dwarfs have the same name and the same color, store the one with the higher physics.\n",
    "<br><br>When you receive the command \"Once upon a time\", the input ends. You must order the dwarfs by physics in descending order and then by total count of dwarfs with the same hat color in descending order. \n",
    "Then you must print them all. \n",
    "\n",
    "### Input\n",
    "* The input will consists of several input lines, containing dwarf data in the format, specified above.\n",
    "* The input ends when you receive the command \"Once upon a time\". \n",
    "\n",
    "### Output\n",
    "* As output you must print the dwarfs, ordered in the way , specified above.\n",
    "* The output format is: ({hatColor}) {name} <-> {physics}\n",
    "\n",
    "### Constraints\n",
    "* The dwarfName will be a string which may contain any ASCII character except ' ' (space), '<', ':', '>'.\n",
    "* The dwarfHatColor will be a string which may contain any ASCII character except ' ' (space), '<', ':', '>'.\n",
    "* The dwarfPhysics will be an integer in range [0, 231 – 1].\n",
    "* There will be no invalid input lines.\n",
    "* If all sorting criteria fail, the order should be by order of input.\n",
    "* Allowed working time / memory: 100ms / 16MB."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Pesho <:> Red <:> 5000\n",
      "Pesho <:> Blue <:> 10000\n",
      "Pesho <:> Red <:> 10000\n",
      "Gosho <:> Blue <:> 10000\n",
      "Once upon a time\n",
      "(Blue) Pesho <-> 10000\n",
      "(Blue) Gosho <-> 10000\n",
      "(Red) Pesho <-> 10000\n"
     ]
    }
   ],
   "source": [
    "from collections import Counter\n",
    "\n",
    "\n",
    "def add_dwarf(dwarfs, counter, dwarf_name, dwarf_color, dwarf_physics):\n",
    "    if not dwarfs:\n",
    "        counter += 1\n",
    "        dwarfs[counter] = {\"name\": dwarf_name, \"hat\": dwarf_color, \"physics\": dwarf_physics}\n",
    "    else:\n",
    "        found = False\n",
    "        for key in dwarfs.keys():\n",
    "            if dwarfs[key][\"name\"] == dwarf_name and dwarfs[key][\"hat\"] == dwarf_color:\n",
    "                dwarfs[key][\"physics\"] = max(dwarfs[key][\"physics\"], dwarf_physics)\n",
    "                found = True\n",
    "                break\n",
    "        if not found:\n",
    "            counter += 1\n",
    "            dwarfs[counter] = {\"name\": dwarf_name, \"hat\": dwarf_color, \"physics\": dwarf_physics}\n",
    "    return dwarfs, counter\n",
    "\n",
    "\n",
    "counter = 0\n",
    "dwarfs = {}\n",
    "\n",
    "while True:\n",
    "    receive = input()\n",
    "    if receive == \"Once upon a time\":\n",
    "        break\n",
    "    dwarf_name, dwarf_color, dwarf_physics = receive.split(\" <:> \")\n",
    "    dwarf_physics = int(dwarf_physics)\n",
    "    dwarfs, counter = add_dwarf(dwarfs, counter, dwarf_name, dwarf_color, dwarf_physics)\n",
    "\n",
    "counts = Counter([list(d.values())[1] for d in dwarfs.values()])\n",
    "sorted_dwarfs = dict(sorted(dwarfs.items(), key=lambda x: (-x[1][\"physics\"], -counts[x[1][\"hat\"]])))\n",
    "\n",
    "for value in sorted_dwarfs.values():\n",
    "    print(f'({value[\"hat\"]}) {value[\"name\"]} <-> {value[\"physics\"]}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 5.\tDragon Army"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Heroes III is the best game ever. Everyone loves it and everyone plays it all the time. Stamat is no exclusion to this rule. His favorite units in the game are all types of dragons – black, red, gold, azure etc… He likes them so much that he gives them names and keeps logs of their stats: damage, health and armor. The process of aggregating all the data is quite tedious, so he would like to have a program doing it. Since he is no programmer, it's your task to help him.\n",
    "<br><br>You need to categorize dragons by their type. For each dragon, identified by name, keep information about his stats. Type is preserved as in the order of input, but dragons are sorted alphabetically by name. For each type, you should also print the average damage, health and armor of the dragons. For each dragon, print his own stats. \n",
    "<br><br>There may be missing stats in the input, though. If a stat is missing you should assign it default values. Default values are as follows: health 250, damage 45, and armor 10. Missing stat will be marked by null.\n",
    "<br><br>The input is in the following format {type} {name} {damage} {health} {armor}. Any of the integers may be assigned null value. See the examples below for better understanding of your task.\n",
    "<br><br>If the same dragon is added a second time, the new stats should overwrite the previous ones. Two dragons are considered equal if they match by both name and type.\n",
    "\n",
    "### Input\n",
    "* On the first line, you are given number N -> the number of dragons to follow\n",
    "* On the next N lines, you are given input in the above described format. There will be single space separating each element.\n",
    "\n",
    "### Output\n",
    "* Print the aggregated data on the console\n",
    "* For each type, print average stats of its dragons in format {Type}::({damage}/{health}/{armor})\n",
    "* Damage, health and armor should be rounded to two digits after the decimal separator\n",
    "* For each dragon, print its stats in format -{Name} -> damage: {damage}, health: {health}, armor: {armor}\n",
    "\n",
    "### Constraints\n",
    "* N is in range [1…100]\n",
    "* The dragon type and name are one word only, starting with capital letter.\n",
    "* Damage health and armor are integers in range [0 … 100000] or null"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5\n",
      "Red Bazgargal 100 2500 25\n",
      "Black Dargonax 200 3500 18\n",
      "Red Obsidion 220 2200 35\n",
      "Blue Kerizsa 60 2100 20\n",
      "Blue Algordox 65 1800 50\n",
      "Red::(160.00/2350.00/30.00)\n",
      "-Bazgargal -> damage: 100, health: 2500, armor: 25\n",
      "-Obsidion -> damage: 220, health: 2200, armor: 35\n",
      "Black::(200.00/3500.00/18.00)\n",
      "-Dargonax -> damage: 200, health: 3500, armor: 18\n",
      "Blue::(62.50/1950.00/35.00)\n",
      "-Algordox -> damage: 65, health: 1800, armor: 50\n",
      "-Kerizsa -> damage: 60, health: 2100, armor: 20\n"
     ]
    }
   ],
   "source": [
    "def input_null_checker(my_input):\n",
    "    d_type, d_name, d_damage, d_health, d_armor = my_input.split()\n",
    "    if d_damage == \"null\":\n",
    "        d_damage = 45\n",
    "    if d_health == \"null\":\n",
    "        d_health = 250\n",
    "    if d_armor == \"null\":\n",
    "        d_armor = 10\n",
    "    return d_type, d_name, int(d_damage), int(d_health), int(d_armor)\n",
    "\n",
    "\n",
    "def add_dragon(dragons, count_id, drag_type, drag_name, drag_damage, drag_health, drag_armor):\n",
    "    if drag_type not in dragons:\n",
    "        count_id += 1\n",
    "        dragons[drag_type] = {count_id: [drag_name, drag_damage, drag_health, drag_armor]}\n",
    "    else:\n",
    "        is_found = False\n",
    "        for key in dragons.keys():\n",
    "            if is_found:\n",
    "                break\n",
    "            if key == drag_type:\n",
    "                for value in dragons[drag_type].values():\n",
    "                    if value[0] == drag_name:\n",
    "                        value[1] = drag_damage\n",
    "                        value[2] = drag_health\n",
    "                        value[3] = drag_armor\n",
    "                        is_found = True\n",
    "                        break\n",
    "        if not is_found:\n",
    "            count_id += 1\n",
    "            dragons[drag_type][count_id] = [drag_name, drag_damage, drag_health, drag_armor]\n",
    "    return dragons, count_id\n",
    "\n",
    "\n",
    "def calculation_and_print(dragons):\n",
    "    for t, d in dragons.items():\n",
    "        damage = 0\n",
    "        health = 0\n",
    "        armor = 0\n",
    "        d = dict(sorted(d.items(), key=lambda x: x[1][0]))\n",
    "        for k, v in d.items():\n",
    "            damage += v[1]\n",
    "            health += v[2]\n",
    "            armor += v[3]\n",
    "        damage /= len(d)\n",
    "        health /= len(d)\n",
    "        armor /= len(d)\n",
    "        print(f'{t}::({damage:.2f}/{health:.2f}/{armor:.2f})')\n",
    "        for value in d.values():\n",
    "            print(f'-{value[0]} -> damage: {int(value[1])}, health: {int(value[2])}, armor: {int(value[3])}')\n",
    "\n",
    "\n",
    "dragons_count = int(input())\n",
    "count_id = 0\n",
    "dragons = {}\n",
    "\n",
    "for dragon in range(dragons_count):\n",
    "    drag_type, drag_name, drag_damage, drag_health, drag_armor = input_null_checker(input())\n",
    "    dragons, count_id = add_dragon(dragons, count_id, drag_type, drag_name, drag_damage, drag_health, drag_armor)\n",
    "\n",
    "calculation_and_print(dragons)"
   ]
  }
 ],
 "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
}