Mod 02 - Elementos básicos do Python e NumPy.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "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": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "sexo = 'F'\n",
    "beta_hcg = 0\n",
    "\n",
    "# seu código vem abaixo desta linha\n",
    "x = int(input('Seu Teste? ' ))\n",
    "x=5\n",
    "if x < 5:\n",
    "      print(\"Seu teste deu Negativo\" % x)\n",
    "elif x > 5:\n",
    "      print(\"Seu teste está Positivo!\" % x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "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": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "dic_renomeacao = {'name':1, 'age':2, 'income':3}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "len(dic_renomeacao)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "dic_renomeacao\n",
    "{'name':'nome', 'age':'idade', 'income':'renda'}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "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": 97,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "43.0"
      ]
     },
     "execution_count": 97,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "N = 42\n",
    "M = 7\n",
    "\n",
    "#Seu código\n",
    "\n",
    "42 + 7 / 7"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "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": 130,
   "metadata": {},
   "outputs": [],
   "source": [
    "N = 47\n",
    "\n",
    "# seu código abaixo\n",
    "#Estrutura para printar valores impares ate 47"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 143,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{3, 5, 7, 47}"
      ]
     },
     "execution_count": 143,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "impares = {1,3,5,7,9,47}\n",
    "impares\n",
    "primos = {2,3,5,7,11,13,47}\n",
    "primos\n",
    "impares & primos\n",
    "# se o numero 47 apareceu no output ele e primo"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "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": 134,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{4, 6, 8, 10, 98}"
      ]
     },
     "execution_count": 134,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "N = 98\n",
    "\n",
    "# seu código aqui\n",
    "\n",
    "pares = {2,4,6,8,10,98}\n",
    "pares\n",
    "\n",
    "primos = {2,3,5,7,11,13,...,97,101}\n",
    "primos\n",
    "\n",
    "pares - primos\n",
    "\n",
    "# retornando os valores diferentes para comparacao de resultados\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "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": 157,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "21.7"
      ]
     },
     "execution_count": 157,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "imc_ideal = (18.5 + 24.9) / 2\n",
    "imc_ideal"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "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": 209,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "7.508650519031143"
      ]
     },
     "execution_count": 209,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "altura = 1.70\n",
    "\n",
    "# Seu código\n",
    "peso_ideal = 21.7 / (1.70 * 1.70)\n",
    "peso_ideal "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "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": 249,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "([5.706771860618015],\n",
       " [5.163593099345628],\n",
       " [7.508650519031143],\n",
       " [7.970615243342516])"
      ]
     },
     "execution_count": 249,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "lista_alturas = [1.95, 2.05, 1.70, 1.65]\n",
    "\n",
    "lista_peso_ideal = [21.7 / (1.95 * 1.95)] , [21.7 / (2.05 * 2.05)] , [21.7 / (1.70 * 1.70)] , [21.7 / (1.65 * 1.65)]\n",
    "\n",
    "# seu código\n",
    "\n",
    "lista_peso_ideal"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "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": 244,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[(1.8, 90), (1.65, 75), (1.91, 70)]"
      ]
     },
     "execution_count": 244,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "altura_peso = [(1.80, 90), (1.65, 75), (1.91, 70)]\n",
    "\n",
    "imc =  tupla1, tupla2, tupla3 = [(1.80,90), (1.65, 75), (1.91, 70)]\n",
    "\n",
    "# seu código\n",
    "imc "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 245,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1.8, 90)"
      ]
     },
     "execution_count": 245,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tupla1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 246,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1.65, 75)"
      ]
     },
     "execution_count": 246,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tupla2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 247,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1.91, 70)"
      ]
     },
     "execution_count": 247,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tupla3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "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": 288,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[[1.8, 90], [1.65, 75], [1.91, 70]]"
      ]
     },
     "execution_count": 288,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "altura_peso = [[1.80, 90], [1.65, 75], [1.91, 70]]\n",
    "\n",
    "# seu código\n",
    "\n",
    "altura_peso"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 295,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1.8, 90, 'A']"
      ]
     },
     "execution_count": 295,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "lista1 = [1.80, 90]\n",
    "lista1.append('A')\n",
    "lista1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 296,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1.65, 75, 'B']"
      ]
     },
     "execution_count": 296,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "lista2 = [1.65, 75]\n",
    "lista2.append('B')\n",
    "lista2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "lista3 = [1.91, 70]\n",
    "lista3.append('C')\n",
    "lista3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "lista1,lista2,lista3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.9.13"
  },
  "vscode": {
   "interpreter": {
    "hash": "c3d784bd0e3e0fa5e4f841272b6d3be81d258b268fff267ce3814bea1adf1d4a"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}