Assignments/PT-BR/Assignment_3_Solutions.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "1) Programe a função **swap()**, que recebe duas tuplas **a** e **b**, com dois elementos cada. Seu código deve fazer com que os últimos elementos das duas tuplas sejam trocados, e então retornar as duas tuplas."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "((1, 4), (3, 2))\n"
     ]
    }
   ],
   "source": [
    "def swap(a,b):\n",
    "    a0, a1 = a\n",
    "    b0, b1 = b\n",
    "    return ((a0, b1),(b0,a1))\n",
    "\n",
    "print(swap((1,2),(3,4)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "2) Crie a função **dist()** que recebe como argumento duas tuplas que representam coordenadas cartesianas de dois pontos. Sua função deve retornar um número que corresponde à distância cartesiana entre esses dois pontos."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "7.0710678118654755\n"
     ]
    }
   ],
   "source": [
    "def dist(p1,p2):\n",
    "    d=((p1[0]-p2[0])**2+(p1[1]-p2[1])**2)**(0.5)\n",
    "    return d\n",
    "\n",
    "print(dist((2,4),(-5,3)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "3) A classe bola representa uma esfera cheia de água (com peso 1000g por metro cubico) com um raio **r** e superfície coberta com tinta ou azul (peso 1g por metro quadrado) ou amarelo (2g por metro quadrado) ou vermelho (3g por m quadrado). O parâmetro da classe é uma tupla **(r, cor)**, respectivamente inteiro e string. O método **peso()** da classe deve retorna o peso total em kg da bola (o peso da água com o peso externo da superfície). Veja exemplo:\n",
    "\n",
    ">```python\n",
    ">>>> bola((2, \"vermelho\")).peso()\n",
    "> 33.66111808566343\n",
    ">\n",
    ">>>> bola((3, \"azul\")).peso()\n",
    "> 113.21043286476177\n",
    "\n",
    "Obs: \n",
    "- Use $\\pi$ = 3.14159\n",
    "- Volume da esfera: $\\frac43 \\pi r^3$\n",
    "- Área da Superfície: $4\\pi r^2$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "268.4844701866666\n"
     ]
    }
   ],
   "source": [
    "class bola:\n",
    "    def __init__(self,tupla):\n",
    "        pi = 3.14159\n",
    "        self.r,self.cor = tupla\n",
    "        self.volume=(4/3)*pi*(self.r**3)\n",
    "        self.area_superf=4*pi*(self.r**2)\n",
    "\n",
    "    def peso(self):\n",
    "        peso_int= self.volume #peso interno em kg (1m³ = 1kg)\n",
    "        peso_ext=0  #será calculado de acordo com a cor\n",
    "        if self.cor == \"azul\":\n",
    "            peso_ext = self.area_superf*1/1000 # 1g/m²\n",
    "        elif self.cor == \"amarelo\":\n",
    "            peso_ext = self.area_superf*2/1000 # 2g/m²\n",
    "        elif self.cor == \"vermelho\":\n",
    "            peso_ext = self.area_superf*3/1000 # 3g/m²\n",
    "        return peso_ext+peso_int\n",
    "\n",
    "print(bola((4,'amarelo')).peso())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "4) Números romanos são ocasionalmente utilizados para marcações temporais ou outras finalidades, porém sua conversão manual é um tanto trabalhosa. Sua tarefa é implementar duas funções, ***int\\_to\\_Roman()*** que converte um número inteiro para romano (em string) e **Roman\\_to\\_int()** que faz o inverso. Veja exemplos abaixo:\n",
    "\n",
    ">```python\n",
    ">>>> int_to_Roman(1)\n",
    "> I\n",
    ">>>> int_to_Roman(3000)\n",
    "> MMM\n",
    ">\n",
    ">>>> Roman_to_int('MMMCMLXXXVI')\n",
    "> 3986\n",
    ">>>> Roman_to_int('C')\n",
    "> 100\n",
    "\n",
    "Obs: Todos os casos de teste serão menores que 4000, portanto não precisa se preocupar com os caracteres com barras em cima utilizados em algumas versões do sistema de numeração romana."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CXXVII\n"
     ]
    }
   ],
   "source": [
    "def int_to_Roman(num):\n",
    "    val = [1000, 900, 500, 400,\n",
    "           100, 90, 50, 40,\n",
    "           10, 9, 5, 4, 1]\n",
    "    syb = [\"M\", \"CM\", \"D\", \"CD\",\n",
    "           \"C\", \"XC\", \"L\", \"XL\",\n",
    "           \"X\", \"IX\", \"V\", \"IV\", \"I\"]\n",
    "    roman_num, i = '', 0\n",
    "    while  num > 0:\n",
    "        for _ in range(num // val[i]):\n",
    "            roman_num += syb[i]\n",
    "            num -= val[i]\n",
    "        i += 1\n",
    "    return roman_num\n",
    "\n",
    "print(int_to_Roman(127))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "18\n"
     ]
    }
   ],
   "source": [
    "def Roman_to_int(s):\n",
    "    rom_val = {'I': 1, 'V': 5, 'X': 10, 'L': 50, 'C': 100, 'D': 500, 'M': 1000}\n",
    "    int_val = 0\n",
    "    for i in range(len(s)):\n",
    "        if i > 0 and rom_val[s[i]] > rom_val[s[i - 1]]:\n",
    "            int_val += rom_val[s[i]] - 2 * rom_val[s[i - 1]]\n",
    "        else:\n",
    "            int_val += rom_val[s[i]]\n",
    "    return int_val\n",
    "\n",
    "print(Roman_to_int('XVIII'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "5) A função **area()** recebe uma lista **l** de pares ordenados. Esses pares ordenado representam  os vértices de um polígono convexo no plano cartesiano percorridos em um sentido único (permitindo usar o método a seguir). Existe um método que, dadas as coordenadas dos vértices de um polígono, permite calcular a área do mesmo operando um determinante. Você pode encontrar mais detalhes sobre o método clicando [aqui](http://www.profcardy.com/cardicas/como-obter-area-de-poligono-por-coordenadas.php). Seu código deve fazer com que o retorno da função seja o número a que corresponde a área do polígono representado pela entrada (arredonde para duas casas decimais). Vide exemplos a seguir:\n",
    "\n",
    ">```python\n",
    ">>>> area([(0,0),(5,0),(13,8)])\n",
    "> 20.00\n",
    ">\n",
    ">>>> area([(2,0),(6,0),(10,4),(0,4)])\n",
    "> 28.00\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5.08\n"
     ]
    }
   ],
   "source": [
    "def area(l):\n",
    "    l.append(l[0])\n",
    "    acum=0\n",
    "    for i in range(len(l)-1):\n",
    "        acum = acum + l[i][0]*l[i+1][1] - l[i][1]*l[i+1][0]\n",
    "    a=abs(acum/2)\n",
    "    return round(a,2)\n",
    "\n",
    "print(area([(0,0),(1,0),(2,4.15),(0,3)]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Desafio\n",
    "\n",
    "6) A função **combina()** recebe uma lista **l** de números inteiros distintos ordenados e um inteiro **n**. Sua implementação deve fazer com que ela retorne uma lista de tuplas, cada tupla com **n** elementos, contendo todas as possíveis combinações **n** a **n** dos elementos da lista **l**. Você deve retornar apenas uma lista **r** contento as tuplas geradas. Garanta que as tuplas estejam ordenadas na lista. Veja os exemplos abaixo:\n",
    "\n",
    ">```python\n",
    ">>>> combina([1,2,3,4],2)\n",
    "> [(1,2),(1,3),(1,4),(2,3),(2,4),(3,4)]\n",
    ">\n",
    ">>>> combina([1,2,3,4],3)\n",
    "> [(1, 2, 3), (1, 2, 4), (1, 3, 4), (2, 3, 4)]\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[(1, 2), (1, 3), (2, 3)]\n"
     ]
    }
   ],
   "source": [
    "def combina(l,n):\n",
    "    def gen(iterable, r):\n",
    "        # gen('ABCD', 2) --> AB AC AD BC BD CD\n",
    "        # gen(range(4), 3) --> 012 013 023 123\n",
    "        pool = tuple(iterable)\n",
    "        n = len(pool)\n",
    "        if r > n:\n",
    "            return\n",
    "        indices = list(range(r))\n",
    "        yield tuple(pool[i] for i in indices)\n",
    "        while True:\n",
    "            for i in reversed(range(r)):\n",
    "                if indices[i] != i + n - r:\n",
    "                    break\n",
    "            else:\n",
    "                return\n",
    "            indices[i] += 1\n",
    "            for j in range(i+1, r):\n",
    "                indices[j] = indices[j-1] + 1\n",
    "            yield tuple(pool[i] for i in indices)\n",
    "    c=[el for el in gen(l, n)]\n",
    "    return c\n",
    "\n",
    "print(combina([1,2,3],2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      ".......\n",
      "----------------------------------------------------------------------\n",
      "Ran 7 tests in 0.006s\n",
      "\n",
      "OK\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<unittest.main.TestProgram at 0x7f06a0504bb0>"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import itertools, unittest\n",
    "\n",
    "class UnitTests(unittest.TestCase):\n",
    "    \n",
    "    def test_swap(self):\n",
    "        self.assertEqual(swap((1,5),(9,0)),((1,0),(9,5)))\n",
    "        self.assertEqual(swap((17,8),(1,13)),((17,13),(1,8)))\n",
    "        self.assertEqual(swap((91,49),(36,25)),((91,25),(36,49)))\n",
    "\n",
    "    def test_area(self):\n",
    "        l1=[(9,5),(5,6),(3,7),(1,6),(0,3),(1,1),(4,0),(9,1)]\n",
    "        l2=[(1,-4),(-4,-5),(-6,-4),(-6,0),(-5,4),(-3,6),(1,8),(5,7),(8,2),(5,-2)]\n",
    "        l3=[(3,10),(7,5),(2,1),(-3,0),(-5,3),(-3,8),(-1,10)]\n",
    "        self.assertEqual(area(l1),46.5)\n",
    "        self.assertEqual(area(l2),127)\n",
    "        self.assertEqual(area(l3),78.5)\n",
    "\n",
    "    def test_bola(self):\n",
    "        class bola2:\n",
    "            def __init__(self,tupla):\n",
    "                pi = 3.14159\n",
    "                self.r,self.cor = tupla\n",
    "                self.volume=(4/3)*pi*(self.r)**3\n",
    "                self.area_superf=4*pi*(self.r)**2\n",
    "            def peso(self):\n",
    "                peso_int= self.volume\n",
    "                peso_ext=0\n",
    "                if self.cor == \"azul\":\n",
    "                    peso_ext = self.area_superf*1/1000\n",
    "                elif self.cor == \"amarelo\":\n",
    "                    peso_ext = self.area_superf*2/1000\n",
    "                else: \n",
    "                    peso_ext = self.area_superf*3/1000\n",
    "                return peso_ext+peso_int\n",
    "        self.assertAlmostEqual(bola((2,'azul')).peso(),bola2((2,'azul')).peso(),delta=0.3)\n",
    "        self.assertAlmostEqual(bola((4,'azul')).peso(),bola2((4,'azul')).peso(),delta=0.3)\n",
    "        self.assertAlmostEqual(bola((5,'vermelho')).peso(),bola2((5,'vermelho')).peso(),delta=0.3)\n",
    "        self.assertAlmostEqual(bola((10,'vermelho')).peso(),bola2((10,'vermelho')).peso(),delta=0.3)\n",
    "        self.assertAlmostEqual(bola((5,'amarelo')).peso(),bola2((5,'amarelo')).peso(),delta=0.3)\n",
    "        self.assertAlmostEqual(bola((10,'amarelo')).peso(),bola2((10,'amarelo')).peso(),delta=0.3)\n",
    "\n",
    "    def test_int_to_Roman(self):\n",
    "        self.assertEqual(int_to_Roman(1997),'MCMXCVII')\n",
    "        self.assertEqual(int_to_Roman(2222),'MMCCXXII')\n",
    "        self.assertEqual(int_to_Roman(1443),'MCDXLIII')\n",
    "        self.assertEqual(int_to_Roman(101),'CI')\n",
    "        self.assertEqual(int_to_Roman(999),'CMXCIX')\n",
    "\n",
    "    def test_Roman_to_int(self):\n",
    "        self.assertEqual(1997,Roman_to_int('MCMXCVII'))\n",
    "        self.assertEqual(2222,Roman_to_int('MMCCXXII'))\n",
    "        self.assertEqual(1443,Roman_to_int('MCDXLIII'))\n",
    "        self.assertEqual(101,Roman_to_int('CI'))\n",
    "        self.assertEqual(999,Roman_to_int('CMXCIX'))\n",
    "\n",
    "    def test_dist(self):\n",
    "        self.assertAlmostEqual(dist((3,2),(5,-1)),13**(0.5),delta=0.3)\n",
    "        self.assertAlmostEqual(dist((6,1),(-7,-10)),290**(0.5),delta=0.3)\n",
    "        self.assertAlmostEqual(dist((13,20),(17,0)),4*26**(0.5),delta=0.3)\n",
    "        self.assertAlmostEqual(dist((4,0),(0,2)),2*5**(0.5),delta=0.3)\n",
    "        self.assertAlmostEqual(dist((8,9),(2,2)),85**(0.5),delta=0.3)\n",
    "        \n",
    "    def test_combina(self):\n",
    "        l1,n1 = [0,1,3,4,6,8,9],3\n",
    "        l2,n2 = [1,2,5,6,7,9,13,17,21], 5\n",
    "        l3,n3 = [0,10,14,16,21,33,67,91,153,205],2\n",
    "        self.assertEqual(combina(l1,n1),[el for el in itertools.combinations(l1, n1)])\n",
    "        self.assertEqual(combina(l2,n2),[el for el in itertools.combinations(l2, n2)])\n",
    "        self.assertEqual(combina(l3,n3),[el for el in itertools.combinations(l3, n3)])\n",
    "    \n",
    "\n",
    "unittest.main(argv=['first-arg-is-ignored'], exit=False)"
   ]
  }
 ],
 "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
}