05.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Abrindo a caixa de ferramentas\n",
    "\n",
    "Se você chegou até aqui, você já sabe tanto quanto a maior parte dos programadores iniciantes.\n",
    "\n",
    "Que tal saber um pouco mais? 😎\n",
    "\n",
    "## Iterando sobre coleções \n",
    "\n",
    "No roteiro 03, falamos que o `for` pode ter dois usos principais:\n",
    "\n",
    "| Estrutura | Significado |\n",
    "|:----:|:--|\n",
    "| ```for``` | Sabemos quantas vezes queremos executar um código.  <br> Queremos iterar sobre os elementos de uma coleção.|\n",
    "\n",
    "Naquele roteiro, nós estudamos apenas o primeiro uso do `for`. \n",
    "\n",
    "Vamos ver um exemplo do segundo caso:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "pares = {2, 4, 6, 8}\n",
    "for p in pares:\n",
    "    print(p)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> Que loucura foi essa? 😱\n",
    "\n",
    "Vamos entender uma linha de cada vez:\n",
    "1. Em vez de associarmos `pares` a um valor, nós associamos a um **conjunto** de valores (um `set`). Em Python, a notação para criar um `set` é listar os valores separados por vírgulas, delimitados por chaves.\n",
    "2. A cada iteração, o `for` associa a variável `p` a um elemento do conjunto `pares`. Uma característica do `set` é que os elementos não são armazenados em ordem. Assim, a única certeza que temos é que o `for` vai iterar sobre todos os elementos, mas não podemos confiar na ordem dessa iteração!\n",
    "3. A variável `p` pode ser usada dentro do escopo do `for`.\n",
    "\n",
    "> Mas se não temos garantia de ordem, qual a vantagem de usar o `for` assim? 🤔\n",
    "\n",
    "Na verdade, o `set` é apenas um dos exemplos de **coleções** de dados do Python. \n",
    "\n",
    "No caso do `set`, seu uso principal é testar se um elemento existe no conjunto."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "2 in pares"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "1 in pares"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Para adicionar ou remover elementos de um conjunto, usamos as opções `add()` e `remove()`. No entanto, não é possível armazenar valores repetidos em um `set`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "conjunto = {1, 2}\n",
    "conjunto.add(3)\n",
    "conjunto.remove(2)\n",
    "print(conjunto)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "duplicados = {2, 2, 4, 4}\n",
    "print(duplicados)\n",
    "conjunto.add(3)\n",
    "print(conjunto)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Também é possível realizar operações típicas de conjuntos utilizado `sets`, como união, intersecção e diferença. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "impares = {1, 3, 5, 7}\n",
    "impares | pares"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "impares & pares"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "impares - pares"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> `set()` é a forma como o Python representa um conjunto vazio."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercícios de fixação"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "1 - Crie um conjunto `primos` que contenha 5 números primos entre 2 e 100 escolhidos aleatoriamente."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "2 - Crie um conjunto `fibonacci` que contenha 5 números da série de Fibonacci entre 2 e 100 escolhidos aleatoriamente."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "3 - Verifique se algum número sorteado nos exemplos anteriores pertence ao mesmo tempo a `primos` e a `fibonacci`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Coleções associativas"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Um outro tipo de coleção disponível no Python são os **dicionários** (`dict`), que além das operações básicas de conjuntos possuem também a capacidade de **associação**.\n",
    "\n",
    "Em um `dict`, um conjunto de **chaves** (`keys`) está associado a **valores** (`values`). Veja o exemplo abaixo:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "Leonardo = {\"inglês\": \"fluente\", \"espanhol\": \"fluente\", \"italiano\": \"conversa\"}\n",
    "Júlia = {\"inglês\": \"compreende\"}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Chaves:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "for key in Leonardo.keys():\n",
    "    print(key)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Valores:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for value in Leonardo.values():\n",
    "    print(value)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Assim como no exemplo do `set`, não há garantia de ordem ao percorrer os elementos de um `dict`.\n",
    "\n",
    "No entanto, podemos fazer todas as operações de conjuntos sobre `keys`.\n",
    "\n",
    "- Idiomas em comum:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "Leonardo.keys() & Júlia.keys()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Idiomas que Leonardo fala, mas Júlia não fala:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "Leonardo.keys() - Júlia.keys()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Júlia fala espanhol?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "\"espanhol\" in Júlia"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Valores associados"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Além das operações de conjunto sobre as chaves, os valores armazenados em um dicionário podem ser acessados usando a chave correspondente:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "Leonardo[\"inglês\"]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Se buscarmos uma chave que não existe, teremos um erro:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "Leonardo[\"alemão\"]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Também é possível associar uma chave a um novo valor:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "Leonardo[\"italiano\"] = \"conversação\"\n",
    "Leonardo[\"italiano\"]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A operação de associação também aceita novas chaves. \n",
    "\n",
    "Neste caso, estamos acrescentando um novo par chave-valor ao `dict`. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "Leonardo[\"alemão\"] = \"compra na Amazon\"\n",
    "print(Leonardo)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Para remover uma chave, usamos o comando `del`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "del Júlia[\"inglês\"]\n",
    "print(Júlia)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> `{}` é a forma como o Python representa um dicionário vazio."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercícios de fixação"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "1 - Peça ao usuário para informar 10 números entre 0 e 30 e conte quantas vezes cada número foi informado."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "2 - Gere 10 números aleatórios entre 0 e 30 e conte quantas vezes cada número foi gerado."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "3 - Conte quantos números idênticos o usuário e o computador escolheram."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Coleções com ordem"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Nos exemplos de coleções que vimos até aqui, a ordem dos elementos não era preservada.\n",
    "\n",
    "**Por não preservar ordem, conjuntos e dicionários são muito rápidos em suas operações.**\n",
    "\n",
    "Em algumas situações, no entanto, precisamos usar coleções com ordem.\n",
    "\n",
    "Nesse notebook, vamos ver o caso das listas (`list`):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n",
      "5\n",
      "2\n",
      "4\n"
     ]
    }
   ],
   "source": [
    "espera = [3, 5, 2, 4]\n",
    "for pessoa in espera:\n",
    "    print(pessoa)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Em Python, a notação para criar uma `list` é listar os valores separados por vírgulas, delimitados por colchetes.\n",
    "\n",
    "A garantia de ordem das listas abre um novo mundo de possibilidades.\n",
    "\n",
    "Agora podemos, por exemplo, inserir um elemento no meio da lista, inclusive se ele já existir na lista:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[3, 5, 2, 5, 4]"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "espera.insert(3,5)\n",
    "espera"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> Opa, deu errado.. Eu mandei inserir na posição 3 ☹️"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Em linguagens que se prezam, a contagem de posições em uma coleção ordenada começa no índice 0. \n",
    "\n",
    "Podemos acessar posições de uma lista usando colchetes após seu nome:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n"
     ]
    }
   ],
   "source": [
    "print(espera[0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5\n"
     ]
    }
   ],
   "source": [
    "print(espera[1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n"
     ]
    }
   ],
   "source": [
    "print(espera[2])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5\n"
     ]
    }
   ],
   "source": [
    "print(espera[3])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Também é possível remover um elemento de uma determinada posição:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[3, 5, 2, 4]\n"
     ]
    }
   ],
   "source": [
    "espera.pop(3)\n",
    "print(espera)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Acessar posições de uma lista também é chamado de indexar a lista, já que usamos índices para representar as posições.\n",
    "\n",
    "Note que também seria possível iterar sobre os elementos de uma lista usando índices. \n",
    "\n",
    "Podemos fazer isso usando o procedimento `enumerate`, que permite iterar sobre uma lista tendo acesso ao índice e ao elemento ao mesmo tempo:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0: 3\n",
      "1: 5\n",
      "2: 2\n",
      "3: 4\n"
     ]
    }
   ],
   "source": [
    "for índice, valor in enumerate(espera):\n",
    "    print(índice, \": \", valor, sep=\"\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Um outro caso é quando precisamos seguir uma sequência diferente da ordem dos elementos na lista (avançando ou voltando ao longo da iteração). Neste caso, usamos o laço `while` e o procedimento `len`, que calcula o tamanho da lista.\n",
    "\n",
    "O código a seguir testa se uma palavra é um palíndromo, isto é, se ele pode ser lida tanto da esquerda para direita como da direita para esquerda:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> Em Python, um texto pode ser tratado como uma lista de letras! 😱😮😳"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "def palíndromo(palavra):\n",
    "    início = 0\n",
    "    fim = len(palavra) - 1\n",
    "    while início < fim:\n",
    "        if palavra[início] != palavra[fim]:\n",
    "            return False\n",
    "        início += 1\n",
    "        fim -= 1\n",
    "    return True"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "palíndromo(\"reviver\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "palíndromo(\"roma\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Algumas operações são tão comuns em listas que o Python oference um atalho para elas.\n",
    "\n",
    "Pra inserir um elemento no final, por exemplo, temos a opção `append`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "espera.append(7)\n",
    "print(espera)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercícios de fixação"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "1 - Crie uma lista `só_pares` contendo 10 números gerados aleatoriamente entre 0 e 100."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "2 - Processe a lista `só_pares` para que sobrem apenas números pares, utilizando uma sequência de remoções manuais."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "3 - Gere uma nova lista `alternados`, contendo 10 números gerados aleatoriamente entre 0 e 100. Após sua criação, processe a lista `alternados` de forma automatizada para que sobrem apenas números pares."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "4 - Adicione números ímpares gerados aleatoriamente a `alternados`, de forma que após entre dois números pares haja apenas um número ímpar. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercícios do URI"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[1281](https://www.urionlinejudge.com.br/judge/pt/problems/view/1281) - Dona Parcinova costuma ir regularmente à feira para comprar frutas e legumes. Ela pediu então à sua filha, Mangojata, que a ajudasse com as contas e que fizesse um programa que calculasse o valor que precisa levar para poder comprar tudo que está em sua lista de compras, considerando a quantidade de cada tipo de fruta ou legume e os preços destes itens.\n",
    "\n",
    "A primeira linha de entrada contém um inteiro N que indica a quantidade de idas à feira de dona Parcinova (que nada mais é do que o número de casos de teste que vem a seguir). Cada caso de teste inicia com um inteiro M que indica a quantidade de produtos que estão disponíveis para venda na feira. Seguem os M produtos com seus preços respectivos por unidade ou Kg. A próxima linha de entrada contém um inteiro P (1 ≤ P ≤ M) que indica a quantidade de diferentes produtos que dona Parcinova deseja comprar. Seguem P linhas contendo cada uma delas um texto e um valor inteiro, que indicam respectivamente o nome de cada produto e a quantidade deste produto.\n",
    "\n",
    "Para cada caso de teste, imprima o valor que será gasto por dona Parcinova, com 2 casas decimais, conforme o exemplo abaixo."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "|.| Entrada | Saída |\n",
    "|-|:----:|:-:|\n",
    "| *Exemplo 1* | 4<br/>mamao 2.19<br/>cebola 3.10<br/>tomate 2.80<br/>uva 2.73<br/>3<br/>mamao 2<br/>tomate 1<br/>uva 3<br/> | 15.37 | \n",
    "| *Exemplo 2* | 5<br/>morango 6.70<br/>repolho 1.12<br/>brocolis 1.71<br/>tomate 2.80<br/>cebola 2.81<br/>4<br/>brocolis 2<br/>tomate 1<br/>cebola 1<br/>morango 1 | 15.73 | \n",
    "| *Exemplo 3* | 5<br/>ovos 8.45<br/>pão 3.10<br/>bacon 7.32<br/>iogurte 2.47<br/>coalhada 1.75<br/>3<br/>bacon 2<br/>ovos 1<br/>coalhada 4 | 30.09 | "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[1104](https://www.urionlinejudge.com.br/judge/pt/problems/view/1104) - Alice e Beatriz colecionam cartas de Pokémon. As cartas são produzidas para um jogo que reproduz a batalha introduzida em um dos mais bem sucedidos jogos de videogame da história, mas Alice e Beatriz são muito pequenas para jogar, e estão interessadas apenas nas cartas propriamente ditas. Para facilitar, vamos considerar que cada carta possui um identificador único, que é um número inteiro.\n",
    "\n",
    "Cada uma das duas meninas possui um conjunto de cartas e, como a maioria das garotas de sua idade, gostam de trocar entre si as cartas que têm. Elas obviamente não têm interesse emtrocar cartas idênticas, que ambas possuem, e não querem receber cartas repetidas na troca. Além disso, as cartas serão trocadas em uma única operação de troca: Alice dá para Beatriz um sub-conjunto com N cartas distintas e recebe de volta um outro sub-conjunto com N cartas distintas.\n",
    "\n",
    "As meninas querem saber qual é o número máximo de cartas que podem ser trocadas. Por exemplo, se Alice tem o conjunto de cartas {1, 1, 2, 3, 5, 7, 8, 8, 9, 15} e Beatriz o conjunto {2, 2, 2, 3, 4, 6, 10, 11, 11}, elas podem trocar entre si no máximo quatro cartas. Escreva um código que, dados os conjuntos de cartas que Alice e Beatriz possuem, determine o número máximo de cartas que podem ser trocadas.\n",
    "\n",
    "A primeira linha da entrada contém números inteiros representando as cartas do conjunto de Alice, separados por um espaço em branco. A segunda linha contém números inteiros representando as cartas do conjunto de Beatriz. As cartas de Alice e Beatriz são apresentadas em ordem não decrescente.\n",
    "\n",
    "Imprima uma única linha, contendo um numero inteiro, indicando o número máximo de cartas que Alice e Beatriz podem trocar entre si."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "|.| Entrada | Saída |\n",
    "|-|:----:|:-:|\n",
    "| *Exemplo 1* | 1000<br/>1000 | 0 | \n",
    "| *Exemplo 2* | 1 3 5<br/>2 4 6 8 | 3 | \n",
    "| *Exemplo 3* | 1 1 2 3 5 7 8 8 9 15<br/>2 2 2 3 4 6 10 11 11 | 4 | "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[1110](https://www.urionlinejudge.com.br/judge/pt/problems/view/1110) - Piotr é um canadense gente boa que veio morar no Brasil e nas horas vagas gosta de jogar cartas.\n",
    "\n",
    "Um dos jogos preferidos dele é o de adivinhar qual carta vai ficar por último no baralho, considerando as seguintes condições:\n",
    "- o deck de cartas contém apenas cartas de números. Se o deck tiver n cartas, essas cartas estarão numeradas de 1 a n e ordenadas, com a carta 1 no topo e a carta n no fundo. \n",
    "- a carta descartada é a que estiver no topo.\n",
    "- quando uma carta for descartada, a carta seguinte deverá ser movida para o fim do deck.\n",
    "\n",
    "Escreva um código que ajude os amigos de Piotr a derrotá-lo, descobrindo qual carta ficará por último no baralho.\n",
    "\n",
    "A entrada será um número que indicará quantas cartas têm no deck. A saída deverá ter duas linhas. Na primeira, informe as cartas descartadas, na sequência em que elas forem descartadas. Na segunda, informe a carta que ficou por último no deck."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "|.| Entrada | Saída |\n",
    "|-|:----:|:-:|\n",
    "| *Exemplo 1* | 7 | 1 3 5 7 4 2<br/>6 | \n",
    "| *Exemplo 2* | 10 | 1 3 5 7 9 2 6 10 8<br/>4 |\n",
    "| *Exemplo 3* | 6 | 1 3 5 2 6<br/> 4 | "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercícios do UVa"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[10226](https://uva.onlinejudge.org/index.php?option=onlinejudge&page=show_problem&problem=1167) - Madeira de lei é o grupo botânico de árvores que têm folhas largas, produzem um fruto ou uma noz e geralmente hibernam no inverno. O carvalho e a cerejeira, por exemplo, são tipos de madeira de lei, mas são de diferentes espécies. \n",
    "\n",
    "Usando tecnologia de mapeamento por satélite, o Departamento de Recursos Naturais catalogou todas as árvores existentes. Você precisa calcular o percentual que uma determinada espécie representa em relação à população inteira de árvores.\n",
    "\n",
    "A entrada consiste de uma lista de espécies observadas pelo satélite, uma árvore por linha. \n",
    "\n",
    "Seu código deverá imprimir o nome de cada espécie e seu percentual em relação à população total, considerando 4 casas decimais."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "|.| Entrada | Saída |\n",
    "|-|:----:|:-:|\n",
    "| *Exemplo 1* | Red Alder<br/>Ash<br/>Aspen<br/>Basswood<br/>Ash<br/>Beech<br/>Yellow Birch<br/>Ash<br/>Beech<br/>Cottonwood | Red Alder 10.0000<br/>Ash 30.0000<br/>Aspen  10.0000<br/>Basswood 10.0000<br/>Beech 20.0000<br/>Yellow Birch 10.0000<br/>Cottonwood 10.0000 | \n",
    "| *Exemplo 2* | White Oak<br/>Hickory<br/>Pecan<br/>Hard Maple<br/>White Oak<br/>Soft Maple<br/>Red Oak<br/>Red Oak<br/>White Oak | White Oak 33.3333<br/>Hickory 11.1111<br/>Pecan 11.1111<br/>Hard Maple 11.11111<br/>Soft Maple 11.1111<br/>Red Oak 22.2222 |\n",
    "| *Exemplo 3* | Ash<br/>Cypress<br/>Red Elm<br/>Gum<br/>Hackberry<br/>Poplan<br/>Sassafras | Ash 0.1428<br/>Cypress 0.1428<br/>Red Elm 0.1428<br/>Gum 0.1428<br/>Hackberry 0.1428<br/>Poplan 0.1428<br/>Sassafras 0.1428 | "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[11849](https://uva.onlinejudge.org/index.php?option=com_onlinejudge&Itemid=8&page=show_problem&problem=2949) - Jack e Jill decidiram vender alguns dos seus livros. Eles decidiram que só vão vender os livros que os dois têm em comum. De cada livro, Jack possui no máximo uma cópia, assim como Jill. Quantos livros Jack e Jill podem vender?\n",
    "\n",
    "Escreva um código que receba como entrada os livros de Jack em uma linha, identificados por um número e separados por espaço. A linha seguinte segue o mesmo padrão e informa os livros de Jill.\n",
    "\n",
    "Seu código deverá informar quantos livros Jack e Jill têm em comum."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "|.| Entrada | Saída |\n",
    "|-|:----:|:-:|\n",
    "| *Exemplo 1* | 1 2 3<br/>1 2 4 | 2 | \n",
    "| *Exemplo 2* | 4 8 1 3 2<br/>2 4 6 8 | 3 | \n",
    "| *Exemplo 3* | 5 4 2 3 7 12 9 15<br/>2 6 11 10 9 5 4 3 | 4 | "
   ]
  },
  {
   "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.6.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}