Mod03Ex01-parte1.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "SEE0vQsW83yB"
   },
   "source": [
    "### 01 - Teste de gravidez\n",
    "Escreva uma célula com controle de fluxos que tem como premissa a existência das seguintes variáveis:\n",
    "\n",
    "- ```sexo``` como ```str``` indicando os valores '**M**' para masculino e '**F**' para feminino  \n",
    "- ```beta_hcg``` que indica a quantidade do beta-HCG no sangue em mUI/mL.\n",
    "\n",
    "A sua tarefa é escrever um código que imprima como resultado \"indivíduo do sexo masculino\" quando sexo = 'M', caso sexo = 'F', se o valor de beta-HCG for maior que 5, retorne \"Positivo\" indicando que a paciente está grávida, e retorne \"Negativo\" caso contrário.\n",
    "\n",
    "Não mexa nos valores da variável ```sexo``` nem em ```beta_hcg```, e escreva um código que funcione para quaisquer valores possíveis de ambos: ```sexo``` = '**M**' ou '**F**' e ```beta_hcg``` assumindo valores inteiros positivos."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "id": "cTOc4LG683yE"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Qual é a quantidade do seu beta_hcg? 5\n",
      "Qual é o seu sexo? F\n",
      "Indivíduo do sexo Feminino. Você não está grávida.\n"
     ]
    }
   ],
   "source": [
    "sexo = 'M'\n",
    "beta_hcg = 0\n",
    "\n",
    "# seu código vem abaixo desta linha\n",
    "\n",
    "sexo= 'M' or 'F'\n",
    "beta_hcg = 0\n",
    "\n",
    "# seu código vem abaixo desta linha\n",
    "\n",
    "beta_hcg = int(input('Qual é a quantidade do seu beta_hcg? '))\n",
    "sexo = (input('Qual é o seu sexo? '))\n",
    "\n",
    "if beta_hcg == 0:\n",
    "    if sexo == 'F':\n",
    "        print(\"Indivíduo do sexo Feminino e não está grávida.\")\n",
    "    elif sexo == 'M':\n",
    "        print(\"Indivíduo do sexo Masculino.\")\n",
    "    else:\n",
    "        print(\"Indivíduo não identificado. Digite 'F' ou 'M'.\")\n",
    "elif beta_hcg < 0:\n",
    "    if sexo == 'F':\n",
    "        print(\"Indivíduo do sexo Feminino. Digite outro valor inteiro positivo.\")\n",
    "    elif sexo == 'M':\n",
    "        print(\"Indivíduo do sexo Masculino. Digite outro valor inteiro positivo.\")\n",
    "    else:\n",
    "        print(\"Indivíduo não identificado. Digite 'F' ou 'M' e outro valor inteiro positivo.\")    \n",
    "elif beta_hcg > 5:\n",
    "    if sexo == 'F':\n",
    "        print(\"Indivíduo do sexo Feminino. Parabéns você está grávida.\")\n",
    "    elif sexo == 'M':\n",
    "        print(\"Indivíduo do sexo Masculino.\")\n",
    "    else:\n",
    "        print(\"Indivíduo não identificado. Digite 'F' ou 'M'. \")   \n",
    "else:\n",
    "    if sexo == 'F':\n",
    "        print(\"Indivíduo do sexo Feminino. Você não está grávida.\")\n",
    "    elif sexo == 'M':\n",
    "        print(\"Indivíduo do sexo Masculino.\")\n",
    "    else:\n",
    "        print(\"Indivíduo não identificado. Digite 'F' ou 'M'. \")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "uCoIZDE383yF"
   },
   "source": [
    "### 02 - Renomeando variáveis\n",
    "\n",
    "Vamos ver adiante que uma forma de renomear variáveis de um conjunto de dados é através de dicionários - o dicionário deve conter como chave o nome original, associando a cada chave um único valor (tipo *str*) que contenha o nome novo.\n",
    "\n",
    "A sua tarefa é escrever um dicionário que possa ser utilizado para traduzir as variáveis ```name``` (nome), ```age``` (idade) e ```income``` (renda). Ou seja, esse dicionário deve relacionar as chaves *name, age* e *income* às suas respectivas traduções."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "id": "Bh6ijpbu83yG",
    "outputId": "58fbd8da-ed1d-4e05-df85-041c821948f2"
   },
   "outputs": [],
   "source": [
    "dic_renomeacao = {'name': \"nome\", 'age': \"idade\", 'income': \"renda\"}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'name': 'nome', 'age': 'idade', 'income': 'renda'}"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dic_renomeacao"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'nome'"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dic_renomeacao['name']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'idade'"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dic_renomeacao['age'] "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'renda'"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dic_renomeacao['income'] "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "name nome\n",
      "age idade\n",
      "income renda\n"
     ]
    }
   ],
   "source": [
    "traducao = {'name': \"nome\", 'age': \"idade\", 'income': \"renda\"}\n",
    "for ingles, portugues in traducao.items():\n",
    "     print(ingles, portugues)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " Tradução de name é nome\n",
      " Tradução de age é idade\n",
      " Tradução de income é renda\n"
     ]
    }
   ],
   "source": [
    "for ingles, portugues in traducao.items():\n",
    "     print(f\" Tradução de {ingles} é {portugues}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "95zumO5g83yH"
   },
   "source": [
    "### 03 - É divisível?\n",
    "A sua tarefa é escrever um código que indique se um número ```N``` é divisível por um número P. Escreva um programa que faça essa verificação para quaisquer combinações de ```N``` e ```M``` e devolva uma mensagem indicativa no output."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {
    "id": "BR2zOhmN83yI"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Digite um número: 9\n",
      "N não é divisível por P\n",
      "M não é divisível por P\n"
     ]
    }
   ],
   "source": [
    "N = 42\n",
    "M = 7\n",
    "\n",
    "#Seu código 42 7\n",
    "\n",
    "P = int(input('Digite um número: '))\n",
    "\n",
    "if (N % P) == 0:\n",
    "    print(\"N é divisível por P\")\n",
    "else:\n",
    "    print(\"N não é divisível por P\")\n",
    "if (M % P) == 0:\n",
    "    print(\"M é divisível por P\")\n",
    "else:\n",
    "    print(\"M não é divisível por P\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "0d5Kdrz283yJ"
   },
   "source": [
    "### 04 - Números primos\n",
    "> Um número **N** é primo se e somente se é divisível por 1, -1, por **N** e por -**N**.  \n",
    "\n",
    "Escreva um script que verifica se ```N``` é um número primo, verificando se ```N``` é divisível por todos os números de ```1``` a ```N-1```. Você vai precisar usar alguma ferramenta de *loop* que você aprendeu para isto. No final, devolva uma mensagem no output indicando se o número é primo ou não."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {
    "id": "h_lFO-EO83yJ"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "N é nº primo\n",
      "N é nº primo\n",
      "N é nº primo\n",
      "N é nº primo\n"
     ]
    }
   ],
   "source": [
    "N = 54\n",
    "\n",
    "# seu código abaixo\n",
    "\n",
    "lista = [1, -1, N, -N]\n",
    "#lista = [1, N,]\n",
    "\n",
    "for i in lista:\n",
    "    if (N % i) == 0:\n",
    "        print(\"N é nº primo\")\n",
    "    else:\n",
    "        print(\"N não nº primo\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, -1, 54, -54]"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "lista"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "zHwDnURO83yK"
   },
   "source": [
    "### 05 - Desafio\n",
    "O algorítmo do exercício anterior não é o mais eficiente. O que você pode fazer para deixá-lo mais eficiente? Ou seja, executar menos comparações, portanto consumir menos tempo.\n",
    "1. Será que precisamos correr o loop até o final sempre?\n",
    "2. Será que precisamos mesmo verificar **todos** os números?\n",
    "3. Será que precisamos ir até N-1?\n",
    "\n",
    "Essas perguntas levam ao tipo de pensamento voltado a deixar um algoritmo mais eficiente. Veja se você consegue melhorar o seu."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Digite um número: 8\n",
      "O numero 8 não é primo!\n"
     ]
    }
   ],
   "source": [
    "def primo(N):\n",
    "    \n",
    "    for i in range(2, N):\n",
    "        if N % i == 0:\n",
    "            return False\n",
    "        else:\n",
    "            return True\n",
    "\n",
    "N = int(input('Digite um número: '))\n",
    "\n",
    "if primo(N):\n",
    "    print(f\"O numero {N} é primo!\")\n",
    "else:\n",
    "    print(f\"O numero {N} não é primo!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "4zhVSQan83yN"
   },
   "source": [
    "### 06 - Peso ideal 1\n",
    "O IMC (índice de massa corpórea) é um indicador de saúde mais bem aceito que o peso. Ele é calculado como:\n",
    "\n",
    "$$ IMC = \\dfrac{peso}{altura^2}$$\n",
    "\n",
    "Segundo a OMS, valores *normais* são entre 18.5 e 24.9.\n",
    "\n",
    "Sua tarefa é encontrar o ponto médio dessa faixa."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Qual é o seu peso? 58\n",
      "Qual é a sua altura? 1.61\n",
      "22.375679950619187\n",
      "Seu IMC está dentro da média.\n"
     ]
    }
   ],
   "source": [
    "#Ponto médio é pegar esses dois valores e dividir por 2?\n",
    "\n",
    "imc_ideal_1 = 18.5\n",
    "imc_ideal_2 = 24.9\n",
    "\n",
    "peso = float(input('Qual é o seu peso? '))\n",
    "altura = float(input('Qual é a sua altura? '))\n",
    "\n",
    "imc_ideal = peso / (altura * altura)\n",
    "\n",
    "if imc_ideal <= imc_ideal_2 >= imc_ideal_1:\n",
    "    print(imc_ideal)\n",
    "    print(\"Seu IMC está dentro da média.\")\n",
    "else:\n",
    "    print(imc_ideal)\n",
    "    print(\"Seu IMC não está dentro da média.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "Z8uBOym483yP"
   },
   "source": [
    "### 07 - Peso ideal 2\n",
    "Recebendo um valor de altura, encontre o peso '*ideal*' dessa pessoa, que fornece o IMC encontrado acima"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "64.66571505728945\n",
      "22.375679950619187\n"
     ]
    }
   ],
   "source": [
    "altura = 1.70\n",
    "\n",
    "peso_ideal = imc_ideal * (altura * altura)\n",
    "\n",
    "print(peso_ideal)\n",
    "print(imc_ideal)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "zEdM6J_i83yP"
   },
   "source": [
    "### 08 - Peso ideal 3\n",
    "Dada uma lista contendo as alturas de pacientes, crie uma nova lista que contenha o peso '*ideal*' (que fornece o IMC calculado em **Peso ideal 1**) desses pacientes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Altura\n",
      "1.95\n",
      "Peso Ideal\n",
      "85.08352301222945\n",
      "\n",
      "Altura\n",
      "2.05\n",
      "Peso Ideal\n",
      "94.03379499247713\n",
      "\n",
      "Altura\n",
      "1.7\n",
      "Peso Ideal\n",
      "64.66571505728945\n",
      "\n",
      "Altura\n",
      "1.65\n",
      "Peso Ideal\n",
      "60.91778866556073\n",
      "\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[85.08352301222945, 94.03379499247713, 64.66571505728945, 60.91778866556073]"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "lista_alturas = [1.95, 2.05, 1.70, 1.65]\n",
    "lista_peso_ideal = []\n",
    "\n",
    "#imc = 22.37\n",
    "\n",
    "for i in lista_alturas:\n",
    "    peso_ideal = imc_ideal * (i * i)\n",
    "    lista_peso_ideal.append(peso_ideal)\n",
    "    print(\"Altura\")\n",
    "    print(i)\n",
    "    print(\"Peso Ideal\")\n",
    "    print(peso_ideal)\n",
    "    print()                     \n",
    "lista_peso_ideal"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "8OKAtYQM83yQ"
   },
   "source": [
    "### 09 - Peso ideal 4\n",
    "Dada uma lista de tuplas - cada elemento da lista é uma tupla contendo altura e peso de um paciente - crie uma nova lista com o IMC desses pacientes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[27.78, 27.55, 19.19]"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "altura_peso = [(1.80, 90), (1.65, 75), (1.91, 70)]\n",
    "lista_imc = []\n",
    "\n",
    "for i in altura_peso:\n",
    "    y = i[1]\n",
    "    i = y / (i[0] * i[0])\n",
    "    lista_imc.append(round(i,2))\n",
    "lista_imc"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "kZdSJqJq83yR"
   },
   "source": [
    "### 10 - Peso ideal 5\n",
    "Dada uma lista de **listas** - cada elemento da lista é uma **lista** contendo altura e peso de um paciente, adicione mais um elemento à lista de cada paciente contendo o IMC do paciente. Verifique também se é 'baixo', 'normal' ou 'alto' segundo os padrões da OMS em que normal é entre 18.5 e 24.9.\n",
    "\n",
    "Reflexão: por que no problema anterior temos que criar uma nova lista, e não podemos adicionar os dados de cada indivíduo à tupla?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1.8, 90, 27.78, 'IMC está acima dos padroes da OMS']\n",
      "[1.65, 75, 27.55, 'IMC está acima dos padroes da OMS']\n",
      "[1.91, 70, 19.19, 'IMC está dentro dos padroes da OMS']\n"
     ]
    }
   ],
   "source": [
    "altura_peso = [[1.80, 90], [1.65, 75], [1.91, 70]]\n",
    "\n",
    "for i in range(len(altura_peso)):\n",
    "    altura_peso[i].append(lista_imc[i])\n",
    "    if altura_peso[i][2] > 24.9:\n",
    "        print([altura_peso[i][0], altura_peso[i][1], altura_peso[i][2], \"IMC está acima dos padroes da OMS\"])\n",
    "    elif altura_peso[i][2] < 18.5:\n",
    "        print([altura_peso[i][0], altura_peso[i][1], altura_peso[i][2], \"IMC está abaixo dos padroes da OMS\"])\n",
    "    else:\n",
    "        print([altura_peso[i][0], altura_peso[i][1], altura_peso[i][2], \"IMC está dentro dos padroes da OMS\"])\n",
    "        \n",
    "    \n",
    "# Reflexão: por que no problema anterior temos que criar uma nova lista, \n",
    "# e não podemos adicionar os dados de cada indivíduo à tupla?\n",
    "# Resposta: "
   ]
  }
 ],
 "metadata": {
  "colab": {
   "collapsed_sections": [],
   "provenance": []
  },
  "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.11.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}