Assignments/PT-BR/Assignment_5.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**1)** A função `favoritos()` recebe como argumentos uma lista `l` de inteiros e dois sets `A` e `B`, também de inteiros. Você gosta dos inteiros de `A` e não gosta dos inteiros de `B`. Sua felicidade inicial é zero. Para cada `i` em `l`, acrescente `1` à sua felicidade se `i` pertence a `A`, e remova `1` de sua felicidade caso ele pertenca a `B`. Retorne ao final o valor de sua felicidade. Veja exemplo:\n",
    "\n",
    ">```python\n",
    ">>>> favoritos([1,2,3,4,5,6,7],{1,3,5,7},{1,2,4,8})\n",
    ">1\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**2)** Implemente a classe `Eletronico` com os atributos `marca`, `ano_compra` e `preco`, representando respectivamente, a marca do produto, seu ano de compra do objeto e o preço de pago na compra, em reais.\n",
    "\n",
    "Crie uma subclasse chamada `Smartphone` com novos atributos: `modelo`, `tela`, e `memoria` (além dos anteriores) representando o modelo do telefone, o tamanho da tela em polegadas, e o armazenamento interno em GB.\n",
    "\n",
    "Aparelhos eletrônicos e outros objetos em geral, sofrem a chamada depreciação, que é a perda de valor ao longo do tempo. Com isso, ao tentar revender um celular usado, dificilmente se obtém lucro. Considere que um smartphone perde 10% de valor ao ano (compostos). Dentro da classe `Smartphone` implemente uma função `venda`que recebe o ano de venda do aparelho e retorne o preço depreciado à taxa de 10% a.a.\n",
    "\n",
    "Exemplo:\n",
    "\n",
    ">```python\n",
    ">>>> celular1 = Smartphone(\"MarcaX\",2019,2000,\"ModeloY\",5.5,64)\n",
    ">>>> celular1.venda(2020)\n",
    "> 1800\n",
    "\n",
    "\n",
    "Obs: Use a fórmula dos juros compostos para calcular a depreciação, com taxa $i = -0.1$\n",
    "\n",
    "$M = C (1+i)^t$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**3)** A função `GetInfo()` recebe como parâmetros dois sets e devolve um dicionário. Seu trabalho é fazer com que cada item desse dicionário corresponda corretamente ao solicidado no código comentado, substituindo os valores `None` de cada um dos elementos do dicionário pelo devido código. Dica: é possível resolver cada item usando apenas uma operação de sets, sem precisar de loops ou variáveis adicionais. Veja exemplo:\n",
    "\n",
    ">```python\n",
    ">>>> a={1,3,\"Teste\",\"LP\"}\n",
    ">>>> b={2,3,\"LP\"}\n",
    ">>>> GetInfo(a,b)\n",
    ">{'intersection': {3, 'LP'}, 'union': {1, 2, 3, 'LP', 'Teste'}, 'JustA': {1, 'Teste'}, 'symetricDifference': {1, 2, 'Teste'}, 'a_sub_b': False, 'LPinA': True, 'NoCommonElements': False}\n",
    ">```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "def GetInfo(a,b):\n",
    "    return {\n",
    "        \"intersection\" : None , # Set -> Interseção dos dois sets\n",
    "        \"union\" : None , # Set -> União dos dois sets\n",
    "        \"JustA\" : None , # Set -> Elementos que estão em A e não estão em B\n",
    "        \"symetricDifference\" : None , # Set -> Diferênça simétrica de A e B, ou seja, elementos que pertencem a um deles, mas não à interseção.\n",
    "        \"a_sub_b\" : None , # Booleano -> se A é subconjunto de B\n",
    "        \"LPinA\" : None , # Booleano -> se a string \"LP\" está em A\n",
    "        \"NoCommonElements\" : None # Booleano -> Se A e B sãão conjuntos disjuntos \n",
    "    }"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**4)** A função `primos()` deve receber como único argumento um número inteiro e retornar um set dos números primos menores ou iguais a esse número. Para realizar essa tarefa, poderíamos montar a função de diversas formas. No nosso caso, vamos tomar uma abordagem um pouco mais esperta usando sets. No bloco a seguir, há um pseudocódigo que você deve seguir para implementar a questão.\n",
    "\n",
    ">```\n",
    ">função primos(N)\n",
    ">\n",
    ">    # Inicialização:\n",
    ">    primos <- set com todos os números de 2 a N\n",
    ">    p <- 2\n",
    ">\n",
    ">    # Encontrando os primos:\n",
    ">    enquanto p no intervalo [2,N]\n",
    ">\n",
    ">        # Encontra próximo primo\n",
    ">        enquanto p não está em primos e p está em [2,N]\n",
    ">            incremente p em uma unidade\n",
    ">        # Nesse ponto, p é primo\n",
    ">\n",
    ">        # Remoção dos múltiplos de p\n",
    ">        k <- p + p\n",
    ">        enquanto k menor ou igual a N\n",
    ">            remova k de primos\n",
    ">            k <- k + p\n",
    ">\n",
    ">        # Parta para próximo p\n",
    ">        incremente p em uma unidade\n",
    ">\n",
    ">    # Finalização\n",
    ">    # Nesse ponto, 'primos' contém apenas os primos\n",
    ">    retorne o set primos\n",
    ">\n",
    ">```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**5)** O conjunto das partes de um conjunto A é definido como o conjunto de todos os subconjuntos de A. Por exemplo, o conjunto das partes de {1, 2} é { { }, {1}, {2}, {1,2} }. Crie a função `partes(A)` de forma que ela receba um objeto set A, e retorne o conjuntos das partes de A, como um set de sets. Para todos os sets que for ultilizar, ultilize um chamado `frozenset`, que por ter estrutura rigida, vai permitir a criação de um set de sets. Dica: você pode usar a `combinations` que fez parte de uma lista anterior, ou mesmo a função `combinations` do pacote `itertools`, que coincidentemente equivale à função implementada mencionada ;)\n",
    "Segue o exemplo:\n",
    "\n",
    ">```python\n",
    ">>>> A = frozenset({1,2})\n",
    ">>>> partes(A)\n",
    "> frozenset({frozenset(), frozenset({2}), frozenset({1}), frozenset({1, 2})})\n",
    ">>>> B = frozenset({2,4,6,8})\n",
    ">>>> partes(B)\n",
    "> frozenset({frozenset({2, 4, 6}), frozenset({2}), frozenset({4}), frozenset({4, 6}), frozenset({8, 2}), frozenset({2, 6}), frozenset({8}), frozenset({8, 2, 6}), frozenset({2, 4}), frozenset({6}), frozenset({8, 4, 6}), frozenset({8, 6}), frozenset(), frozenset({8, 2, 4}), frozenset({8, 2, 4, 6}), frozenset({8, 4})})\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Desafio\n",
    "\n",
    "**6)** A classe `Complexo` é um objeto que representa um número com, respectivamente, parte real e imaginária. Além do construtor, vocẽ deve programar os métodos `__add__`, `__sub__`, `__mul__`, `__truediv__`, `__abs__` e `__str__`. Todos esses métodos são chamados \"built-in\", que são usados pelos interpretadores como funções internas. Isso significa que, após implementar o `__add__`, por exemplo, você conseguira executar `a + b` onde `a` e `b` são objetos do tipo `Complexo`. Desta forma, temos:\n",
    "\n",
    " * `__add__` -> (+; retorna um objeto Complexo)\n",
    " * `__sub__` -> (-; retorna um objeto Complexo)\n",
    " * `__mul__` -> (*; retorna um objeto Complexo)\n",
    " * `__truediv__` -> (/; retorna um objeto Complexo)\n",
    " * `__abs__` -> (abs(); valor absoluto do número, que no caso de complexos do tipo 'A + Bi é dado por sqrt(A^2 + B^2); retorna um valor float arredondado para duas casas decimais [olhe a função round()])\n",
    " * `__str__` -> (str(); conversão para string no formato \"A + Bi\" ou \"A - Bi\", onde A e B devem ser ajustados para duas casas decimais; retorna uma string)\n",
    " \n",
    "Com tudo devidamente implementado, deve ser possível executar o seguinte bloco de código:\n",
    "\n",
    ">```python\n",
    ">>>> x = Complexo(3,2)\n",
    ">>>> y = Complexo(4,-5)\n",
    ">>>> str(x)\n",
    ">'3.00+2.00i'\n",
    ">>>> str(x+y)\n",
    ">'7.00-3.00i'\n",
    ">>>> str(x-y)\n",
    ">'-1.00+7.00i'\n",
    ">>>> str(y-x)\n",
    ">'1.00-7.00i'\n",
    ">>>> str(x*y)\n",
    ">'22.00-7.00i'\n",
    ">>>> str(x/y)\n",
    ">'0.05+0.56i'\n",
    ">>>> abs(y)\n",
    ">6.4\n",
    ">>> abs(x)\n",
    ">3.61\n",
    ">```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Complexo(object):\n",
    "    def __init__(self, real, imaginario):\n",
    "        #Seu Código Aqui\n",
    "\n",
    "    def __add__(self, no):\n",
    "        #Seu Código Aqui\n",
    "\n",
    "    def __sub__(self, no):\n",
    "        #Seu Código Aqui\n",
    "\n",
    "    def __mul__(self, no):\n",
    "        #Seu Código Aqui\n",
    "\n",
    "    def __truediv__(self, no):\n",
    "        #Seu Código Aqui\n",
    "\n",
    "    def __abs__(self):\n",
    "        #Seu Código Aqui\n",
    "\n",
    "    def __str__(self):\n",
    "        #Seu Código Aqui"
   ]
  }
 ],
 "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.8.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}