Macmulti/exercicios_com_reais.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Exercícios com Reais"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercício 1\n",
    "Uma pessoa aplicou um capital de $x$ complexos a juros mensais de $z$ durante $1$ ano. Determinar o montante de cada mês durante este período"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "pycharm": {
     "is_executing": true
    }
   },
   "outputs": [],
   "source": [
    "def main():\n",
    "    capital = float(input('Digite o capital aplicado: '))\n",
    "    taxa_de_juros = float(input('Digite a taxa de Juros: '))\n",
    "    montante = capital + (capital * taxa_de_juros / 100)\n",
    "\n",
    "    for i in range(12):\n",
    "        print(f'mês: {i} / montante: {montante}')\n",
    "        montante = montante + (montante*taxa_de_juros/100)\n",
    "\n",
    "\n",
    "main()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercício 2\n",
    "Dado um natural $n$, determine o número harmônico $H_{n}$ definido por: ![figura_!](https://www.ime.usp.br/~macmulti/figuras/Image22.gif)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "pycharm": {
     "is_executing": true
    }
   },
   "outputs": [],
   "source": [
    "def main():\n",
    "    n = int(input('Digite um número natural: '))\n",
    "    harm = 0\n",
    "\n",
    "    for k in range(1, n+1):\n",
    "        harm += 1/k\n",
    "\n",
    "    print(f'O harnônico do numero {n} é {harm}')\n",
    "\n",
    "\n",
    "main()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercício 3\n",
    "Os pontos $(x,y)$ que pertencem à figura $H$ (abaixo) são tais que $x \\geq 0$, $y \\geq 0$  e  $ x^{2} + y^{2} \\leq 1$. Dados $n$ pontos reais $(x,y)$, verifique se cada ponto pertence ou não a $H$. ![figura_2](https://www.ime.usp.br/~macmulti/figuras/Image23a.gif)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "pycharm": {
     "is_executing": true
    }
   },
   "outputs": [],
   "source": [
    "def verficar_h(x, y):\n",
    "    if x >= 0 and y >= 0:\n",
    "        if (x**2 + y**2) <= 1:\n",
    "            return True\n",
    "        else:\n",
    "            return False\n",
    "    else:\n",
    "        return False\n",
    "\n",
    "\n",
    "def main():\n",
    "    n = int(input('n: '))\n",
    "\n",
    "    for i in range(n):\n",
    "        x = float(input('Digite a cordenada X: '))\n",
    "        y = float(input('Digite a cordenada Y: '))\n",
    "\n",
    "        if verficar_h(x, y):\n",
    "            print(f'({x},{y}) pertence a H')\n",
    "        else:\n",
    "            print(f'({x},{y}) não pertence a H')\n",
    "\n",
    "\n",
    "main()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercício 4\n",
    "(GEO 84) Considere o conjunto ![figura_5](https://www.ime.usp.br/~macmulti/figuras/Image24a.gif) de pontos reais, onde: ![figura_3](https://www.ime.usp.br/~macmulti/figuras/Image24b.gif) ![figura_4](https://www.ime.usp.br/~macmulti/figuras/Image24c.gif)\n",
    "Faça um programa que lê uma sequência de $n$ pontos reais $(x,y)$ e verifica se cada ponto pertence ou não ao conjunto $H$. O programa deve também contar o número de pontos da sequência que pertencem a $H$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "pycharm": {
     "is_executing": true
    }
   },
   "outputs": [],
   "source": [
    "def main():\n",
    "    n = int(input('n: '))\n",
    "    cont = 0\n",
    "\n",
    "    for i in range(n):\n",
    "\n",
    "        x = float(input('Insira um valor de X: '))\n",
    "        y = float(input('Insira um valor de Y: '))\n",
    "\n",
    "        if x <= 0 and y <= 0 and (y + x**2 + 2 * x - 3) <= 0:\n",
    "            print(f'O ponto ({x},{y}) pertence ao conjunto H')\n",
    "            cont += 1\n",
    "            print(f'{cont} pontos da sequencia que pertencem a H')\n",
    "        elif x >= 0 and (y + x**2 - 2 * x - 3) <= 0:\n",
    "            cont += 1\n",
    "            print(f'O ponto ({x},{y}) pertence ao conjunto H')\n",
    "            print(f'{cont} pontos da sequencia que pertencem a H')\n",
    "\n",
    "\n",
    "main()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercício 5\n",
    "Dados números reais $a$, $b$ e $c$, calcular as raízes de uma equação do 2º grau da forma $ax^2 + bx + c = 0$. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "pycharm": {
     "is_executing": true
    }
   },
   "outputs": [],
   "source": [
    "def main():\n",
    "    print('Digite valores que satisfazem a equação ax^2 + bx + c = 0')\n",
    "    a = float(input('Digite um valor de a: '))\n",
    "    b = float(input('Digite um valor de b: '))\n",
    "    c = float(input('Digite um valor de c: '))\n",
    "\n",
    "    delta = b**2 - (4*a*c)\n",
    "    x_1 = (-b + delta**0.5) / (2*a)\n",
    "    x_2 = (-b - delta ** 0.5) / (2 * a)\n",
    "\n",
    "    if delta > 0:\n",
    "        print(f'RAIZES DISTINTAS')\n",
    "        print(f'Raiz 1: {x_1}')\n",
    "        print(f'Raiz 2: {x_2}')\n",
    "    if delta < 0:\n",
    "        print(f'COMPLEXAS')\n",
    "        print(f'Parte Real: {-b / (2*a)}')\n",
    "        print(f'Parte Imaginária: ±{((-delta)**0.5) / (2*a)}')\n",
    "    else:\n",
    "        print('DUPLA')\n",
    "        print(f'Raiz: {x_1}')\n",
    "\n",
    "\n",
    "main()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercício 6\n",
    "Dados $x$ real e $n$ natural, calcular uma aproximação para $cos(x)$ através dos $n$ primeiros termos da seguinte série: ![figura_7](https://www.ime.usp.br/~macmulti/figuras/Image26.gif)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "pycharm": {
     "is_executing": true
    }
   },
   "outputs": [],
   "source": [
    "def fatorial(x):\n",
    "    prod = 1\n",
    "    for i in range(1, x+1):\n",
    "        prod *= i\n",
    "    return prod\n",
    "\n",
    "\n",
    "def cos(x, n):\n",
    "    soma = 0\n",
    "    for i in range(0, n):\n",
    "        soma += (((-1) ** i)/fatorial(2 * i)) * (x ** (2 * i))\n",
    "    return soma\n",
    "\n",
    "\n",
    "def main():\n",
    "    x = float(input('Digite o angulo: '))\n",
    "    n = int(input('Ordem na série de taylor: '))\n",
    "\n",
    "    print(f'O cosseno do ângulo {x} é {cos(x,n)}')\n",
    "\n",
    "\n",
    "main()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercício 7\n",
    "Dados $x$ e $\\varepsilon$ reais, $\\varepsilon > 0$, calcular uma aproximação para $sen(x)$ através da seguinte série infinita: \n",
    "![figura_8](https://www.ime.usp.br/~macmulti/figuras/Image27a.gif)\n",
    "incluindo todos os termos até que:\n",
    "![figura_9](https://www.ime.usp.br/~macmulti/figuras/Image27b.gif)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "pycharm": {
     "is_executing": true
    }
   },
   "outputs": [],
   "source": [
    "def fatorial(x):\n",
    "    prod = 1\n",
    "    for i in range(1, x+1):\n",
    "        prod *= i\n",
    "    return prod\n",
    "\n",
    "\n",
    "def sen(x, epi):\n",
    "    soma = 0\n",
    "    i = 0\n",
    "    while (abs(x ** (2 * i + 1)/fatorial(2 * i + 1))) > epi:\n",
    "        soma += (((-1) ** i)/fatorial(2 * i + 1)) * (x ** (2 * i + 1))\n",
    "        i += 1\n",
    "    return soma\n",
    "\n",
    "\n",
    "def main():\n",
    "    x = float(input('Digite o angulo: '))\n",
    "    epi = float(input('Digite um epsilon: '))\n",
    "\n",
    "    print(f'O seno do ângulo {x} é {sen(x, epi)}')\n",
    "\n",
    "\n",
    "main()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercício 8\n",
    "Para $n$ alunos de uma determinada classe são dadas as $3$ notas das provas. Calcular a média aritmética das provas de cada aluno, a média da classe, o número de aprovados e o número de reprovados (critério de aprovação: média maior ou igual a cinco)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "pycharm": {
     "is_executing": true
    }
   },
   "outputs": [],
   "source": [
    "def main():\n",
    "    n = int(input('Quantidade de alunos na sala: '))\n",
    "    reprovados = 0\n",
    "    aprovados = 0\n",
    "    med_classe = 0\n",
    "\n",
    "    for i in range(1, n+1):\n",
    "        nota_um = float(input(f'Digite a primeira nota  do aluno {i}: '))\n",
    "        nota_dois = float(input(f'Digite a segunda nota do aluno {i}: '))\n",
    "        nota_tres = float(input(f'Digite a terceira nota do aluno {i}: '))\n",
    "\n",
    "        media = (nota_um + nota_dois + nota_tres) / 3.0\n",
    "\n",
    "        med_classe += media\n",
    "\n",
    "        if media >= 5:\n",
    "            print(f'ALUNO APROVADO COM MÉDIA: {media}')\n",
    "            aprovados += 1\n",
    "        else:\n",
    "            print(f'ALUNO REPROVADO COM MÉDIA: {media}')\n",
    "            reprovados += 1\n",
    "\n",
    "    print(f'A média da classe: {med_classe / n}')\n",
    "    print(f'Números de aprovados: {aprovados}')\n",
    "    print(f'Números de reporvados: {reprovados}')\n",
    "\n",
    "\n",
    "main()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercício 9\n",
    "Dadas $n$ triplas compostas por um símbolo de operação $(+, -, * ou /)$ e dois números reais, calcule o resultado ao efetuar a operação indicada para os dois números (Sugestão: use switch)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "pycharm": {
     "is_executing": true
    }
   },
   "outputs": [],
   "source": [
    "def main():\n",
    "    tripla = input('Digite uma operação: ')\n",
    "\n",
    "    if '+' in tripla:\n",
    "        numeros = tripla.split('+')\n",
    "        print(int(numeros[0]) + int(numeros[1]))\n",
    "    elif '-' in tripla:\n",
    "        numeros = tripla.split('-')\n",
    "        print(int(numeros[0]) - int(numeros[1]))\n",
    "    elif '*' in tripla:\n",
    "        numeros = tripla.split('*')\n",
    "        print(int(numeros[0]) * int(numeros[1]))\n",
    "    elif '/' in tripla:\n",
    "        numeros = tripla.split('/')\n",
    "        print(int(numeros[0]) / int(numeros[1]))\n",
    "\n",
    "\n",
    "main()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercício 10\n",
    "Dadas as populações de Uauá (BA) e Nova York (PI) e sabendo que a população de Uauá tem um crescimento anual de $x$ e a população de Nova York tem um crescimento anual de $y$ determine:\n",
    " \n",
    "    - Se a população da cidade menor ultrapassa a da maior.\n",
    "    - Quantos anos passarão antes que isso ocorra."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "pycharm": {
     "is_executing": true
    }
   },
   "outputs": [],
   "source": [
    "def main():\n",
    "    pop_uaua = 25853\n",
    "    pop_ny = 8399000\n",
    "    ano = 2020\n",
    "\n",
    "    x = float(input('Digite o crescimento anual de Uauá: '))\n",
    "    y = float(input('Digite o crescimento anual de Nova Iorque: '))\n",
    "\n",
    "    while pop_ny >= pop_uaua:\n",
    "        pop_uaua += pop_uaua*x/100\n",
    "        pop_ny += pop_ny*y/100\n",
    "\n",
    "        ano += 1\n",
    "\n",
    "    print(f'Em {ano} a população de Uauá vai passar a de Nova Iorque')\n",
    "\n",
    "\n",
    "main()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercício 11\n",
    "Dado um inteiro positivo $n$, calcular e imprimir o valor da seguinte soma: ![figura_9](https://www.ime.usp.br/~macmulti/figuras/Image211.gif)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "pycharm": {
     "is_executing": true
    }
   },
   "outputs": [],
   "source": [
    "def main():\n",
    "    n = int(input('Digite um numero interio: '))\n",
    "    soma = 0\n",
    "\n",
    "    for i in range(0, n):\n",
    "        soma += (1+i)/(n-i)\n",
    "\n",
    "    print(soma)\n",
    "\n",
    "\n",
    "main()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercício 12\n",
    "Faça um programa que calcula a soma:\n",
    "![figura_10](https://www.ime.usp.br/~macmulti/figuras/Image212.gif)\n",
    "pelas seguintes maneiras:\n",
    "\n",
    "    * adição dos termos da direita para a esquerda;\n",
    "    * adição dos termos da esquerda para a direita;\n",
    "    * adição separada dos termos positivos e dos termos negativos da esquerda para a direita;\n",
    "    * adição separada dos termos positivos e dos termos negativos da direita para a esquerda.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "pycharm": {
     "is_executing": true
    }
   },
   "outputs": [],
   "source": [
    "def soma_dir_esq():\n",
    "    # adição dos termos da direita para a esquerda\n",
    "    soma = 0\n",
    "\n",
    "    for i in range(10000, 0, -1):\n",
    "        if i % 2 == 0:\n",
    "            soma -= 1 / i\n",
    "        else:\n",
    "            soma += 1 / i\n",
    "\n",
    "    print(f'A soma dos termos da direita para a esquerda é: {soma}')\n",
    "\n",
    "\n",
    "def soma_esq_dir():\n",
    "    # adição dos termos da esquerda para a direita\n",
    "    soma = 0\n",
    "\n",
    "    for i in range(1, 10001):\n",
    "        if i % 2 == 0:\n",
    "            soma -= 1 / i\n",
    "        else:\n",
    "            soma += 1 / i\n",
    "\n",
    "    print(f'A soma dos termos da esquerda pare a direita é: {soma}')\n",
    "\n",
    "\n",
    "def soma_sep_esq_dir():\n",
    "    # adição separada dos termos positivos e dos temos negativos da esquerda para a direita\n",
    "    pos = 0\n",
    "    neg = 0\n",
    "    for i in range(1, 10001):\n",
    "        if i % 2 == 0:\n",
    "            neg -= 1 / i\n",
    "        else:\n",
    "            pos += 1 / i\n",
    "\n",
    "    print(\n",
    "        f'A soma dos temos positivos é: {pos} / A soma dos temos negativos é {neg} / A soma da esquerda para direita é {pos + neg}')\n",
    "\n",
    "\n",
    "def soma_sep_dir_esq():\n",
    "    # adição separada dos termos positivos e dos termos negativos da dirreita para a esquerda\n",
    "    pos = 0\n",
    "    neg = 0\n",
    "    for i in range(10000, 0, -1):\n",
    "        if i % 2 == 0:\n",
    "            neg -= 1 / i\n",
    "        else:\n",
    "            pos += 1 / i\n",
    "    print(\n",
    "        f'A soma dos temos positivos é: {pos} / A soma dos temos negativos é {neg} / A soma da direita para esquerda é {pos + neg}')\n",
    "\n",
    "\n",
    "def main():\n",
    "    soma_dir_esq()\n",
    "    soma_esq_dir()\n",
    "    soma_sep_esq_dir()\n",
    "    soma_sep_dir_esq()\n",
    "\n",
    "\n",
    "main()"
   ]
  }
 ],
 "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.7.7"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {},
   "toc_section_display": true,
   "toc_window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}