RepeticaoI.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div id=\"homesweethome\"></div>\n",
    "\n",
    "<div style=\"width: 100%; text-align: center; color: white; background-color: #222; font-size: 3em; font-weight: 700; padding: .5em .5em .6em .5em; line-height: 1.4em;\">Programação em Python para Iniciantes</div>\n",
    "\n",
    "<br>\n",
    "\n",
    "<div style=\"width: 100%; text-align: center; color: white; background-color: #555; font-size: 2.2em; font-weight: 700; padding: .5em .5em .6em .5em; line-height: 0.9em;\">Estruturas de repetição</div>\n",
    "\n",
    "<br>\n",
    "\n",
    "Nesta unidade, você vai aprender como fazer para executar um trecho do seu programa várias vezes automaticamente.\n",
    "\n",
    "Isso é muito útil quando o problema que estamos tentando resolver envolve tarefas repetitivas!\n",
    "\n",
    "<span style=\"color: red;\">**Atenção:**</span> **salve seu trabalho frequentemente, pois a atividade desta unidade pede justamente para você entregar este _notebook_ completamente resolvido.**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "# Introdução\n",
    "\n",
    "Vamos começar com um exemplo: suponha que você queira imprimir os números de 1 a 5. \n",
    "\n",
    "Você poderia fazer o seguinte:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "print(1)\n",
    "print(2)\n",
    "print(3)\n",
    "print(4)\n",
    "print(5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Isso é factivel.\n",
    "\n",
    "Agora, e se você quisesse imprimir os números de 1 a 100?\n",
    "\n",
    "Tudo bem, imprimir os números de 1 a 100 com um monte de linhas `print()` é muito tedioso, mas também seria possível.\n",
    "\n",
    "O problema complica mesmo se você quisesse imprimir os números de 1 a <b>$n$</b>, onde $n$ é um número que você obteve do usuário através de uma chamada do `input()`. \n",
    "\n",
    "Com os recursos da linguagem que aprendemos até o momento, isso não seria nem chato nem tedioso, seria impossível!\n",
    "\n",
    "Para lidar com situações que exigem repetição de tarefas, as linguagens de programação possuem estruturas de repetição (também chamadas de _laços_) como o comando `for` e o comando `while`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Veja a seguir como você pode fazer para imprimir os números de 1 a 5 com o comando **`for`**:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "for n in [1, 2, 3, 4, 5]:\n",
    "    print(n)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "O que exatamente o nosso código está fazendo? Execute o código a seguir para ver uma animação:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Código para rodar vídeo\n",
    "from IPython.display import HTML\n",
    "HTML('<iframe width=\"420\" height=\"315\" src=\"https://www.youtube.com/embed/9h_5HYvmL44\"></iframe>')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<hr> \n",
    "\n",
    "### Exercício <span class=\"exec\"></span>: números de 1 a 8\n",
    "\n",
    "Modifique o código abaixo para que ele mostre os números de 1 a 8.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "for n in [1, 2, 3, 4, 5]:\n",
    "    print(n)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<hr>\n",
    "\n",
    "Antes de prosseguirmos com mais explicações sobre o comando **`for`**, vamos tentar entender o conceito de _lista_."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Listas\n",
    "\n",
    "`[1, 2, 3, 4, 5]` é um exemplo de **lista**. Uma lista pode ter elementos de vários tipos!\n",
    "\n",
    "Veja o código abaixo."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "['papagaio', 'cachorro', True, 34]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Podemos usar uma variável para guardar uma lista de dados:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "x = ['Alice', 'Beto', 'Caio', 4, 35.2176, False]\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Comprimento da lista"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "O comprimento de uma lista pode ser consultado via a função `len()`. Veja:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "len(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Intervalos (_ranges_)\n",
    "\n",
    "Python tem ainda uma estrutura chamada _range_, que é muito semelhante a uma lista.\n",
    "\n",
    "Um _range_ é uma lista imutável de números inteiros igualmente espaçados (como em uma progressão aritmética).\n",
    "\n",
    "A tradução mais comum para _range_ é \"intervalo\".\n",
    "\n",
    "Veja alguns exemplos mais comuns do uso de intervalos:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "x = range(1, 21)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Para imprimir (mostrar na tela) a lista de valores nesse _range_, podemos converter o range para uma lista assim:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "list(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Repare que `range(1, 21)` tem os números inteiros de 1 até 20 (mas não tem o 21).\n",
    "\n",
    "O primeiro argumento do `range()` é o primeiro inteiro **dentro** do intervalo.\n",
    "\n",
    "O segundo argumento do `range()` é o primeiro inteiro **fora** do intervalo.\n",
    "\n",
    "Veja mais alguns exemplos:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "intervalo = range(1, 6)\n",
    "print(list(intervalo))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Agora um exemplo de intervalo (_range_) sendo usado junto com o comando `for`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "for i in range(1, 6):\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Intervalos do tipo $0$ a $n - 1$\n",
    "\n",
    "Quando programamos, é comum precisarmos do intervalo contendo todos os números inteiros de $0$ até $n - 1$.\n",
    "\n",
    "Em Python, podemos construir um intervalo desses passando um único argumento para o comando `range()`. Veja:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "n = 10\n",
    "list(range(n))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Observe que `range(n)` é equivalente a `range(0, n)` e que, portanto, `range(n)` retorna um lista com os números de $0$ a $n-1$."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Veja mais um exemplo:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "for i in range(10):\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Saída de dados dentro de laços\n",
    "\n",
    "**Atenção:** não execute a célula abaixo!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for i in range(1000000):\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "O problema é que uma quantidade excessiva de linhas de texto será gerada na saída (1 milhão de linhas para ser exato), o que fará com que o navegador trave, pois ele não vai conseguir lidar com todo esse fluxo de dados gerados pelo Jupyter e não irá mostrá-los adequadamente na tela.\n",
    "\n",
    "Então por que é que essa célula se encontra neste notebook?\n",
    "\n",
    "Para que você tome muito cuidado com `print(...)` dentro de laços de repetição. Se o número de iterações do laço for muito grande, como no exemplo acima, você terá de reiniciar o navegador e possivelmente também o Jupyter. Se você executou a célula, melhor que tenha cometido esse erro agora (que você está no começo do tutorial) do que após ter resolvido muitos exercícios ;-)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# O comando **`for`**\n",
    "\n",
    "Como você já deve ter percebido, o comando **`for`** faz com que uma variável receba, repetidamente, valores tomados de uma dada lista e, para cada um desses valores, executa o bloco de código indentado logo abaixo.\n",
    "\n",
    "A estrutura do comando **`for`** é a seguinte:\n",
    "\n",
    "\n",
    "    for variável in lista:\n",
    "        código indentado\n",
    "        código indentado\n",
    "        etc.\n",
    "    \n",
    "Assim como no comando **`if`**, a primeira linha de código não indentada depois do comando **`for`** marca o fim do bloco de código associado.\n",
    "        \n",
    "A lista de elementos no comando **`for`** pode ser substituida por um intervalo.\n",
    "        "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exemplo:\n",
    "\n",
    "O programa a seguir imprime os números de 2 até 10"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "for i in range(2, 11):\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "\n",
    "### Exercício <span class=\"exec\"></span>: números de 10 a 50\n",
    "\n",
    "Mude o código acima para que o programa imprima os números de 10 até 50 (inclusive o 10 e o 50).\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exemplo:\n",
    "\n",
    "Para cada número entre 1 e 10, o programa a seguir mostra o dobro desse número, o triplo, o quadrado e a raiz quadrada. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for n in range(1, 11):\n",
    "    print('O dobro de', n, 'é', 2*n)\n",
    "    print('O triplo de', n, 'é', 3*n)\n",
    "    print('O quadrado de', n, 'é', n**2)\n",
    "    print('A raiz quadrada de', n, 'é', n**(1/2))\n",
    "    print('-------------------------------------------')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exemplo:\n",
    "\n",
    "O exemplo abaixo imprime apenas os números pares de 0 até 9:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "for i in range(10):\n",
    "    if i % 2 == 0:\n",
    "        print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exemplo:\n",
    "\n",
    "Veja um exemplo em que o valor da variável do `for` não é usada no corpo do `for`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for i in range(5):\n",
    "    print('oi')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<hr>\n",
    "\n",
    "### Exercício <span class=\"exec\"></span>: par ou ímpar I\n",
    "\n",
    "O código a seguir imprime os números de 1 a 10. Modifique **apenas** o bloco de código dentro do  **`for`** de modo que ele imprima o seguinte:</p>\n",
    "\n",
    "    1 é ímpar\n",
    "    2 é par \n",
    "    3 é ímpar\n",
    "    4 é par \n",
    "    5 é ímpar\n",
    "    etc. (até 10)\n",
    "\n",
    "**Dica:** use o comando **`if`** dentro do bloco de código do **`for`**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "for n in range(1, 11):\n",
    "    print(n)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "### Exercício <span class=\"exec\"></span>: multiplos de 5 entre 0 e 100\n",
    "\n",
    "Observe o programa abaixo.\n",
    "\n",
    "Modifique o código de forma que ele imprima todos os múltiplos de 5 no intervalo de 0 a 100 (0 e 100 inclusive)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for i in range(10):\n",
    "    if i % 2 == 0:\n",
    "        print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Variáveis contadoras\n",
    "\n",
    "É muito comum realizarmos um laço de repetição para contar a ocorrência de certos eventos ou para contar objetos que satisfazem alguma propriedade.\n",
    "\n",
    "Vejamos um exemplo: suponha que estamos interessados em contar quantos números de 0 a 1000 são multiplos de 4 e 6 simultaneamente.\n",
    "\n",
    "Podemos criar uma variável `contadora` e inicializá-la com o valor 0. \n",
    "\n",
    "Depois, podemos percorrer todos os números de 0 a 1000, um a um, com o auxílio do comando `for`. Para cada número encontrado devemos verificar se ele é multiplo de 4 e também de 6 e, em caso afirmativo, devemos incrementar a variável `contadora` (somar 1 ao valor armazenado nela) para que ela, ao final do laço, tenha como valor exatamente a quantidade desejada (o número de múltiplos simultâneos de 4 e 6 no intervalo de 0 a 1000).\n",
    "\n",
    "Vajamos como fica o código."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "contadora = 0\n",
    "for j in range(1001):\n",
    "    if j % 4 == 0 and j % 6 == 0:\n",
    "        contadora = contadora + 1\n",
    "        \n",
    "print('A quantidade de números entre 0 e 1000 que são')\n",
    "print('multiplos de 4 e 6 simultaneamente é igual a', contadora)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Você achou expressão&nbsp; `contadora = contadora + 1` &nbsp;um pouco estranha?\n",
    "\n",
    "Essa linha faz uma **atribuição** que funciona da seguinte maneira:\n",
    "\n",
    "1. calcula-se o valor de `contadora + 1` (expressão do lado direito do `=`)\n",
    "2. guarda-se o resultado na variável `contadora` (variável que está à esquerda do `=`)\n",
    "\n",
    "Ou seja, o novo valor da variável `contadora` após a execução dessa linha é o valor antigo de `contadora` mais 1.\n",
    "\n",
    "O código abaixo traz uma situação análoga, execute-a e veja o que acontece."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 10\n",
    "x = x + 1\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "\n",
    "### Exercício <span class=\"exec\"></span>: multiplos de 5 ou 7\n",
    "\n",
    "Faça um programa para contar quantos números entre 1000 e 9999 são multiplos de 5 ou multiplos de 7. Se um número é multiplo de 5 e de 7 simultaneamente ele também deve ser contado (uma única vez, é claro).\n",
    "\n",
    "As extremidades (i.e. 1000 e 9999) também devem ser consideradas na contagem."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "\n",
    "### Exercício <span class=\"exec\"></span>: anos bissextos entre o ano zero e o ano atual\n",
    "\n",
    "A regra para um ano X ser bissexto é \"X é multiplo de 4 mas não de 100\". As únicas excessões a essa regra são os anos múltiplos de 400, que são bissextos apesar da regra dizer que eles não deverima ser.\n",
    "\n",
    "Faça um programa para contar a quantidades de anos bissextos entre o ano zero e o ano atual. Inclua o ano atual na contagem se ele for bissexto. (O ano zero também deve ser incluído, já que ele foi bissexto.)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Variáveis acumuladoras\n",
    "\n",
    "As variáveis acumuladoras funcionam de maneira semelhante às variáveis contadoras, só que elas armazenam a soma dos valores de objetos que satisfazem determinada propriedade em vez de simplesmente contar o número desses objetos. \n",
    "\n",
    "Vejamos um exemplo.\n",
    "\n",
    "Vamos tomar como ponto de partida o problema de contar a quantidade de números pares entre 0 e 100. Vejamos como seria um programa para fazer isso:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "pares = 0\n",
    "for i in range(101):\n",
    "    if i % 2 == 0:\n",
    "        pares = pares + 1\n",
    "        \n",
    "print('Existem', pares, 'numeros pares entre 0 e 100 (contando o 0 e o 100).')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Suponha agora que, em vez de querermos contar a quantidade de números pares, desejamos saber o valor da soma desses números. \n",
    "\n",
    "Qual a soma de todos os números pares entre 0 e 100?\n",
    "\n",
    "Em outras palavras, quanto vale a expressão $2 + 4 + 6 + \\cdots + 100$?\n",
    "\n",
    "Para resolver esse problema, podemos usar uma (nova) variável -- que vamos convenientemente chamar de `soma` -- para armazenar a soma desses números.\n",
    "\n",
    "Inicialmente o valor dessa variável é 0. \n",
    "\n",
    "À medida que vamos percorrendo os números de 0 a 100 (com o auxílio de um `for`), vamos analisando cada um dos números nessa sequência, um a um, e decidindo se cada um deles é par. Para cada número par encontrado, nós \"acumulamos\" seu valor na variável soma.\n",
    "\n",
    "Vejamos como fica o códogo."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "A soma dos números pares entre 0 e 100 é 2550\n"
     ]
    }
   ],
   "source": [
    "soma = 0\n",
    "for i in range(101):\n",
    "    if i % 2 == 0:\n",
    "        soma = soma + i\n",
    "    \n",
    "print('A soma dos números pares entre 0 e 100 é', soma)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Novamente, pode ser que você tenha achado a expressão&nbsp; `soma = soma + i` &nbsp;um pouco estranha.\n",
    "\n",
    "O que essa linha faz é o seguinte:\n",
    "\n",
    "1. calcula o valor de `soma + i`\n",
    "2. guarda o resultado na variável `soma`\n",
    "\n",
    "Ou seja, o novo valor da variável `soma` após a execução dessa linha é o valor antigo de `soma` mais o valor de `i`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exemplo:\n",
    "\n",
    "Vejamos agora um exemplo mais simples do uso de variável acumuladora.\n",
    "\n",
    "Suponha que queremos calcular a soma dos números de $1$ a $n$.\n",
    "\n",
    "Por exemplo, se $n = 5$, queremos calcular:\n",
    "\n",
    "$$1 + 2 + 3 + 4 + 5 = 15.$$\n",
    "\n",
    "Na verdade, existe uma fórmula fechada para essa soma, mas suponha que queremos fazer a soma usando o comando `for`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "n = int(input(\"De o valor de n: \"))\n",
    "soma = 0\n",
    "for i in range(1, n + 1):\n",
    "    soma = soma + i\n",
    "    \n",
    "print(soma)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "No exemplo de código acima dizemos que a variável `soma` **acumulou** os valores de `i` ao longo das iterações, por isso é que `soma` (nesse caso) pode ser chamada de variável acumuladora."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "\n",
    "### Exercício <span class=\"exec\"></span>: soma de quadrados I\n",
    "\n",
    "Na célula abaixo, copiamos o código do exemplo acima (que calcula $1 + 2 + \\cdots + n$).\n",
    "\n",
    "Modifique esse código para calcular a soma dos quadrados dos números de $1$ até $n$. Ou seja, quando o usuário digitar um número $n$, o programa deverá mostrar o resultado da soma\n",
    "\n",
    "$$1^2 + 2^2 + 3^2 + \\cdots + n^2.$$\n",
    "\n",
    "Teste se seu código funciona: para $n = 137$, seu programa deve devolver 866525."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "n = int(input(\"De o valor de n: \"))\n",
    "total = 0\n",
    "for i in range(1, n + 1):\n",
    "    total = total + i                    #    <<<<<    você deve mudar apenas esta linha\n",
    "\n",
    "print(total)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "\n",
    "### Exercício <span class=\"exec\"></span>: fatorial\n",
    "\n",
    "Talvez alguns de vocês saibam que o módulo **`math`** do Python tem uma função chamada **`factorial`** que calcula o fatorial de um número. Neste exercício, vamos fazer um programa para calcular o fatorial sem usar o módulo **`math`**. \n",
    "\n",
    "O _fatorial_ de um número natural $n$ é definido como\n",
    "\n",
    "$$n! = n \\times (n-1) \\times (n-2) \\times \\cdots \\times 3 \\times 2 \\times 1.$$\n",
    "\n",
    "Ou seja, o fatorial de um número $n$ é o produto de todos os inteiros de $2$ até $n$. \n",
    "\n",
    "Faça um programa que peça ao usuário um valor para $n$ e que mostra o valor de $n!$ na tela. Não use a função **`factorial`** do módulo **`math`**! \n",
    "\n",
    "Para conferir se seu programa está correto: 7! = 5040, 13! = 6227020800."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Solução análoga ao exemplo da soma dos números de 1 a n \n",
    "\n",
    "# mas agora você deve usar o produto em vez de soma\n",
    "# lembre-se de inicializar corretamente a variável 'produto'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "\n",
    "## Entrada de dados dentro de laços\n",
    "\n",
    "É comum termos que ler da entrada (perguntar ao usuário) um número muito grande de dados.\n",
    "Algumas vezes o \"tamanho\" da entrada -- a quantidade desses dados -- é parte da própria entrada.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exemplo:\n",
    "\n",
    "Suponha que uma loja disponibilize um software aos seus vendedores para ajudá-los a calcular o valor total de suas vendas num período (mensal, anual, o que for). \n",
    "\n",
    "O código a seguir pede que o usuário (vendedor) digite o número de vendas, e depois pede a ele que digite o valor de cada venda. Finalmente, o programa calcula e imprime o valor total das vendas daquele vendedor."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "n = int(input(\"Qual o número de vendas? \"))\n",
    "total = 0.0\n",
    "for i in range(n):\n",
    "    valor = float(input(\"Qual o valor da venda? \"))\n",
    "    total = total + valor\n",
    "    \n",
    "print(\"O total das vendas é:\", total)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Podemos identificar claramente o uso de uma variável acumuladora chamada `total`. Mas o ponto do exemplo é justamente ilustrar o fato de que é possível fazer perguntas ao usuário dentro de um comando `for`. \n",
    "\n",
    "Se o vendedor respondeu que o número de vendas é 7 (linha 1 do programa), então o programa irá perguntar por 7 valores, uma pergunta para cada iteração do laço `for`.\n",
    "\n",
    "Repare também que, neste exemplo, o valor da variável `i` não é usado dentro do corpo do `for`. Não há problema algum com isso.\n",
    "\n",
    "Mas poderíamos usar o valor de `i` para formatar melhor as pergutas. Preste atenção no código a seguir e identifique o que mudou com relação ao código acima. Execute o programa e perceba como isso afeta positivamente a experiência do usuário."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "n = int(input(\"Qual o número de vendas? \"))\n",
    "total = 0.0\n",
    "for i in range(n):\n",
    "    valor = float(input(\"Qual o valor da \" + str(i + 1) + \"ª venda? \"))\n",
    "    total = total + valor\n",
    "    \n",
    "print(\"O total das vendas é:\", total)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<hr>\n",
    "\n",
    "### Exercício <span class=\"exec\"></span>: média das vendas\n",
    "\n",
    "Modifique o código acima para que, além do valor total das vendas, o programa imprima também o valor médio das vendas.\n",
    "\n",
    "Teste se seu código funciona: para $n=3$ e valores $12.20$, $15.30$, $17.50$, a média deve ser $15.0$\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<hr>\n",
    "\n",
    "### Exercício <span class=\"exec\"></span>: parabéns!\n",
    "\n",
    "Copiamos o código do exemplo anterior na célula abaixo.\n",
    "\n",
    "Modifique-o de modo que, toda vez que o usuário digitar uma venda de valor maior do que 100 reais, o programa mostre &ndash; naquele mesmo momento &ndash; uma mensagem de parabéns para o vendedor."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "n = int(input(\"Qual o número de vendas? \"))\n",
    "total = 0.0\n",
    "for i in range(n):\n",
    "    valor = float(input(\"Qual o valor da venda? \"))\n",
    "    total = total + valor\n",
    "    \n",
    "print(\"A total das vendas é:\", total)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Agora, continue a modificar seu programa de modo que ele conte quantas vendas ultrapassaram 100 reais e, no final, imprima uma mensagem informando o vendedor dessa quantidade."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<hr>\n",
    "\n",
    "### Exercício <span class=\"exec\"></span>: par ou ímpar II\n",
    "\n",
    "Faça um programa que pede para o usuário digitar um inteiro $n > 0$ e que depois pede para o usuário digitar $n$ inteiros. Finalmente mostre ao usuário quantos números pares e quantos ímpares ele digitou."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<span style=\"font-weight: 600; color: red;\">Atenção:</span> se você já programa em Python ou em outra linguagem de programação, talvez você fique tentado a usar o conceito de _listas_ ou _arrays_ ou _vetores_ para resolver alguns exercícios desta unidade. Se esse for o seu caso, não use nada disso. Todos os exercícios podem (e devem) ser resolvidos somente com os conceitos que vimos até agora, sem o uso de estruturas lineares como as que mencionamos."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "### Exercício <span class=\"exec\"></span>: soma de quadrados II\n",
    "\n",
    "Pergunte ao usuário por um número $n$. Em seguida, pergunte a ele por $n$ números inteiros e, no final, mostre a ele a soma dos quadrados dos $n$ números que o usuário forneceu. Por exemplo, se as respostas do usuário forem: 3, 4, 2, 2, seu programa deve exibir o resultado da conta $4^2 + 2^2 + 2^2$, que é $24$. Observe que o número 3 não entra na conta porque ele é o valor de $n$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "### Exercício <span class=\"exec\"></span>: cálculo do CR\n",
    "\n",
    "Cada aluno da Universidade Federal do ABC possui um _Coeficiente de Rendimento_ (CR). Segundo [informações oficiais da ProGrad](http://prograd.ufabc.edu.br/guia-da-graduacao#cr-ca-cpk), o CR é \n",
    "\n",
    "> um número indicativo do desenvolvimento do aluno no curso, cujo cálculo considera os conceitos obtidos em todas as disciplinas por ele cursadas. O cálculo do CR leva em conta a média ponderada dos conceitos obtidos em todas as disciplinas cursadas pelo aluno, considerando como peso seus respectivos créditos.\n",
    "\n",
    "Faça um programa para ajudar um aluno da UFABC a computar seus CR. Seu programa deve perguntar pelo numero de disciplinas cursadas. Para cada uma delas, seu programa deve perguntar pelo conceito obtido (A, B, C, D, E, F ou O) e depois pelo número de crétidos da disciplina (teoria + prática). \n",
    "\n",
    "Seu programa deve considerar a seguinte tabela de conversão conceito &rarr; número:\n",
    "\n",
    "|conceito | número |\n",
    "|:--------:|:--------:|\n",
    "| A | 4 |\n",
    "| B | 3 |\n",
    "| C | 2 |\n",
    "| D | 1 | \n",
    "| F ou O | 0 |\n",
    "\n",
    "O CR é uma média ponderada dos conceitos (transformados em números conforme a tabela acima), onde o peso de cada conceito é o número de créditos da disciplina.\n",
    "\n",
    "Ao final, seu programa deve mostrar ao aluno qual é o CR dele."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "\n",
    "### Exercício <span class=\"exec\"></span>: máximo\n",
    "\n",
    "Faça um programa que pede ao usuário para digitar um número inteiro $n > 0$. \n",
    "\n",
    "Depois, seu programa deve perguntar $n$ números racionais (_float_) ao usuário.\n",
    "\n",
    "Finalmente, seu programa deve imprimir o maior valor fornecido pelo usuário.\n",
    "\n",
    "Exemplo: para $n = 10$ e valores $17, 1.2, 4.8, 19, 3, 23.6, 20, 24, 6.1, 12$, seu programa deve imprimir o valor $24.0$.\n",
    "\n",
    "Não use listas para armazenar os números lidos da entrada."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Mais exercícios"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "\n",
    "### Exercício <span class=\"exec\"></span>: divisores\n",
    "\n",
    "Faça um programa que pede ao usuário para digitar um número inteiro $n > 0$. Depois, seu programa deve mostrar todos os divisores de $n$. \n",
    "\n",
    "Exemplo: para $n = 2136$ seu programa deve mostrar os divisores 1, 2, 3, 4, 6, 8, 12, 24, 89, 178, 267, 356, 534, 712, 1068, 2136. Se for mais fácil pra você, pode mostrar um número por linha."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<hr>\n",
    "\n",
    "### Exercício <span class=\"exec\"></span>: primo\n",
    "\n",
    "Um número inteiro $n > 1$ é _primo_ se tem exatamente dois divisores positivos: $1$ e o próprio $n$.\n",
    "\n",
    "Faça um programa que pede ao usuário para digitar um número inteiro $n > 1$ e que decide se esse número é primo ou composto."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# parecido com o exercício de encontrar os divisores de um número"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<hr>\n",
    "\n",
    "### Exercício <span class=\"exec\"></span>: distância total\n",
    "\n",
    "Neste exercício você deve fazer um programa que calcula a distância percorrida por um helicóptero. O helicóptero parte da posição $(0, 0)$, voa em linha reta até a posição $(x_1, y_1)$ e pousa, depois voa em linha reta até a posição $(x_2, y_2)$ e pousa, e assim por diante, até pousar definitivamente na posição $(x_n, y_n)$. Suponha que essas coordenadas são todas inteiras. Seu programa deve fazer o seguinte:\n",
    "* pedir para o usuário digitar o número $n$ de pontos que o helicóptero deve visitar (além da origem);\n",
    "* depois pedir as coordenadas dos pontos, calcular a distância entre cada dois pontos consecutivos e acumular esse valor;\n",
    "* finalmente, seu programa deve mostrar a distância total percorrida pelo helicóptero.\n",
    "\n",
    "Veja um exemplo de execução abaixo.\n",
    "\n",
    "    Quantos heliportos o helicóptero irá visitar? 3\n",
    "    De a coordenada x do heliporto 1? 4\n",
    "    De a coordenada y do heliporto 1? 0\n",
    "    De a coordenada x do heliporto 2? 4\n",
    "    De a coordenada y do heliporto 2? 3\n",
    "    De a coordenada x do heliporto 3? 0\n",
    "    De a coordenada y do heliporto 3? 0\n",
    "    A distância total percorrida é 12.0\n",
    "\n",
    "\n",
    "Não use listas para armazenar as coordenadas.\n",
    "\n",
    "**Dica:** $\\sqrt{x} = x^{1/2}$\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# solução análoga ao exemplo das vendas (mas agora você deve calcular distâncias)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "\n",
    "### Exercício <span class=\"exec\"></span>: segmentos \n",
    "\n",
    "Fonte: [Caderno de Exercícios IME/USP](https://www.ime.usp.br/~macmulti/exercicios/)\n",
    "\n",
    "Dados $n$ e uma seqüência de $n$ números inteiros, determinar quantos segmentos de números iguais consecutivos compõem essa seqüência.\n",
    "\n",
    "Por exemplo, a seqüência 5,  2,  2,  3,  4,  4,  4,  4,  5,  5 é formada por 5 segmentos de números iguais:  \n",
    "\n",
    "$$ 5 ~~~~~~ 2 ~~  2 ~~~~~~  3 ~~~~~~  4 ~~ 4 ~~ 4 ~~ 4 ~~~~~~  5 ~~ 5  $$\n",
    "\n",
    "Não use listas."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<hr>\n",
    "\n",
    "### Exercício <span class=\"exec\"></span>: números em ordem?\n",
    "\n",
    "Faça um programa que pede ao usuário para digitar um número inteiro positivo $n$. Em seguida, peça para ele digitar $n$ números racionais (_float_). Depois que o usuário terminar, seu programa deve e mostrar na tela a palavra \"_crescente_\" se os números racionais digitados pelo usuário estão em ordem crescente ou mostrar \"_não crescente_\" caso contrário. Não use listas para armazenar os $n$ números racionais."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercício <span class=\"exec\"></span>: dicionário\n",
    "\n",
    "Faça um programa que pergunte ao usuário por um número inteiro $n > 0$. \n",
    "\n",
    "Em seguida, seu programa deve ler $n$ palavras da entrada e deve decidir se as palavras foram dadas em ordem lexicográfica (i.e. na ordem do dicionário) e imprimir `ORDENADO` em caso afirmativo; do contrário, seu programa deve imprimir `NÃO ORDENADO`.\n",
    "\n",
    "Não use listas para armazenar as palavras."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a rel=\"license\" href=\"http://creativecommons.org/licenses/by-sa/4.0/\"><img alt=\"Creative Commons License\" style=\"border-width:0\" src=\"https://i.creativecommons.org/l/by-sa/4.0/88x31.png\" /></a><br /><span xmlns:dct=\"http://purl.org/dc/terms/\" href=\"http://purl.org/dc/dcmitype/InteractiveResource\" property=\"dct:title\" rel=\"dct:type\">Python 3 Practice Notebooks</span> by <a xmlns:cc=\"http://creativecommons.org/ns#\" href=\"https://github.com/daniel-ufabc/ipycourse\" property=\"cc:attributionName\" rel=\"cc:attributionURL\">Cristiane Sato, Daniel M. Martin and Mirtha L. F. Venero</a> is licensed under a <a rel=\"license\" href=\"http://creativecommons.org/licenses/by-sa/4.0/\">Creative Commons Attribution-ShareAlike 4.0 International License</a>."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<span style=\"color: red;\">Execute a célula abaixo para melhorar a aparência deste <i>notebook</i>.</span>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "init_cell": true
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<style>\n",
       ".rendered_html h1 {\n",
       "    background-color: #555;\n",
       "    color: white;\n",
       "    padding: .5em;\n",
       "    // border-bottom: 2px solid #000;\n",
       "    // padding-bottom: .6em;\n",
       "    margin-bottom: 1em;\n",
       "}\n",
       "\n",
       ".rendered_html h1 code {\n",
       "    color: #EBB7C5;\n",
       "    background-color: rgba(0,0,0,0);\n",
       "}\n",
       "\n",
       ".rendered_html h2 {\n",
       "    border-bottom: 1px solid #333;\n",
       "    padding-bottom: .6em;\n",
       "}\n",
       "                                      \n",
       ".rendered_html h3 {\n",
       "    color: #034f84;\n",
       "}\n",
       "\n",
       ".rendered_html code  {\n",
       "    padding: 2px 4px;\n",
       "    font-size: 90%;\n",
       "    color: #c7254e;\n",
       "    background-color: #f9f2f4;\n",
       "    border-radius: 4px;\n",
       "}\n",
       "\n",
       ".rendered_html pre code {\n",
       "    padding: 0px;\n",
       "    font-size: 90%;\n",
       "    color: #c7254e;\n",
       "    background-color: rgba(0, 0, 0, 0);\n",
       "}\n",
       "\n",
       "kbd {\n",
       "    border-radius: 3px;  \n",
       "    padding: 2px, 3px;\n",
       "}\n",
       "\n",
       "body {\n",
       "    counter-reset: h1counter excounter;\n",
       "}\n",
       "h1:before {\n",
       "    content: counter(h1counter) \".\\0000a0\\0000a0\";\n",
       "    counter-increment: h1counter;\n",
       "}\n",
       "span.exec:before {\n",
       "    content: counter(excounter);\n",
       "    counter-increment: excounter;\n",
       "}\n",
       "\n",
       "\n",
       "</style>  \n",
       "<script>\n",
       "location.hash = \"#homesweethome\";\n",
       "</script>\n"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "%%html\n",
    "<style>\n",
    ".rendered_html h1 {\n",
    "    background-color: #555;\n",
    "    color: white;\n",
    "    padding: .5em;\n",
    "    // border-bottom: 2px solid #000;\n",
    "    // padding-bottom: .6em;\n",
    "    margin-bottom: 1em;\n",
    "}\n",
    "\n",
    ".rendered_html h1 code {\n",
    "    color: #EBB7C5;\n",
    "    background-color: rgba(0,0,0,0);\n",
    "}\n",
    "\n",
    ".rendered_html h2 {\n",
    "    border-bottom: 1px solid #333;\n",
    "    padding-bottom: .6em;\n",
    "}\n",
    "                                      \n",
    ".rendered_html h3 {\n",
    "    color: #034f84;\n",
    "}\n",
    "\n",
    ".rendered_html code  {\n",
    "    padding: 2px 4px;\n",
    "    font-size: 90%;\n",
    "    color: #c7254e;\n",
    "    background-color: #f9f2f4;\n",
    "    border-radius: 4px;\n",
    "}\n",
    "\n",
    ".rendered_html pre code {\n",
    "    padding: 0px;\n",
    "    font-size: 90%;\n",
    "    color: #c7254e;\n",
    "    background-color: rgba(0, 0, 0, 0);\n",
    "}\n",
    "\n",
    "kbd {\n",
    "    border-radius: 3px;  \n",
    "    padding: 2px, 3px;\n",
    "}\n",
    "\n",
    "body {\n",
    "    counter-reset: h1counter excounter;\n",
    "}\n",
    "h1:before {\n",
    "    content: counter(h1counter) \".\\0000a0\\0000a0\";\n",
    "    counter-increment: h1counter;\n",
    "}\n",
    "span.exec:before {\n",
    "    content: counter(excounter);\n",
    "    counter-increment: excounter;\n",
    "}\n",
    "\n",
    "\n",
    "</style>  \n",
    "<script>\n",
    "location.hash = \"#homesweethome\";\n",
    "</script>"
   ]
  }
 ],
 "metadata": {
  "anaconda-cloud": {},
  "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.5.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}