Assignments/PT-BR/Assignment_1_Solutions.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "1) Trabalhe a variável fornecida **x** apenas com atributos de string (como '.upper') para torna-la exatamente: \"$Diclorodifeniltricloroetano$\"."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = \"DiClOrod  IFeNi  lTRicLOr oETaNo  \""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Diclorodifeniltricloroetano\n"
     ]
    }
   ],
   "source": [
    "x = x.replace(\" \",\"\").capitalize()\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "2) Atribua respectivamente os valores **'palavra'** , **15** , **3.14** e **'lista'** para as variáveis **A**,**B**, **C** e **D** em uma única linha de código. Depois, imprima-as nessa mesma ordem em uma única linha separadas por um espaço, usando apenas um print."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "palavra 15 3.14 lista\n"
     ]
    }
   ],
   "source": [
    "A, B, C, D = 'palavra', 15, 3.14, 'lista'\n",
    "print(A,B,C,D,sep=\" \")\n",
    "#print(f\"{A} {B} {C} {D}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "3) Ultilize a função **input()** para receber uma entrada na forma **'68.4 1.71'**, ou seja, dois números em ponto flutuante em uma linha separados por espaço. Daí, atribua esses números respectivamente às variáveis **p** e **h**, que representam peso e altura de um indivíduo (dica: dê uma olhada no método '.split()'). Com esses dados, calcule o Índice de Massa Corporal (IMC) do indivíduo a partir da seguinte relação:\n",
    "    \n",
    "\\begin{equation}\n",
    "IMC = \\dfrac{peso}{altura^2}\n",
    "\\end{equation}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Digite peso e altura respectivamente, separados por espaço:  71 1.82\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "21.434609346697258\n"
     ]
    }
   ],
   "source": [
    "p,h = input(\"Digite peso e altura respectivamente, separados por espaço: \").split()\n",
    "IMC = float(p)/float(h)**2\n",
    "print(IMC)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Esse íncide pode ainda ser classificado conforme faixas de valores, de acordo com a tabela abaixo. Use estruturas condicionais para classificar e imprimir a classificação atribuida ao indivíduo.\n",
    "\n",
    "<center><img src=\"https://miro.medium.com/max/1514/0*XPL4s-jVqLsB6ae8.png\" width=\"40%\"><\\center>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Peso ideal (parabéns)\n"
     ]
    }
   ],
   "source": [
    "if IMC <= 18.5:\n",
    "    print(\"abaixo do peso\")\n",
    "elif IMC <= 24.9:\n",
    "    print(\"Peso ideal (parabéns)\")\n",
    "elif IMC <= 29.9:\n",
    "    print(\"Levemente acima do peso\")\n",
    "elif IMC <= 34.9:\n",
    "    print(\"Obesidade grau I\")\n",
    "elif IMC <= 39.9:\n",
    "    print(\"Obesidade grau II (severa)\")\n",
    "else:\n",
    "    print(\"Obesidade III (mórbida)\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "4) Receba como input um número inteiro e, ultilizando um loop, calcule o fatorial deste número, ou seja, o produto de todos os inteiros de um até o número fornecido."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Digite um inteiro:  5\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5! = 120\n"
     ]
    }
   ],
   "source": [
    "num = int(input(\"Digite um inteiro: \"))\n",
    "fat = 1\n",
    "for i in range(1,num+1):\n",
    "    fat *= i # Equivale a fat = fat * i\n",
    "print(f\"{num}! = {fat}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "5) Fazendo uso de um loop while e da função input, leia uma quantidade indefinida de números inteiros até que o número lido seja -1. Apresente a soma de todos esses números na forma de um print, excluindo o -1 lido ao final."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Digite um inteiro:  15\n",
      "Digite um inteiro:  21\n",
      "Digite um inteiro:  8\n",
      "Digite um inteiro:  9\n",
      "Digite um inteiro:  -1\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Soma = 53\n"
     ]
    }
   ],
   "source": [
    "soma, num = 0, 0\n",
    "while num != -1:\n",
    "    soma+=num\n",
    "    num = int(input(\"Digite um inteiro: \"))\n",
    "print(f\"Soma = {soma}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "6) Leia o **nome** de um funcionário, seu **número de horas trabalhadas** e o **valor que recebe por hora** em uma única linha separados por espaço. A seguir, calcule o **salário** desse funcionário e mostre-o com duas casas decimais."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Insira nome, tempo de trabalho e valor da hora:  Igor 10 5000\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "50000.00\n"
     ]
    }
   ],
   "source": [
    "nome, horas, valor = input(\"Insira nome, tempo de trabalho e valor da hora: \").split()\n",
    "salario = float(horas)*float(valor)\n",
    "print('{:.2f}'.format(salario))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "7) Leia três valores com ponto flutuante **A**, **B** e **C** respectivamente. Em seguida, calcule e mostre:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Insira os três valores 27 18 15\n"
     ]
    }
   ],
   "source": [
    "A, B, C = [float(x) for x in input(\"Insira os três valores\").split()]\n",
    "# a, b, c = input().split()\n",
    "# A, B, C = float(a), float(b), float(c)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "    a) a área do triângulo retângulo que tem A por base e C por altura."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Área: 120.0\n"
     ]
    }
   ],
   "source": [
    "print(\"Área:\", A*C/2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "    b) a área do círculo de raio C. (pi = 3.14159)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Área: 804.24704\n"
     ]
    }
   ],
   "source": [
    "print(\"Área:\", 3.14159*C**2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "    c) a área do trapézio que tem A e B por bases e C por altura."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Área: 312.0\n"
     ]
    }
   ],
   "source": [
    "print(\"Área:\", (A+B)*C/2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "    d) a área do quadrado que tem lado B."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Área: 576.0\n"
     ]
    }
   ],
   "source": [
    "print(\"Área:\", B**2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "    e) a área do retângulo que tem lados A e B."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Área: 360.0\n"
     ]
    }
   ],
   "source": [
    "print(\"Área:\", A*B)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "8) Leia **3 valores de ponto flutuante** e efetue o cálculo das **raízes da equação de segundo grau** formada por esses coeficientes (Bhaskara). Se não for possível calcular as raízes, mostre a mensagem **“Impossivel calcular”**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Valores de a, b e c:  1 0 0\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Raiz: -0.0\n"
     ]
    }
   ],
   "source": [
    "a, b, c = [float(x) for x in input(\"Valores de a, b e c: \").split()]\n",
    "if a==0:\n",
    "    print(\"a deve ser diferente de zero!\")\n",
    "else:\n",
    "    delta = b**2-4*a*c\n",
    "    if delta<0:\n",
    "        print(\"Impossível calcular\")\n",
    "    elif delta == 0:\n",
    "        x = -b/(2*a)\n",
    "        print(f\"Raiz: {x}\")\n",
    "    else:\n",
    "        #Lembrando que sqrt(n) = n^(1/2)\n",
    "        x1 = (-b+delta**0.5)/(2*a)\n",
    "        x2 = (-b-delta**0.5)/(2*a)\n",
    "        print(f\"Raizes: {x1}, {x2}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "9) Leia quatro valores numéricos com ponto flutuante correspondentes às coordenadas de dois pontos no plano carteziano. Cada ponto virá em uma linha com suas coordenadas semapradas por espaço. Depois, calcule e mostre a distância entre esses dois pontos.\n",
    "\n",
    "(obs: $d=\\sqrt{(x_1-x_2)^2 + (y_1-y_2)^2}$)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Digite x1 e y1:  2 5\n",
      "Digite x2 e y2:  8 -3\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "d = 10.0\n"
     ]
    }
   ],
   "source": [
    "x1, y1 = [float(i) for i in input(\"Digite x1 e y1: \").split()]\n",
    "x2, y2 = [float(i) for i in input(\"Digite x2 e y2: \").split()]\n",
    "d = ((x1-x2)**2+(y1-y2)**2)**0.5\n",
    "print(f\"d = {d}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "10) Leia **dois números de ponto flutuante** em uma linha que representam as **coordenadas de um ponto carteziano**. Com isso, use **estruturas condicionais** para determinar se está na origem, imprimindo a menságem **'origem'**, em um dos eixos, imprimindo **'eixo x'** ou **'eixo y'**, ou em um dos quatro quadrantes, imprimindo **'q1'**, **'q2**', **'q3'** ou **'q4'**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Insira x e y: 5 -3\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "q4\n"
     ]
    }
   ],
   "source": [
    "x, y = [float(x) for x in input(\"Insira x e y:\").split()]\n",
    "\n",
    "if x==0 and y==0:\n",
    "    print('origem')\n",
    "elif x==0:\n",
    "    print('eixo y')\n",
    "elif y==0:\n",
    "    print('eixo x')\n",
    "elif x>0 and y>0:\n",
    "    print('q1')\n",
    "elif x>0:\n",
    "    print('q4')\n",
    "elif y>0:\n",
    "    print('q2')\n",
    "else:\n",
    "    print('q3')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "11) Leia um número inteiro que representa um código de DDD para discagem interurbana. Em seguida, informe a qual cidade o DDD pertence, considerando a tabela abaixo.\n",
    "\n",
    "<center><img src=\"https://resources.urionlinejudge.com.br/gallery/images/problems/UOJ_1050.png\" width=\"40%\"><\\center>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Insira o DDD: 10\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "DDD inválido.\n"
     ]
    }
   ],
   "source": [
    "ddd = int(input(\"Insira o DDD:\"))\n",
    "dicio = {61:'Brasilia',\n",
    "         71:'Salvador',\n",
    "         11:'Sao Paulo',\n",
    "         21:'Rio de Janeiro',\n",
    "         32:'Juiz de Fora',\n",
    "         19:'Campinas',\n",
    "         27:'Vitoria',\n",
    "         31:'Belo Horizonte'}\n",
    "if ddd in dicio.keys():\n",
    "    print(dicio[ddd])\n",
    "else:\n",
    "    print('DDD inválido.')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "12) Leia um valor inteiro entre 1 e 12, inclusive. Correspondente a este valor, deve ser apresentado como resposta em um print o mês do ano por extenso, com a primeira letra maiúscula."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Insira o valor numérido do mês: 11\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Esse é o mês de Novembro\n"
     ]
    }
   ],
   "source": [
    "mes = int(input(\"Insira o valor numérido do mês:\"))\n",
    "dicio = {1:'Janeiro',\n",
    "         2:'Fevereiro',\n",
    "         3:'Março',\n",
    "         4:'Abril',\n",
    "         5:'Maio',\n",
    "         6:'Junho',\n",
    "         7:'Julho',\n",
    "         8:'Agosto',\n",
    "         9:'Setembro',\n",
    "         10:'Outubro',\n",
    "         11:'Novembro',\n",
    "         12:'Dezembro'}\n",
    "if mes<1 or mes>12:\n",
    "    print('Valor inválido')\n",
    "else:\n",
    "    print('Esse é o mês de',dicio[mes])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "12) Faça um programa que leia 6 valores em uma linha. A seguir, mostre a quantidade de valores positivos digitados. Na linha seguinte, imprima a média dos valores com uma casa decimal."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Digite 6 valores:  1 2 3 5 4 -2\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5 positivos digitados\n",
      "Média = 2.1666666666666665\n"
     ]
    }
   ],
   "source": [
    "entrada6 = [float(x) for x in input(\"Digite 6 valores: \").split()]\n",
    "\n",
    "pos, soma = 0, 0\n",
    "for i in entrada6:\n",
    "    soma += i\n",
    "    if i > 0:\n",
    "        pos += 1\n",
    "print(f\"{pos} positivos digitados\")\n",
    "print(f\"Média = {soma/6}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "13) Leia um valor inteiro **N**. Apresente o **quadrado de cada um dos valores pares**, de 1 até N, inclusive N, se for o caso, dispostos um por linha."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Digite um inteiro:  16\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4\n",
      "16\n",
      "36\n",
      "64\n",
      "100\n",
      "144\n",
      "196\n",
      "256\n"
     ]
    }
   ],
   "source": [
    "N = int(input(\"Digite um inteiro: \"))\n",
    "for i in range(1,N+1):\n",
    "    if i%2==0:\n",
    "        print(i**2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "14) Leia um valor **N** que representa a quantidade de casos de teste. Em seguida, para cada um dos casos, **leia um número inteiro e imprima sua classificação como 'par/impar' e 'positivo/negativo'**. as duas palavras que classificam o número devem ser impressas em uma mesma linha separadas por um espaço. No caso do valor zero, imprima apenas **'nulo'**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Quantidade de testes:  6\n",
      "Inteiro teste 1/6:  0\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "nulo\n"
     ]
    },
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Inteiro teste 2/6:  2\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "par positivo\n"
     ]
    },
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Inteiro teste 3/6:  3\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ímpar positivo\n"
     ]
    },
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Inteiro teste 4/6:  -1\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ímpar negativo\n"
     ]
    },
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Inteiro teste 5/6:  -2\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "par negativo\n"
     ]
    },
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Inteiro teste 6/6:  10\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "par positivo\n"
     ]
    }
   ],
   "source": [
    "N = int(input(\"Quantidade de testes: \"))\n",
    "\n",
    "for i in range(1,N+1):\n",
    "    num = int(input(f\"Inteiro teste {i}/{N}: \"))\n",
    "    if num==0:\n",
    "        print('nulo')\n",
    "    else:\n",
    "        paridade = \"ímpar\"\n",
    "        sinal = \"negativo\"\n",
    "        if num%2==0:\n",
    "            paridade = \"par\"\n",
    "        if num>0:\n",
    "            sinal = \"positivo\"\n",
    "        print(paridade,sinal,sep=\" \")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Desafio\n",
    "15) Problemas de ordenação são recorrentes na história da programação. Ao longo do tempo, diversos algoritmos foram desenvolvidos para cumprir essa função. O mais simples desses algoritmos é o **Bubble Sort**, que é baseado em comparações de elementos dois a dois em um loop de passagens pelos elementos. Leia mais sobre o **Bubble Sort** clicando [aqui](https://pt.wikipedia.org/wiki/Bubble_sort), ou veja esse [vídeo](https://www.youtube.com/watch?v=lyZQPjUT5B4). Sua missão, se decidir aceita-la, será receber como input seis números inteiros fora de ordem. Implemente o principio do **Bubble Sort** para ordenar esses seis números **usando apenas loop e estrutura condicional**. No fim, imprima os seis números em ordem crescente em uma única linha separados por espaço."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Digite 6 inteiros:  5 10 -9 6 4 15\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-9 4 5 6 10 15\n",
      "100\n"
     ]
    }
   ],
   "source": [
    "lista = [int(x) for x in input(\"Digite 6 inteiros: \").split()]\n",
    "trocado = True\n",
    "while trocado:\n",
    "    trocado = False\n",
    "    for i in range(0,len(lista)-1):\n",
    "        if lista[i] > lista[i+1]:\n",
    "            lista[i],lista[i+1] = lista[i+1],lista[i]\n",
    "#           aux = lista[i]\n",
    "#           lista[i] = lista[i+1]\n",
    "#           lista[i+1] = aux\n",
    "            trocado = True\n",
    "print(' '.join([str(x) for x in lista]))"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.10"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}