Assignments/PT-BR/Assignment_3.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": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "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": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "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": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "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": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "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": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "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": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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
}