Desafios.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Desafios Code Wars/BeeCrowd"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "TestedeTexto\n"
     ]
    }
   ],
   "source": [
    "# Desafio 1: Retirar os símbolos \"-\" e \"_\" do meio do texto:\n",
    "\n",
    "import re\n",
    "def juntar(texto):\n",
    "    a = texto.split(\"-\")\n",
    "    for i in range(len(a)):\n",
    "        a[i] = a[i].split(\"_\")\n",
    "        b = ''\n",
    "        for j in a[i]:\n",
    "            b = b + j\n",
    "            a[i] = b\n",
    "    c = ''\n",
    "    for k in a:\n",
    "        c = c + k\n",
    "    return c\n",
    "\n",
    "\n",
    "if __name__ == \"__main__\":\n",
    "\n",
    "    c = juntar(\"Teste-de_Texto\")\n",
    "    print(c)\n",
    "    \n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "ename": "KeyboardInterrupt",
     "evalue": "",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mKeyboardInterrupt\u001b[0m                         Traceback (most recent call last)",
      "Cell \u001b[1;32mIn[3], line 14\u001b[0m\n\u001b[0;32m     11\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m n\n\u001b[0;32m     13\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;18m__name__\u001b[39m \u001b[38;5;241m==\u001b[39m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124m__main__\u001b[39m\u001b[38;5;124m\"\u001b[39m:\n\u001b[1;32m---> 14\u001b[0m     a \u001b[38;5;241m=\u001b[39m \u001b[43mdigital_root\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m16\u001b[39;49m\u001b[43m)\u001b[49m\n\u001b[0;32m     15\u001b[0m     b \u001b[38;5;241m=\u001b[39m digital_root(\u001b[38;5;241m942\u001b[39m)\n\u001b[0;32m     16\u001b[0m     c \u001b[38;5;241m=\u001b[39m digital_root(\u001b[38;5;241m132189\u001b[39m)\n",
      "Cell \u001b[1;32mIn[3], line 8\u001b[0m, in \u001b[0;36mdigital_root\u001b[1;34m(n)\u001b[0m\n\u001b[0;32m      6\u001b[0m \u001b[38;5;28;01mwhile\u001b[39;00m y \u001b[38;5;241m>\u001b[39m\u001b[38;5;241m=\u001b[39m \u001b[38;5;241m1\u001b[39m:\n\u001b[0;32m      7\u001b[0m     \u001b[38;5;28;01mfor\u001b[39;00m i \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mrange\u001b[39m(y):\n\u001b[1;32m----> 8\u001b[0m         x \u001b[38;5;241m+\u001b[39m\u001b[38;5;241m=\u001b[39m \u001b[38;5;28mint\u001b[39m(n[i])\n\u001b[0;32m      9\u001b[0m     n \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mstr\u001b[39m(x)\n\u001b[0;32m     10\u001b[0m     y \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mlen\u001b[39m(n)\n",
      "\u001b[1;31mKeyboardInterrupt\u001b[0m: "
     ]
    }
   ],
   "source": [
    "#Desafio 2: Retornar a soma dos algarismos de um número inteiro até que o resultado seja de apenas 1 algarismo:\n",
    "def digital_root(n):\n",
    "    n = str(n)\n",
    "    x = 0\n",
    "    y = len(n)\n",
    "    while y >= 1:\n",
    "        for i in range(y):\n",
    "            x += int(n[i])\n",
    "        n = str(x)\n",
    "        y = len(n)\n",
    "    return n\n",
    "\n",
    "if __name__ == \"__main__\":\n",
    "    a = digital_root(16)\n",
    "    b = digital_root(942)\n",
    "    c = digital_root(132189)\n",
    "    d = digital_root(493193)\n",
    "    \n",
    "    print(a, b, c, d)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[3, 5]\n",
      "[11, 23]\n",
      "[2, 3, 4, 6, 8, 12]\n",
      "[5]\n",
      "13 is prime\n",
      "3 is prime\n",
      "29 is prime\n"
     ]
    }
   ],
   "source": [
    "#Desafio 3: Dado um número inteiro, retornar uma lista com os seus divisores maiores que 1. Se for número primo, retornar: x is prime - Solução aceita!\n",
    "\n",
    "def divisors(integer):\n",
    "    x = integer\n",
    "    y = []\n",
    "    for i in range(2, x):\n",
    "        d = x % i\n",
    "        if d == 0:\n",
    "            y.append(i)\n",
    "    if len(y) > 0:\n",
    "        return y\n",
    "    else:\n",
    "        return (f'{x} is prime')\n",
    "    \n",
    "\n",
    "if __name__ == \"__main__\":\n",
    "    z = divisors(15)\n",
    "    a = divisors(253)\n",
    "    b = divisors(24)\n",
    "    c = divisors(25)\n",
    "    d = divisors(13)\n",
    "    e = divisors(3)\n",
    "    f = divisors(29)\n",
    "    print(z)\n",
    "    print(a)\n",
    "    print(b)\n",
    "    print(c)\n",
    "    print(d)\n",
    "    print(e)\n",
    "    print(f)\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Desafio 3: Solução alternativa\n",
    "\n",
    "def divisors(num):\n",
    "    l = [i for i in range(2,num) if num%i == 0]\n",
    "    if len(l) == 0:\n",
    "        return str(num) + \" is prime\"\n",
    "    return l\n",
    "\n",
    "if __name__ == \"__main__\":\n",
    "    z = divisors(15)\n",
    "    a = divisors(253)\n",
    "    b = divisors(24)\n",
    "    c = divisors(25)\n",
    "    d = divisors(13)\n",
    "    e = divisors(3)\n",
    "    f = divisors(29)\n",
    "    print(z)\n",
    "    print(a)\n",
    "    print(b)\n",
    "    print(c)\n",
    "    print(d)\n",
    "    print(e)\n",
    "    print(f)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import sys\n",
    "import math\n",
    "\n",
    "# Auto-generated code below aims at helping you parse\n",
    "# the standard input according to the problem statement.\n",
    "\n",
    "n = [5, -9, -4, -8]\n",
    "x = []\n",
    "for i in n:\n",
    "    t = int(i)\n",
    "    x.append(t)\n",
    "z = []\n",
    "for i in x:\n",
    "    y = abs(i - 0)\n",
    "    z.append(y)\n",
    "\n",
    "k = z.index(min(z))\n",
    "\n",
    "print(x[k])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Concatena e imprime as palavras do meio de strings se o len for par e imprime a palavra do meio se o len for impar\n",
    "\n",
    "import sys\n",
    "import math\n",
    "import re\n",
    "\n",
    "# Auto-generated code below aims at helping you parse\n",
    "# the standard input according to the problem statement.\n",
    "\n",
    "s = input()\n",
    "x = s.split(' ')\n",
    "y = len(x)\n",
    "k = ''\n",
    "if y % 2 == 0:\n",
    "    z = int(y / 2)\n",
    "    k = x[z-1]+x[z]\n",
    "else:\n",
    "    z = int(((y - 1) / 2))\n",
    "    k = x[z]\n",
    "\n",
    "\n",
    "# Write an answer using print\n",
    "# To debug: print(\"Debug messages...\", file=sys.stderr, flush=True)\n",
    "\n",
    "print(\"toLove\")\n",
    "print(x)\n",
    "print(k)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "ename": "IndexError",
     "evalue": "string index out of range",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mIndexError\u001b[0m                                Traceback (most recent call last)",
      "Cell \u001b[1;32mIn[1], line 12\u001b[0m\n\u001b[0;32m     10\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mlen\u001b[39m(x) \u001b[38;5;241m>\u001b[39m\u001b[38;5;241m=\u001b[39m \u001b[38;5;241m1\u001b[39m \u001b[38;5;129;01mand\u001b[39;00m \u001b[38;5;28mlen\u001b[39m(x) \u001b[38;5;241m<\u001b[39m\u001b[38;5;241m=\u001b[39m \u001b[38;5;241m9\u001b[39m:\n\u001b[0;32m     11\u001b[0m     \u001b[38;5;28;01mfor\u001b[39;00m i \u001b[38;5;129;01min\u001b[39;00m x:\n\u001b[1;32m---> 12\u001b[0m      y \u001b[38;5;241m=\u001b[39m \u001b[43mline\u001b[49m\u001b[43m[\u001b[49m\u001b[43mi\u001b[49m\u001b[38;5;241;43m-\u001b[39;49m\u001b[38;5;241;43m1\u001b[39;49m\u001b[43m]\u001b[49m\n\u001b[0;32m     13\u001b[0m      z\u001b[38;5;241m.\u001b[39mappend(y)\n\u001b[0;32m     15\u001b[0m \u001b[38;5;28mprint\u001b[39m(\u001b[38;5;124m'\u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;241m.\u001b[39mjoin(z))\n",
      "\u001b[1;31mIndexError\u001b[0m: string index out of range"
     ]
    }
   ],
   "source": [
    "# ordenar as letras de uma string de acordo com uma ordem definida pelo usuário:\n",
    "\n",
    "n = int(input())\n",
    "line = input()\n",
    "x = []\n",
    "for i in input().split():\n",
    "    index = int(i)\n",
    "    x.append(index)\n",
    "z = []\n",
    "if len(x) >= 1 and len(x) <= 9:\n",
    "    for i in x:\n",
    "     y = line[i-1]\n",
    "     z.append(y)\n",
    "     \n",
    "print(''.join(z))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# O código verifica quantas jarras de suco são possíveis ser feitas dada uma sequência de caracteres indicando a quantidade de frutas:\n",
    "n = int(input())\n",
    "fruit = []\n",
    "quant = []\n",
    "for i in range(n):\n",
    "    inputs = input().split()\n",
    "    c = inputs[0]\n",
    "    fruit.append(c)\n",
    "    g = int(inputs[1])\n",
    "    quant.append(g)\n",
    "fruits = input()\n",
    "k = []\n",
    "for j in fruit:\n",
    "    y = fruits.count(j)\n",
    "    z = quant[fruit.index(j)]\n",
    "    s = int(y / z)\n",
    "    k.append(s)\n",
    "b = 0\n",
    "for a in k:\n",
    "    b += a\n",
    "d = int(b / len(k))\n",
    "\n",
    "print(d)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "A=78.5397\n"
     ]
    }
   ],
   "source": [
    "raio = float(input())\n",
    "n = 3.14159\n",
    "area = round((n * raio ** 2), 4)\n",
    "\n",
    "print(f\"A={area}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Formatação Numérica - {area:.4f} - area: variavel com o valor, .4f - numero da casas decimais\n",
    "raio = float(input())\n",
    "n = 3.14159\n",
    "raio2 = raio ** 2\n",
    "area = round(n * raio2, 4)\n",
    "print(f\"A={area:.4f}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def area(raio):\n",
    "    n = 3.14159\n",
    "    raio2 = raio ** 2\n",
    "    area = round(n * raio2, 4)\n",
    "    return area\n",
    "\n",
    "x = int(input())\n",
    "for i in range(x):\n",
    "    print(area(float(input())))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "A = float(input())\n",
    "while A < 0 and A > 10:\n",
    "    A = float(input())\n",
    "B = float(input())\n",
    "while B < 0 and B > 10:\n",
    "    B = float(input())\n",
    "\n",
    "MEDIA = ((A * 3.5) + (B * 7.5)) / 11\n",
    "\n",
    "print(f\"MEDIA = {MEDIA:.5f}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "MEDIA = 22.5\n"
     ]
    }
   ],
   "source": [
    "# Media de 3 Numeros:\n",
    "\n",
    "A = float(input())\n",
    "while A < 0 and A > 10:\n",
    "    A = float(input())\n",
    "B = float(input())\n",
    "while B < 0 and B > 10:\n",
    "    B = float(input())\n",
    "C = float(input())\n",
    "while C < 0 and C > 10:\n",
    "    C = float(input())\n",
    "\n",
    "MEDIA = ((A * 2) + (B * 3) + (C * 5)) / 10\n",
    "\n",
    "print(f'MEDIA = {MEDIA:.1f}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "DIFERENCA = -4312\n"
     ]
    }
   ],
   "source": [
    "# Diferença entre 4 números:\n",
    "\n",
    "A = int(input())\n",
    "B = int(input())\n",
    "C = int(input())\n",
    "D = int(input())\n",
    "\n",
    "DIFERENCA = (A * B) - (C * D)\n",
    "\n",
    "print(f'DIFERENCA = {DIFERENCA}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "NUMBER = 2\n",
      "SALARY = U$ 1100.00\n"
     ]
    }
   ],
   "source": [
    "# Calcular Salario\n",
    "id = int(input())\n",
    "horastrab = int(input())\n",
    "valhora = float(input())\n",
    "\n",
    "salario = horastrab * valhora\n",
    "\n",
    "print(f'NUMBER = {id}\\nSALARY = U$ {salario:.2f}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#sequencias = (input() +'\\n' + input()).split('\\n')\n",
    "#print(sequencias)\n",
    "\n",
    "#print(len(sequencias[0]))\n",
    "\n",
    "def compRNA(seq):\n",
    "    for i in range(len(seq[0])):\n",
    "        diferencas = 1    \n",
    "        if seq[0][i] != '.' and seq[1][i] != '.' and seq[0][i] != seq[1][i]:\n",
    "            while seq[0][i+1] != seq[1][i+1]:\n",
    "                diferencas += 1\n",
    "        return f'Mutações: {diferencas}'\n",
    "\n",
    "n = int(input())\n",
    "for i in range(n):\n",
    "    sequencias = (input() +'\\n' + input()).split('\\n')\n",
    "    print(compRNA(sequencias))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Salario com Bonus\n",
    "\n",
    "nome, salario, vendas = input().split()\n",
    "\n",
    "receber = float(salario) + (float(vendas) * 0.15)\n",
    "\n",
    "print(f'TOTAL = R${receber:.2f}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "nome = input()\n",
    "salario = float(input())\n",
    "vendas = float(input())\n",
    "\n",
    "receber = salario + (vendas * 0.15)\n",
    "\n",
    "print('TOTAL = R${0:4.2f}'.format(receber))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Calculo Simples\n",
    "\n",
    "n = int(input())\n",
    "pagar = 0\n",
    "for i in range(n):\n",
    "    cod, quant, val = input().split()\n",
    "    pagar += float(quant) * float(val)\n",
    "    \n",
    "print('VALOR A PAGAR: R$ {0:.2f}'.format(pagar))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "cod1, quant1, val1 = input().split()\n",
    "cod2, quant2, val2 = input().split()\n",
    "pagar = (float(quant1) * float(val1)) + (float(quant2) * float(val2))\n",
    "print('VALOR A PAGAR: R$ {0:.2f}'.format(pagar))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Areas\n",
    "A, B, C = input().split()\n",
    "pi = 3.14159\n",
    "\n",
    "tri = (float(A) * float(C)) / 2\n",
    "cir = pi * (float(C) ** 2)\n",
    "tra = ((float(A) + float(B)) * float(C)) / 2\n",
    "qua = float(B) ** 2\n",
    "ret = float(A) * float(B)\n",
    "\n",
    "print('TRIANGULO: {0:.3f}\\nCIRCULO: {1:.3f}\\nTRAPEZIO: {2:.3f}\\nQUADRADO: {3:.3f}\\nRETANGULO: {4:.3F}'.format(tri, cir, tra, qua, ret))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# O Maior\n",
    "num = list(map(int, input().split()))\n",
    "print('{0} eh o maior'.format(max(num)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Consumo\n",
    "dist = int(input())\n",
    "cons = float(input())\n",
    "med = dist / cons\n",
    "print('{0:.3f} km/l'.format(med))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Distancia entre 2 pontos:\n",
    "\n",
    "x1, y1 = list(map(float, input().split()))\n",
    "x2, y2 = list(map(float, input().split()))\n",
    "dista = (((x2 - x1) ** 2) + ((y2 - y1) ** 2)) ** 0.5\n",
    "print('{0:.4f}'.format(dista))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Distancia entre Veiculos:\n",
    "dist = int(input())\n",
    "time = dist * 2\n",
    "print('{0} minutos'.format(time))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Gasto de combustivel\n",
    "tempo = float(input())\n",
    "velocidade = float(input())\n",
    "gasto = (tempo * velocidade) / 12\n",
    "print('{0:.3f}'.format(gasto))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Numero em Cedulas\n",
    "valor = int(input())\n",
    "if valor < 1000000:\n",
    "    cedulas = [100,50,20,10,5,2,1]\n",
    "    quant = []\n",
    "    print(valor)\n",
    "    while valor >= 1:\n",
    "        for i in cedulas:\n",
    "            quant.append((valor-(valor%i))/i)\n",
    "            valor = valor%i\n",
    "    for i in range(len(cedulas)):\n",
    "        print('{0:.0f} nota(s) de R$ {1:.2f}'.format(quant[i], cedulas[i]).replace('.',','))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Converter Tempo em Segundos\n",
    "\n",
    "valor = int(input())\n",
    "hora = int((valor - valor%3600) / 3600)\n",
    "valor = valor%3600\n",
    "minuto = int((valor - valor%60) / 60)\n",
    "valor = valor%60\n",
    "segundo = int(valor)\n",
    "\n",
    "print('{0}:{1}:{2}'.format(hora, minuto, segundo))\n",
    "\n",
    "print(f'{hora}:{minuto}:{segundo}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Idade em Dias\n",
    "\n",
    "valor = int(input())\n",
    "\n",
    "ano = int((valor - valor%365) / 365)\n",
    "valor = valor%365\n",
    "mes = int((valor - valor%30) / 30)\n",
    "valor = valor%30\n",
    "dia = int(valor)\n",
    "\n",
    "print('{0} ano(s)\\n{1} mes(es)\\n{2} dia(s)'.format(ano,mes,dia))\n",
    "\n",
    "print(f'{ano} ano(s)\\n{mes} mes(es)\\n{dia} dia(s)')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "valor = float(input())\n",
    "if valor >= 0 and valor <= 1000000.00:\n",
    "    cedulas = [100.00,50.00,20.00,10.00,5.00,2.00,1.00,0.5,0.25,0.1,0.05,0.01]\n",
    "    quant = []\n",
    "    \n",
    "    while valor >= 0.01:\n",
    "        for i in cedulas:\n",
    "            quant.append((valor-(valor%i))/i)\n",
    "            valor = valor%i\n",
    "    print('NOTAS:')\n",
    "    for i in range(len(cedulas)):\n",
    "        if cedulas[i] >= 2:\n",
    "            print('{0:.0f} nota(s) de R$ {1:.2f}'.format(quant[i], cedulas[i]))\n",
    "    print('MOEDAS:')\n",
    "    for i in range(len(cedulas)):\n",
    "        if cedulas[i] < 2:\n",
    "            print('{0:.0f} moeda(s) de R$ {1:.2f}'.format(quant[i], cedulas[i]))\n",
    "print('')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Balancear carregadores\n",
    "\n",
    "peso1 = 196\n",
    "peso2 = 102\n",
    "peso3 = 106\n",
    "\n",
    "carregadores = 15\n",
    "\n",
    "unidade = (peso1+peso2+peso3) / carregadores\n",
    "\n",
    "cont1 = round(peso1 / unidade, 0)\n",
    "cont2 = round(peso2 / unidade, 0)\n",
    "cont3 = round(peso3 / unidade, 0)\n",
    "\n",
    "print(f'Carregadores do Box 1: {int(cont1)}\\nCarregadores do Box 2: {int(cont2)}\\nCarregadores do Box 3: {int(cont3)}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Desafio dos Passos - Squadio/DIO"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "passo = int(input())\n",
    "\n",
    "if passo >= 0:\n",
    "    if passo == 0:\n",
    "        print(\"Nenhum passo dado na floresta.\")\n",
    "    else:\n",
    "        for i in range(passo):\n",
    "            if i+1 == 1:\n",
    "                print(\"Explorador: 1 passo\")\n",
    "            elif i+1 > 1:\n",
    "                print(f\"Explorador: {i+1} passos\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Desafio da Lista de Itens - Squadio/DIO"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Lista para armazenar os itens\n",
    "itens = []\n",
    "\n",
    "# TODO: Solicite os itens ao usuário\n",
    "#print(\"Insira 3 itens:\")\n",
    "for i in range(3):\n",
    "    itens.append(input())\n",
    "\n",
    "# Exibe a lista de itens\n",
    "print(\"Lista de itens:\")\n",
    "for item in itens:\n",
    "    print(f\"- {item}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Desafio Upgrade de Capacidade - Squadio/DIO"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "capacidade_atual, aumento_percentual = map(int, input().split())\n",
    "\n",
    "# TODO: Calcule a nova capacidade do disco de Mithril\n",
    "\n",
    "nova_capacidade = int(capacidade_atual * (1 + (aumento_percentual / 100)))\n",
    "\n",
    "# TODO: Imprima a nova capacidade\n",
    "print(nova_capacidade)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4096 262144 0.015625\n"
     ]
    }
   ],
   "source": [
    "z = (4**3)**2/4**3**2\n",
    "a = (4**3)**2\n",
    "b = 4**3**2\n",
    "print(a,b,z)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "inmutable\n"
     ]
    }
   ],
   "source": [
    "s = 'immutable'\n",
    "s = [i for i in s]\n",
    "s[1] = 'n'\n",
    "s = ''.join(s)\n",
    "print(s)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "36 3\n"
     ]
    }
   ],
   "source": [
    "x = 6\n",
    "y = 2\n",
    "print(x ** y, x // y)"
   ]
  }
 ],
 "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.12.2"
  },
  "orig_nbformat": 4
 },
 "nbformat": 4,
 "nbformat_minor": 2
}