03.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<small><small><i>\n",
    "Este notebook foi baseado nos notebooks disponíveis em [https://gitlab.erc.monash.edu.au/andrease/Python4Maths.git]\n",
    "</i></small></small>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Repetindo sem perder o controle!\n",
    "\n",
    "Python permite que um trecho de código seja executado múltiplas vezes **estruturas de repetição**. \n",
    "\n",
    "Pra não perder o controle do seu código e cair em um loop infinito, estruturas de repetição se baseiam em **condições de parada**.\n",
    "\n",
    "Neste roteiro, você aprenderá a utilizar estes conceitos da linguagem Python.\n",
    "\n",
    "## Estruturas de repetição\n",
    "\n",
    "Muitas vezes, é necessário executar um mesmo trecho de código várias vezes:\n",
    "* Quando um sistema pede uma senha ao usuário, mas ele tem uma certa quantidade de tentativas possívels.\n",
    "* Quando queremos cadastrar múltiplos contatos em uma agenda.\n",
    "* Quando estamos calculando a média de várias avaliações de uma disciplina.\n",
    "\n",
    "Em todas essas situações, precisamos repetir um trecho de código **sem cair em um loop infinito**. Há três situações comuns:\n",
    "* Sabemos quantas vezes queremos executar um código.\n",
    "* Queremos executar um código enquanto uma condição for verdadeira.\n",
    "* Queremos executar um código até que determinada situação aconteça.\n",
    "\n",
    "Python oferece duas estruturas de repetição, que podem ser usadas nas situações descritas acima:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "| Estrutura | Significado |\n",
    "|:----:|:--|\n",
    "| ```for``` | Sabemos quantas vezes queremos executar um código.  <br> Queremos iterar sobre os elementos de uma coleção.|\n",
    "| ```while```  | Queremos executar um código até que determinada situação aconteça. <br> Queremos executar um código enquanto uma condição for verdadeira. |"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## A estrutura ```for```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Quando sabemos quantas vezes queremos executar um código, a estrutura de repetição ```for``` deve ser nossa escolha:\n",
    "\n",
    "```python\n",
    "for iterador in intervalo:\n",
    "    expressao\n",
    "    expressao\n",
    "    ...\n",
    "```\n",
    "\n",
    "As regras básicas para o uso da estrutura **for** em Python são:\n",
    "\n",
    "* O trecho de código delimitado por uma estrutura **for** é chamado bloco e deve ser identado.\n",
    "* O procedimento **range(inicio, fim)** permite definir um intervalo de valores que a variavel **iterador** pode assumir durante a execução do ```for```. \n",
    "\n",
    "O exemplo abaixo mostra como esta estrutura pode ser usada para que um código seja repetido por 5 vezes:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "for i in range(0,5):\n",
    "    print(\"Execução\", i+1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note que a função range define intervalos do tipo **[início, fim)**, isto é, valores maiores ou iguais a **início** e menores que **fim**.\n",
    "\n",
    "Também é possível definir intervalos mais elaborados, criando séries com diferentes crescimentos ou até mesmo decréscimos:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# Série crescedo de 2 em 2\n",
    "for i in range(0,5,2):\n",
    "    print(\"Valor de i:\", i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# Série decrescendo de 5 em 5\n",
    "for i in range(15,-20,-5):\n",
    "    print(\"Valor de i:\", i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercícios de fixação"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "1 - Peça ao usuário suas notas das 3 unidades de uma disciplina e calcule sua média."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "2 - Solicite ao usuário um inteiro positivo *n* e imprima a soma dos números pares entre 0 e *n*."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "3 - Analise os números entre -25 e 50. Se o número for múltiplo de 2, imprima BUS. Se for múltiplo de 3, imprima FEES. Caso seja múltiplo de 2 e de 3 ao mesmo tempo, imprima BUS e FEES."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "4 - Solicite ao usuário um inteiro positivo *n* e calcule o fatorial de *n*."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## A estrutura ```while```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Quando queremos executar um código enquanto uma condição for verdadeira, a estrutura de repetição ```while``` deve ser nossa escolha:\n",
    "\n",
    "```python\n",
    "while condicao:\n",
    "    expressao\n",
    "    expressao\n",
    "    ...\n",
    "```\n",
    "\n",
    "As regras básicas para o uso da estrutura **while** em Python são:\n",
    "\n",
    "* O trecho de código delimitado por uma estrutura **while** é chamado bloco e deve ser identado.\n",
    "* O bloco delimitado por uma estrutura **while** será executado enquanto a expressão lógica (```condicao```) for verdadeira (```True```).\n",
    "\n",
    "Um exemplo de uso desta estrutura é o caso em que não se sabe quantas vezes será necessário executar um trecho de código:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "from random import randint\n",
    "\n",
    "n_multiplos = 0\n",
    "while n_multiplos < 3:\n",
    "    numero = randint(0,30)\n",
    "    if numero % 3 == 0:\n",
    "        n_multiplos += 1\n",
    "        print(\"Múltiplo #\", n_multiplos, \"-\", numero)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Também é possível utilizar a estrutura de repetição ```while``` quando queremos executar um código até que uma determinada situação ocorra:\n",
    "\n",
    "```python\n",
    "while True:\n",
    "    expressao\n",
    "    expressao\n",
    "    ...\n",
    "    if condicao:\n",
    "        break\n",
    "```\n",
    "\n",
    "As regras básicas para o uso da estrutura **while** neste contexto são:\n",
    "\n",
    "* O bloco será executado uma ou mais vezes, até que a condição se torne verdadeira.\n",
    "* O comando **```break```** provoca a interrupção da repetição.\n",
    "\n",
    "O exemplo abaixo mostra como esta estrutura pode ser usada para solicitar uma senha ao usuário até que ele acerte a senha:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "senha_correta = \"swordfish\"\n",
    "while True:\n",
    "    senha = input(\"Informe sua senha: \")\n",
    "    if senha == senha_correta:\n",
    "        break\n",
    "    else:\n",
    "        print(\"Senha incorreta!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercícios de fixação"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "1 - Sorteie um número entre 0 e 10 e peça ao usuário para tentar adivinhá-lo. Quando o usuário acertar o número, informe quantas tentativas foram necessárias."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Pulando parte do código\n",
    "\n",
    "É possível evitar que parte do código seja executada durante uma repetição utilizando o comando ```continue```.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "soma = 0\n",
    "for i in range(10):\n",
    "    if i == 3:\n",
    "        continue\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercícios de fixação"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "1 - Imprima os números partes entre 0 e 50, pulando os números múltiplos de 4. Use o comando ```continue```."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Combinando múltiplas estruturas de repetição"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Assim como vimos para estruturas de decisão, também podemos combinar estruturas de repetição em múltiplos níveis. \n",
    "\n",
    "As regras básicas para **aninhar estruturas de repetição** em Python são:\n",
    "* Não há limite com relação a quantas estruturas e em quantos níveis.\n",
    "* Blocos de níveis mais profundos devem apresentar maior grau de identação.\n",
    "* Os efeitos dos comandos ```break``` e ```continue``` se limitam ao nível atual.\n",
    "\n",
    "O exemplo abaixo mostra como imprimir uma matriz identidade. Note que a função ```print``` pode ser usada para imprimir várias vezes em uma mesma linha, utilizando pra isso a opção ```end```."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "for i in range(3):\n",
    "    for j in range(3):\n",
    "        if i == j:\n",
    "            print(\" 1 \", end='')\n",
    "        else:\n",
    "            print(\" 0 \", end='')\n",
    "    print()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "## Exercícios do URI"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "[1080](https://www.urionlinejudge.com.br/judge/pt/problems/view/1080) - Calcular estatísticas é uma importante tarefa dos sistema de computação que trabalham com análise de dados. Em um roteiro anterior, você implementou uma função para uso em histogramas, que informava a qual intervalo um elemento pertencia.\n",
    "\n",
    "Neste exercício, você vai voltar pro mundo real e de fato preparar um histograma dos dados (colher de chá: não precisa gerar o gráfico no final).\n",
    "\n",
    "Escreva um código Python que receba um inteiro informando quantos números no intervalo \\[0,100\\) serão informados a seguir. Considerando 5 subintervalos de igual tamanho, seu programa deverá calcular a frequência de elementos presentes em cada subintervalo.\n",
    "\n",
    "Por fim, seu programa deverá informar os elementos máximo e mínimo encontrados nos dados, e suas posições na sequência dos dados de entrada."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "|.| Entrada | Saída |\n",
    "|-|:----:|---|\n",
    "| *Exemplo 1* | 5<br/>100<br/>40<br/>32<br/>87<br/>90 | \\[0,20\\) - 1 <br/> \\[20,40\\) - 1 <br/> \\[40,60\\) - 1 <br/> \\[60,80\\) - 0 <br/> \\[80,100\\) - 3  <br/> Máximo: 100 (0) <br/> Mínimo: 32 (2) | \n",
    "| *Exemplo 2* | 3<br/>12<br/>29<br/>45 | \\[0,20\\) - 1 <br/> \\[20,40\\) - 1 <br/> \\[40,60\\) - 1 <br/> \\[60,80\\) - 0 <br/> \\[80,100\\) - 0  <br/> Máximo: 45 (2) <br/> Mínimo: 12 (0) | \n",
    "| *Exemplo 3* | 7<br/>13<br/>88<br/>45<br/>63<br/>94<br/>27<br/>5 | \\[0,20\\) - 1 <br/> \\[20,40\\) - 1 <br/> \\[40,60\\) - 1 <br/> \\[60,80\\) - 1 <br/> \\[80,100\\) - 2  <br/> Máximo: 94 (4) <br/> Mínimo: 5 (6) | \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "[1164](https://www.urionlinejudge.com.br/judge/pt/problems/view/1164) - Um número **perfeito** é um número igual à soma dos seus divisores (exceto ele mesmo).\n",
    "\n",
    "O número 28 é um exemplo de número perfeito: 28 = 1 + 2 + 4 + 7 + 14.\n",
    "\n",
    "[1165](https://www.urionlinejudge.com.br/judge/pt/problems/view/1165) - Um número **primo** é um número que só pode ser dividido por 1 e por ele mesmo. \n",
    "\n",
    "O número 17, por exemplo, só pode ser dividido por 1 e por 17.\n",
    "\n",
    "Escreva um código Python que receba um inteiro N e imprima os números do intervalo [1,N] que são primos ou perfeitos."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "|.| Entrada | Saída |\n",
    "|-|:-:|:-|\n",
    "| *Exemplo 1* | 10 | 1 2 3 5 6 7 10 | \n",
    "| *Exemplo 2* | 15 | 1 2 3 5 6 7 10 11 13 |\n",
    "| *Exemplo 3* | 20 | 1 2 3 5 6 7 10 11 13 17 19 |"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "[1789](https://www.urionlinejudge.com.br/judge/pt/problems/view/1789) - Jogos de corrida utilizam simulações baseadas nas regras da física para trazer realismo à experiência do usuário.\n",
    "\n",
    "Neste exercício, você deve simular uma das regras mais simples da mecânica clássica, que mostra que a distância percorrida por um objeto é proporcional à sua velocidade.\n",
    "\n",
    "Neste jogo serão 3 corredores, cada um com uma velocidade dada por um número real sorteado no intervalo [0,100) m/s.\n",
    "\n",
    "Considere que todos os competidores partem do mesmo lugar e apresente a posição de cada corredor atualizada segundo a segundo.\n",
    "\n",
    "Considere ainda que a linha de chegada está a 482m de distância do ponto de partida e encerre a corrida quando o vencedor cruzar a linha, identificando o vencedor.\n",
    "\n",
    "** Dica --** Para gerar um número real aleatório no intervalo [0,100), utilize a função ```uniform(0,100)```."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "|.| Velocidades | Saída |\n",
    "|-|:-:|:-|\n",
    "| *Exemplo 1* | 15.38<br/>55.49<br/>48.65  | 15.38 55.49 48.65 <br/> 30.76 110.98 97.30 <br/> 46.14 166.47 145.95 <br/> 61.52 221.96 194.60 <br/> 76.90 277.45 243.25 <br/> 92.28 332.94 291.90 <br/> 107.66 388.43 340.55 <br/> 123.04 443.92 389.20 <br/> 138.42 499.41 437.85 <br/> P2 | \n",
    "| *Exemplo 2* | 42.27<br/>95.26<br/>72.25 | 42.27 95.26 72.25 <br/> 84.54 190.52 144.50 <br/> 126.81 285.78 216.75 <br/> 169.08 381.04 289.00 <br/> 211.35 476.30 361.25 <br/> 253.62 571.56 433.50 <br/> P2 |\n",
    "| *Exemplo 3* | 98.76<br/>93.21<br/>96.65 | 98.76 93.21 96.65 <br/> 197.52 186.42 193.30 <br/> 296.28 279.63 289.95 <br/> 395.04 372.84 386.60 <br/> 493.80 466.05 483.25 <br/> P1 |"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "from random import uniform"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "[1828](https://www.urionlinejudge.com.br/judge/pt/problems/view/1828) - Pedra, paper e tesoura, ou じゃんけんぽん (jankenpon), é um jogo simples que envolve apenas quatro regras:\n",
    "\n",
    "- Dois jogadores disputam entre si, podendo escolher entre 3 opções de ação: pedra, papel ou tesoura.\n",
    "- A pedra quebra a tesoura.\n",
    "- A tesoura corta o papel.\n",
    "- O papel embrulha a pedra.\n",
    "\n",
    "Também é possível que não haja um vencedor, quando os dois jogadores escolhem a mesma ação.\n",
    "\n",
    "Escreva um código Python que receba um inteiro informando número de rodadas de uma partida e simule dois jogadores competindo entre si. Você deve imprimir as ações e o vencedor de cada rodada, bem como o vencedor da partida."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "|.| Entrada | Saída |\n",
    "|-|:-:|:-|\n",
    "| *Exemplo 1* | 3  | Jogador 2 <br/> Empate <br/> Jogador 2 <br/> Placar final: 0 x 2 <br/> Partida vencida pelo Jogador 2! | \n",
    "| *Exemplo 2* | 5 | Jogador 1 <br/> Jogador 1 <br/> Empate <br/> Empate <br/> Jogador 1 <br/> Placar final: 3 x 0 <br/> Partida vencida pelo Jogador 1! |\n",
    "| *Exemplo 3* | 4 | Empate <br/> Jogador 2 <br/> Empate <br/> Empate <br/> Placar final: 0 x 1 <br/> Partida vencida pelo Jogador 2! |"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Agora que você já sabe até como criar um jogo de jonkenpon, implemente uma versão em que você pode jogar contra o computador e mostre que você pode derrotá-lo :D"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[Blackjack](https://pt.wikipedia.org/wiki/Blackjack) - Vinte-e-um (21) é um dos mais icônicos jogos de cartas, onde um jogador real compete contra um jogador imaginário (a banca) para ver quem consegue o jogo de maior valor sem estourar o limite de 21 pontos.\n",
    "\n",
    "Por simplicidade, considere apenas as seguintes regras:\n",
    "- Cada jogador pode pedir uma carta por rodada ou dizer que quer parar de pedir.\n",
    "- O jogador que acumular mais de 21 pontos perde a partida.\n",
    "- Se o jogador e a banca atingirem o mesmo número de pontos, a partida termina empatada.\n",
    "- As cartas numéricas valem o número de pontos que elas indicam (ex: 2 vale 2, 10 vale 10).\n",
    "- As cartas de figuras (rei, valete e dama) valem 10 pontos.\n",
    "- O Ás vale 11 pontos.\n",
    "\n",
    "Escreva um código Python que te permite jogar blackjack contra o computador, escrevendo a cada rodada o valor do jogo de cada jogador e, ao final, o vencedor da partida."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "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
}