04.Controle de Fluxo - Condicionais.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    },
    "toc": true
   },
   "source": [
    "<h1>Table of Contents<span class=\"tocSkip\"></span></h1>\n",
    "<div class=\"toc\" style=\"margin-top: 1em;\"><ul class=\"toc-item\"><li><span><a href=\"#Controle-de-Fluxo\" data-toc-modified-id=\"Controle-de-Fluxo-1\"><span class=\"toc-item-num\">1&nbsp;&nbsp;</span>Controle de Fluxo</a></span><ul class=\"toc-item\"><li><span><a href=\"#Indentação-do-Código\" data-toc-modified-id=\"Indentação-do-Código-1.1\"><span class=\"toc-item-num\">1.1&nbsp;&nbsp;</span>Indentação do Código</a></span></li><li><span><a href=\"#Sentenças-Condicionais\" data-toc-modified-id=\"Sentenças-Condicionais-1.2\"><span class=\"toc-item-num\">1.2&nbsp;&nbsp;</span>Sentenças Condicionais</a></span><ul class=\"toc-item\"><li><span><a href=\"#Exercícios:\" data-toc-modified-id=\"Exercícios:-1.2.1\"><span class=\"toc-item-num\">1.2.1&nbsp;&nbsp;</span>Exercícios:</a></span></li></ul></li><li><span><a href=\"#Expressões-condicionais\" data-toc-modified-id=\"Expressões-condicionais-1.3\"><span class=\"toc-item-num\">1.3&nbsp;&nbsp;</span>Expressões condicionais</a></span><ul class=\"toc-item\"><li><span><a href=\"#Valores-True-e-False\" data-toc-modified-id=\"Valores-True-e-False-1.3.1\"><span class=\"toc-item-num\">1.3.1&nbsp;&nbsp;</span>Valores True e False</a></span></li></ul></li><li><span><a href=\"#Exercicio-1\" data-toc-modified-id=\"Exercicio-1-1.4\"><span class=\"toc-item-num\">1.4&nbsp;&nbsp;</span>Exercicio 1</a></span></li><li><span><a href=\"#Exercício-2\" data-toc-modified-id=\"Exercício-2-1.5\"><span class=\"toc-item-num\">1.5&nbsp;&nbsp;</span>Exercício 2</a></span></li><li><span><a href=\"#Exercício-3\" data-toc-modified-id=\"Exercício-3-1.6\"><span class=\"toc-item-num\">1.6&nbsp;&nbsp;</span>Exercício 3</a></span></li><li><span><a href=\"#Exercício-4\" data-toc-modified-id=\"Exercício-4-1.7\"><span class=\"toc-item-num\">1.7&nbsp;&nbsp;</span>Exercício 4</a></span></li><li><span><a href=\"#Exercício-5\" data-toc-modified-id=\"Exercício-5-1.8\"><span class=\"toc-item-num\">1.8&nbsp;&nbsp;</span>Exercício 5</a></span></li><li><span><a href=\"#Pedra,-Papel-e-Tesoura\" data-toc-modified-id=\"Pedra,-Papel-e-Tesoura-1.9\"><span class=\"toc-item-num\">1.9&nbsp;&nbsp;</span>Pedra, Papel e Tesoura</a></span></li></ul></li></ul></div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Controle de Fluxo"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Indentação do Código"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Os programas Python são estruturados através de indentação, ou seja, os blocos de código são definidos pelo seu recuo. Ok, é o que esperamos de qualquer código de programa, não é? Sim, mas no caso de Python é um requisito de linguagem, não é uma questão de estilo. Este princípio facilita a leitura e a compreensão do código Python de outras pessoas.\n",
    "\n",
    "Então, como isso funciona? Todas as declarações com a mesma distância à direita pertencem ao mesmo bloco de código, ou seja, as instruções dentro de uma linha de bloco verticalmente. O bloco termina em uma linha menos recuada ou no final do arquivo. Se um bloco tiver de ser mais profundamente aninhado, é simplesmente recuado mais para a direita. Veja a figura abaixo:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "![teste](img/identation.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Há outro aspecto da estruturação em Python, que vocês verão nos exemplos de declarações condicionais a seguir e de laços, mais a frente. As sentenças que iniciam o laço ou a declaração condicional terminam com dois pontos \":\" $-$ o mesmo é verdadeiro para funções e outras estruturas que introduzem blocos. Então, devemos dizer que as estruturas Python são definidas por dois pontos e indentação."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Sentenças Condicionais\n",
    "\n",
    "É muito comum em um programa que certos conjuntos de instruções sejam executados de forma condicional, em casos como validar entradas de dados."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Sintaxe:\n",
    "```python\n",
    "    if <condição>:\n",
    "        <bloco de código>\n",
    "    elif <condição>:          # 0 ou mais cláusulas elif\n",
    "        <bloco de código>\n",
    "    else:                     # opcional\n",
    "        <bloco de código>\n",
    "```\n",
    "Na qual:\n",
    "\n",
    "+ `<condição>`: sentença que possa ser avaliada como verdadeira ou falsa.\n",
    "+ `<bloco de código>`: sequência de linhas de comando.\n",
    "+ As clausulas `elif` e `else` são opcionais e podem existir vários `elifs` para o mesmo `if`, porém apenas um `else` ao final."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Exemplo:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "x = int(input(\"Enter a number for x: \"))\n",
    "y = int(input(\"Enter a number for y: \"))\n",
    "if x == y:\n",
    "    print(\"x and y are equal\")\n",
    "elif x < y:\n",
    "    print(\"x is smaller\")\n",
    "else:\n",
    "    print(\"y is smaller\")\n",
    "print(\"thanks!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Fluxograma do exemplo:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "![if](img/if-statement.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Um exemplo um pouco mais elaborado:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "from datetime import date\n",
    "import calendar\n",
    "\n",
    "today = calendar.day_name[date.today().weekday()]\n",
    "strike = \"N\"\n",
    "my_lab = \"Wednesday\"\n",
    "\n",
    "if today == \"Tuesday\":\n",
    "    if strike == \"Y\":\n",
    "        print(\"Stay home\")\n",
    "    else:\n",
    "        print(\"Lecture in MC102!\")\n",
    "elif today == \"Thursday\":\n",
    "    print(\"Another lecture in MC102!\")\n",
    "elif today == my_lab:\n",
    "    print(\"Go to lab!\")\n",
    "elif today == \"Monday\" or today == \"Friday\" or today == \"Saturday\":\n",
    "    print(\"no lecture in MC102\")\n",
    "else:\n",
    "    print(\"playday!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Se o bloco de código for composto de apenas uma linha, ele pode ser escrito após os dois pontos. Exemplo:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "# weather-api é um wrapper para o feed Weather RSS XML do Yahoo.\n",
    "# Para usar o weather-api é preciso instalá-lo:\n",
    "# pip3 install weather-api\n",
    "\n",
    "from weather import Weather\n",
    "clima = Weather()\n",
    "cidade = clima.lookup_by_location('edmonton')\n",
    "condicao = cidade.condition()\n",
    "temperatura = int(condicao.temp())\n",
    "if temperatura < 32: print ('Congelando...')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Exercícios:\n",
    "- A fórmula para converter de Fahrenheit para Celsius é $C = (F - 32) \\times 5/9$. Use esta fórmula para converter a temperatura obtida no exemplo anterior para Celsius:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "- No trecho de código abaixo, quando o \\textbf{comando_4} é executado?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "if cond1:\n",
    "    if cond2:\n",
    "        comando_1\n",
    "    else:\n",
    "        comando_2\n",
    "else:\n",
    "    if cond3:\n",
    "        comando_3\n",
    "    else:\n",
    "        comando_4"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "- O que será impresso no código abaixo?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "a = 9\n",
    "if a > 3:\n",
    "    if a < 7:\n",
    "        print(\"a\")\n",
    "else:\n",
    "    if a > −10:\n",
    "        print(\"b\")\n",
    "    else:\n",
    "        print(\"c\")\n",
    "print(\"finish!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Expressões condicionais"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "o Python suporta a expressão:\n",
    "```python\n",
    "    <variável> = <valor_1> if <condição> else <valor_2>\n",
    "```\n",
    "Na qual `<variável>` receberá `<valor_1>` se `<condição>` for verdadeira e `<valor_2>`  caso contrário."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "Weekend = True if (today == \"Saturday\" or today == \"Sunday\") else False\n",
    "print(Weekend)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Valores True e False"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Todo valor em python pode ser avaliado como True (Verdadeiro) ou False (Falso). A regra geral é que qualquer valor não-zero ou não vazio irá avaliar para Verdadeiro. Se você nunca tiver certeza, você pode abrir um terminal Python e escrever duas linhas para descobrir se o valor que você está considerando é True ou False. Dê uma olhada nos seguintes exemplos, mantenha-os em mente e teste qualquer valor que você tenha curiosidade."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "if 0:\n",
    "    print(\"This evaluates to True.\")\n",
    "else:\n",
    "    print(\"This evaluates to False.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "if 1:\n",
    "    print(\"This evaluates to True.\")\n",
    "else:\n",
    "    print(\"This evaluates to False.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "# Test for an empty string\n",
    "if '':\n",
    "    print(\"This evaluates to True.\")\n",
    "else:\n",
    "    print(\"This evaluates to False.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "# any other string, including a space\n",
    "if ' ':\n",
    "    print(\"This evaluates to True.\")\n",
    "else:\n",
    "    print(\"This evaluates to False.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Exercicio 1\n",
    "Escrever um programa que calcula a área de três tipos de objetos geométricos: quadrado, retângulo e círculo. \n",
    "- Primeiramente deve ser lido um caractere que indica o tipo de objeto a ter a área calculada: ’q’ para quadrado, ’r’ para retângulo e ’c’ para círculo.\n",
    "- Em seguida deverá ser lido as dimensões do objeto:\n",
    "  - Para um quadrado deve ser lido o tamanho de um lado.\n",
    "  - Para um retângulo devem ser lidos os tamanhos de cada lado.\n",
    "  - Para um círculo, deve ser lido o raio.\n",
    "- Em seguida o programa faz o cálculo da área, imprime no terminal e finaliza o programa. Se o usuário digitar um caractere diferente de ’q’, ’r’, e ’c’ o programa deverá imprimir uma mensagem de erro antes de finalizar o programa."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "from math import pi\n",
    "\n",
    "g = input(\"selecione o objeto -  q, r, ou c: \")\n",
    "entrada_valida = True\n",
    "if g == \"q\":\n",
    "    lado = float(input(\"forneça o lado do quadrado: \"))\n",
    "    area = lado * lado\n",
    "    objeto = \"quadrado\"\n",
    "elif g == \"r\":\n",
    "    a = float(input(\"forneça o lado a do retangulo: \"))\n",
    "    b = float(input(\"forneça o lado b do retangulo: \"))\n",
    "    area = a * b\n",
    "    objeto = \"retangulo\"\n",
    "elif g == \"c\":\n",
    "    r = float(input(\"forneça o raio do circulo: \"))\n",
    "    area = pi * r ** 2\n",
    "    objeto = \"circulo\"\n",
    "else:\n",
    "    print(\"Entrada inválida!\")\n",
    "    entrada_valida = False\n",
    "if entrada_valida:\n",
    "    print(f\"A área do {objeto} é {area}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Exercício 2\n",
    "Quando ações são vendidas ou compradas por meio de um corretor, a comissão do corretor é muitas vezes calculada usando uma escala que depende do valor das ações negociadas. Escreva um programa que calcule o valor da comissão a partir do valor da transação informado pelo usuário, sabendo-se que o corretor cobra os valores indicados abaixo e que a comissão mínima é de R$ 39,00.\n",
    "\n",
    "- Até R\\$2.500,00, comissão de R\\$30,00 + 1,70%\n",
    "- de R\\$2.500,01 até R\\$6.250,00, comissão de R\\$56,00 + 0,66%\n",
    "- R\\$6.250,01 até R\\$20.000,00, comissão de R\\$76,00 + 0,34%\n",
    "- R\\$20.000,01 até R\\$50.000,00, comissão de R\\$100,00 + 0,22%\n",
    "- R\\$50.000,01 até R\\$500.000,00, comissão de R\\$155,00 + 0,11%\n",
    "- Acima de R\\$500.000,00, comissão de R\\$255,00 + 0,09%"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "# Cálculo de Commissão por volume de Vendas\n",
    "venda =input(\"Forneça o valor total das vendas\")\n",
    "if not venda.isdecimal():\n",
    "    print(\"Valor fornecido inválido\")\n",
    "else:\n",
    "    if venda <= 2500:\n",
    "        c = 30 + 0.017 * venda\n",
    "        if c <= 39:\n",
    "            c = 39\n",
    "    elif venda <= 6250:\n",
    "        c = 56 + 0.0066 * venda\n",
    "    elif venda <= 20000:\n",
    "        c = 76 + 0.0034 * venda\n",
    "    elif venda <= 50000:\n",
    "        c = 100 + 0.0022 * venda\n",
    "    elif venda <= 500000:\n",
    "        c = 155 + 0.0011 * venda\n",
    "    else:\n",
    "        c = 255 + 0.0009 * venda\n",
    "    print(f\"Sua comissão foi: R$ {c}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Exercício 3\n",
    "\n",
    "Uma lata de leite em pó da marca A, com 400g custa R\\$8,39. Um saco de leite em pó da marca B, com 1Kg custa R\\$20,30. Qual a marca tem o melhor preço?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "code_folding": [
     0
    ],
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "# solução\n",
    "custo_gr_A = 8.39 / 400\n",
    "custo_gr_B = 20.30 / 1000\n",
    "if abs(custo_gr_A - custo_gr_B) <= 0.0001:\n",
    "    print(\"As duas marcas tem preços iguais!\")\n",
    "elif custo_gr_A < custo_gr_B:\n",
    "    print(\"A marca A tem melhor preço\")\n",
    "else:\n",
    "    print(\"A marca B tem melhor preço.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Exercício 4\n",
    "\n",
    "A equação de uma circuferência de raio $r$ é $x^{2} + y^{2} = r^{2}$.\n",
    "Escreva um algoritmo que, dado um ponto $p$ qualquer, verifique se ele se\n",
    "encontra:\n",
    "- na circunferência;\n",
    "- no interior;\n",
    "- no exterior."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "code_folding": [
     0
    ],
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "# solução\n",
    "r = float(input(\"Forneça o raio da circunferencia: \"))\n",
    "x = float(input(\"Entre com a cordenada x do ponto p: \"))\n",
    "y = float(input(\"Entre com a cordenada y do ponto p: \"))\n",
    "rp2 = x ** 2 + y ** 2\n",
    "if rp2 == r ** 2:\n",
    "    print(\"O ponto p está na circunferência!\")\n",
    "elif rp2 < r ** 2:\n",
    "    print(\"O ponto p está no interior da circunferência.\")\n",
    "else:\n",
    "    print(\"O ponto p está no exterior da circunferência.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Exercício 5\n",
    "\n",
    "Dados os coeficientes a, b, c de uma equação de $2^{o}$ grau, determine se há\n",
    "raizes reais e, caso positivo, quais são elas."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "code_folding": [
     0,
     4
    ],
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "# solução\n",
    "from math import sqrt\n",
    "\n",
    "\n",
    "def is_float(value):\n",
    "    try:\n",
    "        num = float(value)\n",
    "    except ValueError:\n",
    "        return False\n",
    "    return num\n",
    "\n",
    "\n",
    "coefs = input(\"forneça os coeficientes a, b, e c, separados por espaço: \")\n",
    "a, b, c = coefs.split()\n",
    "if is_float(a) and is_float(b) and is_float(c):\n",
    "    a, b, c = float(a), float(b), float(c)\n",
    "    delta = b ** 2 - 4 * a * c\n",
    "    if delta >= 0:\n",
    "        print(\"As raizes da equação são:\", end=\" \")\n",
    "        r1 = (-b + sqrt(delta)) / 2 * a\n",
    "        r2 = (-b - sqrt(delta)) / 2 * a\n",
    "        print(r1, r2)\n",
    "    else:\n",
    "        print(\"A equação não tem raízes reais!\")\n",
    "else:\n",
    "    print(\"Entrada inválida!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Pedra, Papel e Tesoura\n",
    "\n",
    "Escreva um programa que simula o jogo conhecido como \"Pedra, Papel e Tesoura\" de um jogador contra o computador.\n",
    "<img src=\"img/pedra_papel_tesoura.png\" alt=\"Drawing\" style=\"width: 200px;\"/>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Associar objetos (pedra, papel, tesoura) a números é uma forma de\n",
    "**abstração**. Vamos usar essa abstração para simplificar o código do sorteio:\n",
    "```\n",
    "import random                    # Import the random module\n",
    "number = random.randrange(0, n)  # Get random number between 0 and n-1\n",
    "```\n",
    "Tal simplificação pode ser também aplicada ao teste da condição?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "code_folding": [
     0
    ],
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "\"\"\"\n",
    "  Jogo Pedra, Papel e Tesoura\n",
    "  Vamos adotar a seguinte abstração:\n",
    "    - pedra = 0\n",
    "    - papel = 1\n",
    "    - tesoura = 2\n",
    "  Usaremos nos nomes:\n",
    "    - user para representar o jogador\n",
    "    - computer para o computador\n",
    "    \n",
    "  Se user == computer : empate\n",
    "  user ganha quando:\n",
    "     user == pedra e computer == tesoura, ou\n",
    "     user == tesoura e computer == papel, ou\n",
    "     user == papel e computer == pedra     \n",
    "  caso contrário computer ganha    \n",
    "\"\"\"\n",
    "import random\n",
    "pedra = 0\n",
    "papel = 1\n",
    "tesoura = 2\n",
    "computer = random.randrange(0, 3)\n",
    "user = int(input(\"Digite 0 p/ pedra, 1 p/ papel, ou 2 p/ tesoura: \"))\n",
    "if user == computer:\n",
    "    print(\"It's a draw, try again\")\n",
    "elif (user == pedra and computer == tesoura) or \\\n",
    "    (user == tesoura and computer == papel) or \\\n",
    "    (user == papel and computer == pedra):\n",
    "    print(\"You Win!\")\n",
    "else:\n",
    "    print(\"Computer Wins!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Escreva a solução usando aritimética modular. Dica:\n",
    "<img src=\"img/modulo.png\" alt=\"Drawing\" style=\"width: 300px;\"/>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "code_folding": [],
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "if user == computer:\n",
    "    print(\"Empate.\")\n",
    "else:\n",
    "    if (user - computer) % 3 == 1:\n",
    "        print(\"Você ganhou!\")\n",
    "    else:\n",
    "        print(\"O computador ganhou.\")"
   ]
  }
 ],
 "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.7.0"
  },
  "latex_envs": {
   "LaTeX_envs_menu_present": true,
   "autoclose": false,
   "autocomplete": true,
   "bibliofile": "biblio.bib",
   "cite_by": "apalike",
   "current_citInitial": 1,
   "eqLabelWithNumbers": true,
   "eqNumInitial": 1,
   "hotkeys": {
    "equation": "Ctrl-E",
    "itemize": "Ctrl-I"
   },
   "labels_anchors": false,
   "latex_user_defs": false,
   "report_style_numbering": false,
   "user_envs_cfg": false
  },
  "livereveal": {
   "theme": "solarized",
   "transition": "slide"
  },
  "toc": {
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": false,
   "toc_cell": true,
   "toc_position": {
    "height": "565px",
    "left": "0px",
    "right": "1068px",
    "top": "111px",
    "width": "212px"
   },
   "toc_section_display": "block",
   "toc_window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}