2.2 EXERCISE Data Types and Variables.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 25.09.2020 EXERCISE:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Data Types and Variables"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1.\tInteger Operations"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Read four integer numbers. Add first to the second, divide (integer) the sum by the third number and multiply the result by the fourth number. Print the result."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n",
      "20\n",
      "3\n",
      "3\n",
      "30\n"
     ]
    }
   ],
   "source": [
    "first_number = int(input())\n",
    "second_number = int(input())\n",
    "third_number = int(input())\n",
    "fourth_number = int(input())\n",
    "\n",
    "result = int((first_number + second_number) / third_number) * fourth_number\n",
    "\n",
    "print(result)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2.\tChars to String"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Write a function that receives 3 characters. Combine all the characters into one string and print it on the console."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a\n",
      "b\n",
      "c\n",
      "abc\n"
     ]
    }
   ],
   "source": [
    "first_char = input()\n",
    "second_char = input()\n",
    "third_char = input()\n",
    "\n",
    "result = first_char + second_char + third_char\n",
    "\n",
    "print(result)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3.\tElevator"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Calculate how many courses will be needed to elevate n persons by using an elevator with capacity of p persons. The input holds two lines: the number of people n and the capacity p of the elevator."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4\n",
      "5\n",
      "1\n"
     ]
    }
   ],
   "source": [
    "import math\n",
    "\n",
    "people = int(input())\n",
    "capacity = int(input())\n",
    "\n",
    "result = math.ceil(people / capacity)\n",
    "\n",
    "print(result)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 4.\tSum of Chars"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Write a program, which sums the ASCII codes of n characters and prints the sum on the console."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Input"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- On the first line, you will receive n – the number of lines, which will follow\n",
    "- On the next n lines – you will receive letters from the Latin alphabet"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Output"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Print the total sum in the following format:\n",
    "- The sum equals: {total_sum}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Constraints"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- n will be in the interval [1…20].\n",
    "- The characters will always be either upper or lower-case letters from the English alphabet\n",
    "- You will always receive one letter per line"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5\n",
      "A\n",
      "b\n",
      "C\n",
      "d\n",
      "E\n",
      "The sum equals: 399\n"
     ]
    }
   ],
   "source": [
    "n = int(input())\n",
    "\n",
    "sum = 0\n",
    "for i in range(n):\n",
    "    letter = input()\n",
    "    sum += ord(letter)\n",
    "    \n",
    "print(f\"The sum equals: {sum}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 5.\tPrint Part of the ASCII Table"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Find online more information about ASCII (American Standard Code for Information Interchange) and write a program that prints part of the ASCII table of characters on the console.  On the first line of input you will receive the char index you should start with and on the second line - the index of the last character you should print."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "40\n",
      "55\n",
      "( ) * + , - . / 0 1 2 3 4 5 6 7 "
     ]
    }
   ],
   "source": [
    "start_range = int(input())\n",
    "stop_range = int(input())\n",
    "\n",
    "for char in range(start_range, stop_range + 1):\n",
    "    print(chr(char), end=\" \")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 6.\tTriples of Latin Letters"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Write a program to read an integer n and print all triples of the first n small Latin letters, ordered alphabetically:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n",
      "aaa\n",
      "aab\n",
      "aac\n",
      "aba\n",
      "abb\n",
      "abc\n",
      "aca\n",
      "acb\n",
      "acc\n",
      "baa\n",
      "bab\n",
      "bac\n",
      "bba\n",
      "bbb\n",
      "bbc\n",
      "bca\n",
      "bcb\n",
      "bcc\n",
      "caa\n",
      "cab\n",
      "cac\n",
      "cba\n",
      "cbb\n",
      "cbc\n",
      "cca\n",
      "ccb\n",
      "ccc\n"
     ]
    }
   ],
   "source": [
    "number = int(input())\n",
    "\n",
    "for first_symbol in range(number):\n",
    "    for second_symbol in range(number):\n",
    "        for third_symbol in range(number):\n",
    "            print(f\"{chr(97 + first_symbol)}{chr(97 + second_symbol)}{chr(97 + third_symbol)}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 7.\tWater Overflow"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You have a water tank with capacity of 255 liters. On the next n lines, you will receive liters of water, which you have to pour in your tank. If the capacity is not enough, print \"Insufficient capacity!\" and continue reading the next line. On the last line, print the liters in the tank."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Input"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The input will be on two lines:\n",
    "- On the first line, you will receive n – the number of lines, which will follow\n",
    "- On the next n lines – you receive quantities of water, which you have to pour in the tank"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Output"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Every time you do not have enough capacity in the tank to pour the given liters, print:\n",
    "- Insufficient capacity!\n",
    "- On the last line, print only the liters in the tank."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Constraints"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- n will be in the interval [1…20]\n",
    "- liters will be in the interval [1…1000]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4\n",
      "250\n",
      "10\n",
      "Insufficient capacity!\n",
      "20\n",
      "Insufficient capacity!\n",
      "40\n",
      "Insufficient capacity!\n",
      "250\n"
     ]
    }
   ],
   "source": [
    "n = int(input())\n",
    "\n",
    "capacity = 255\n",
    "water = 0\n",
    "\n",
    "for pour in range(n):\n",
    "    liters = int(input())\n",
    "    if water + liters > capacity:\n",
    "        print(\"Insufficient capacity!\")\n",
    "    else:\n",
    "        water += liters\n",
    "        \n",
    "print(water)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 8.\t* Party Profit"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As a young adventurer, you travel with your party around the world, seeking for gold and glory. But you need to split the profit among your companions.\n",
    "- You will receive a party size. After that you receive the days of the adventure. \n",
    "- Every day, you are earning 50 coins, but you also spent 2 coins per companion for food. \n",
    "- Every 3rd (third) day, you have a motivational party, spending 3 coins per companion for drinking water. \n",
    "- Every 5th (fifth) day you slay a boss monster and you gain 20 coins per companion. But if you have a motivational - - party the same day, you spent additional 2 coins per companion. \n",
    "- Every 10th (tenth) day at the start of the day, 2 (two) of your companions leave, but every 15th (fifteenth) day 5 (five) new companions are joined at the beginning of the day.\n",
    "- You have to calculate how much coins gets each companion at the end of the adventure."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Input / Constraints"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The input will consist of exactly 2 lines:\n",
    "- party size – integer in range [1…100]\n",
    "- days – integer in range [1…100]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Output"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Print the following message: \"{companions_count} companions received {coins} coins each.\"\n",
    "- You cannot split a coin, so take the integral part (round down the coins to integer number). "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "15\n",
      "30\n",
      "19 companions received 102 coins each.\n"
     ]
    }
   ],
   "source": [
    "import math\n",
    "\n",
    "party_size = int(input())\n",
    "days = int(input())\n",
    "\n",
    "profit = 0\n",
    "spent = 0\n",
    "\n",
    "for day in range(1, days + 1):\n",
    "    if day % 10 == 0:\n",
    "        party_size -= 2\n",
    "    if day % 15 == 0:\n",
    "        party_size += 5\n",
    "    profit += 50\n",
    "    spent += (2 * party_size)\n",
    "    if day % 3 == 0:\n",
    "        spent += (3 * party_size)\n",
    "    if day % 5 == 0:\n",
    "        profit += (20 * party_size)\n",
    "        if day % 3 == 0:\n",
    "            spent += (2 * party_size)\n",
    "            \n",
    "coins = profit - spent\n",
    "coins_per_companion = math.floor(coins / party_size)\n",
    "\n",
    "print(f\"{party_size} companions received {coins_per_companion} coins each.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 9.\t *Snowballs"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Tony and Andi love playing in the snow and having snowball fights, but they always argue which makes the best snowballs. They have decided to involve you in their fray, by making you write a program, which calculates snowball data, and outputs the best snowball value.\n",
    "- You will receive N – an integer, the number of snowballs being made by Tony and Andi.\n",
    "- For each snowball you will receive 3 input lines:\n",
    "- On the first line you will get the snowball_snow – an integer.\n",
    "- On the second line you will get the snowball_time – an integer.\n",
    "- On the third line you will get the snowball_quality – an integer.\n",
    "- For each snowball you must calculate its snowball_value by the following formula:\n",
    "- (snowball_snow / snowball_time) ^ snowball_quality\n",
    "- At the end you must print the highest calculated snowball_value."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Input"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- On the first input line you will receive N – the number of snowballs.\n",
    "- On the next N * 3 input lines you will be receiving data about snowballs. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Output"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- As output you must print the highest calculated snowball_value, by the formula, specified above. \n",
    "- The output format is: \n",
    "- {snowball_snow} : {snowball_time} = {snowball_value} ({snowball_quality})"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Constraints"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- The number of snowballs (N) will be an integer in range [0, 100].\n",
    "- The snowball_snow is an integer in range [0, 1000].\n",
    "- The snowball_time is an integer in range [1, 500].\n",
    "- The snowball_quality is an integer in range [0, 100]."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n",
      "10\n",
      "2\n",
      "3\n",
      "5\n",
      "5\n",
      "5\n",
      "10 : 2 = 125 (3)\n"
     ]
    }
   ],
   "source": [
    "snowballs = int(input())\n",
    "\n",
    "snowball_value = 0\n",
    "highest_snowball_value = 0\n",
    "result = \"\"\n",
    "\n",
    "for snowball in range(snowballs):\n",
    "    snowball_snow = int(input())\n",
    "    snowball_time = int(input())\n",
    "    snowball_quality = int(input())\n",
    "    snowball_value = (snowball_snow // snowball_time) ** snowball_quality\n",
    "    if snowball_value > highest_snowball_value:\n",
    "        highest_snowball_value = snowball_value\n",
    "        result = f\"{snowball_snow} : {snowball_time} = {highest_snowball_value} ({snowball_quality})\"\n",
    "        \n",
    "print(result)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 10.\t* Gladiator Expenses"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- As a gladiator, Peter has to repair his broken equipment when he loses a fight. His equipment consists of helmet, sword, shield and armor. You will receive the Peter`s lost fights count. \n",
    "- Every second lost game, his helmet is broken.\n",
    "- Every third lost game, his sword is broken.\n",
    "- When both his sword and helmet are broken in the same lost fight, his shield also brakes.\n",
    "- Every second time, when his shield brakes, his armor also needs to be repaired. \n",
    "- You will receive the price of each item in his equipment. Calculate his expenses for the year for renewing his equipment. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Input / Constraints"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The input will consist of 5 lines:\n",
    "- On the first line you will receive the lost fights count – integer in the range [0, 1000].\n",
    "- On the second line you will receive the helmet price - floating point number in range [0, 1000]. \n",
    "- On the third line you will receive the sword price - floating point number in range [0, 1000]. \n",
    "- On the fourth line you will receive the shield price - floating point number in range [0, 1000]. \n",
    "- On the fifth line you will receive the armor price - floating point number in range [0, 1000]. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Output"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- As output you must print Peter`s total expenses for new equipment: \"Gladiator expenses: {expenses} aureus\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "23\n",
      "12.50\n",
      "21.50\n",
      "40\n",
      "200\n",
      "Gladiator expenses: 608.00 aureus\n"
     ]
    }
   ],
   "source": [
    "lost_fights_count = int(input())\n",
    "helmet_price = float(input())\n",
    "sword_price = float(input())\n",
    "shield_price = float(input())\n",
    "armor_price = float(input())\n",
    "\n",
    "expenses = 0\n",
    "counter_shield_broken = 0\n",
    "\n",
    "for lost_fight in range(1, lost_fights_count + 1):\n",
    "    if lost_fight % 2 == 0:\n",
    "        expenses += helmet_price\n",
    "    if lost_fight % 3 == 0:\n",
    "        expenses += sword_price\n",
    "    if lost_fight % 2 == 0 and lost_fight % 3 == 0:\n",
    "        expenses += shield_price\n",
    "        counter_shield_broken += 1\n",
    "    if counter_shield_broken == 2:\n",
    "        expenses += armor_price\n",
    "        counter_shield_broken = 0\n",
    "        \n",
    "print(f\"Gladiator expenses: {expenses:.2f} aureus\")"
   ]
  }
 ],
 "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
}