05.Controle de Fluxo - Iterações.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---Iterações\" data-toc-modified-id=\"Controle-de-Fluxo---Iterações-1\"><span class=\"toc-item-num\">1&nbsp;&nbsp;</span>Controle de Fluxo - Iterações</a></span><ul class=\"toc-item\"><li><span><a href=\"#Laços-while\" data-toc-modified-id=\"Laços-while-1.1\"><span class=\"toc-item-num\">1.1&nbsp;&nbsp;</span>Laços <strong>while</strong></a></span><ul class=\"toc-item\"><li><span><a href=\"#Questões\" data-toc-modified-id=\"Questões-1.1.1\"><span class=\"toc-item-num\">1.1.1&nbsp;&nbsp;</span>Questões</a></span></li><li><span><a href=\"#Exercício\" data-toc-modified-id=\"Exercício-1.1.2\"><span class=\"toc-item-num\">1.1.2&nbsp;&nbsp;</span>Exercício</a></span></li></ul></li><li><span><a href=\"#Laços-for\" data-toc-modified-id=\"Laços-for-1.2\"><span class=\"toc-item-num\">1.2&nbsp;&nbsp;</span>Laços <strong>for</strong></a></span></li><li><span><a href=\"#A-função-range\" data-toc-modified-id=\"A-função-range-1.3\"><span class=\"toc-item-num\">1.3&nbsp;&nbsp;</span>A função <code>range</code></a></span><ul class=\"toc-item\"><li><span><a href=\"#Exercícios\" data-toc-modified-id=\"Exercícios-1.3.1\"><span class=\"toc-item-num\">1.3.1&nbsp;&nbsp;</span>Exercícios</a></span></li></ul></li><li><span><a href=\"#Escolhendo-entre-for-e-while\" data-toc-modified-id=\"Escolhendo-entre-for-e-while-1.4\"><span class=\"toc-item-num\">1.4&nbsp;&nbsp;</span>Escolhendo entre <strong>for</strong> e <strong>while</strong></a></span><ul class=\"toc-item\"><li><span><a href=\"#Exercício:-Potenciação\" data-toc-modified-id=\"Exercício:-Potenciação-1.4.1\"><span class=\"toc-item-num\">1.4.1&nbsp;&nbsp;</span>Exercício: Potenciação</a></span></li><li><span><a href=\"#Exercício:-A-sequencia-$3n-+-1$.\" data-toc-modified-id=\"Exercício:-A-sequencia-$3n-+-1$.-1.4.2\"><span class=\"toc-item-num\">1.4.2&nbsp;&nbsp;</span>Exercício: A sequencia $3n + 1$.</a></span></li></ul></li><li><span><a href=\"#Variáveis-Indicadoras\" data-toc-modified-id=\"Variáveis-Indicadoras-1.5\"><span class=\"toc-item-num\">1.5&nbsp;&nbsp;</span>Variáveis Indicadoras</a></span><ul class=\"toc-item\"><li><span><a href=\"#Exercício\" data-toc-modified-id=\"Exercício-1.5.1\"><span class=\"toc-item-num\">1.5.1&nbsp;&nbsp;</span>Exercício</a></span></li></ul></li><li><span><a href=\"#Variáveis-Contadoras\" data-toc-modified-id=\"Variáveis-Contadoras-1.6\"><span class=\"toc-item-num\">1.6&nbsp;&nbsp;</span>Variáveis Contadoras</a></span><ul class=\"toc-item\"><li><span><a href=\"#Questões\" data-toc-modified-id=\"Questões-1.6.1\"><span class=\"toc-item-num\">1.6.1&nbsp;&nbsp;</span>Questões</a></span></li></ul></li><li><span><a href=\"#Exercício\" data-toc-modified-id=\"Exercício-1.7\"><span class=\"toc-item-num\">1.7&nbsp;&nbsp;</span>Exercício</a></span></li></ul></li></ul></div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Controle de Fluxo - Iterações\n",
    "\n",
    "Até agora vimos como escrever programas capazes de executar comandos de forma linear, e, se necessário, tomar decisões com relação a executar ou não um bloco de comandos.\n",
    "Entretanto, eventualmente faz-se necessário executar um bloco de comandos várias vezes para obter o resultado esperado. A execução repetida de um conjunto de instruções é chamada de iteração. Python tem duas instruções para iteração - a declaração **for**, e a instrução **while**."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Laços **while**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Executa um bloco de código atendendo a uma condição.\n",
    "\n",
    "Sintaxe:\n",
    "```python\n",
    "    while <condição>:\n",
    "        <bloco de código>\n",
    "        continue\n",
    "        break\n",
    "    else:\n",
    "        <bloco de código>\n",
    "```            \n",
    "O bloco de código dentro do laço `while` é repetido enquanto a condição do laço estiver sendo avaliada como verdadeira."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "![while](img/while-statement.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "**Exemplo:** Calcule quantas vezes o dígito 0 aparece no número inteiro calculado abaixo."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "num = 2**100\n",
    "print(num)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "count = 0\n",
    "\n",
    "while num > 0:             # O que acontece se mudarmos a condição para >=0?\n",
    "    if num % 10 == 0:\n",
    "        count = count + 1\n",
    "    num = num // 10\n",
    "\n",
    "print(count)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "**Exemplo:** Jogo de Adivinhação"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "import random                      # Import the random module \n",
    "\n",
    "number = random.randrange(1, 101) # Get random number between 1 and 100\n",
    "guesses = 0\n",
    "guess = int(input(\"Adivinhe meu número entre 1 e 100:\"))\n",
    "\n",
    "while guess != number:\n",
    "    guesses += 1\n",
    "    if guess > number:\n",
    "        print(guess, \"está acima.\") \n",
    "    elif guess < number:\n",
    "        print(guess, \" está abaixo.\")\n",
    "    guess = int(input(\"tente novamente: \"))\n",
    "\n",
    "print(\"\\nÓtimo, você acertou em\", guesses, \" tentativas!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "**Exercício:** Repita o Jogo de adivinhação dando a opção do jogador de desistir, por exemplo, escolhendo o número $0$.\n",
    "- Dica: Use os comandos **break** & **else** dos laços **while**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Questões\n",
    "\n",
    "1. O que acontece se a condição no comando while for falsa na primeira vez?\n",
    "2. O que acontece se a condição no comando while for sempre verdadeira?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Exercício\n",
    "\n",
    "- Supondo que a população de um país A seja da ordem de 80000 habitantes com uma taxa anual de crescimento de 3% e que a população de B seja 200000 habitantes com uma taxa de crescimento de 1.5%. Faça um programa que calcule e escreva o número de anos necessários para que a população do país A ultrapasse ou iguale a população do país B, mantidas as taxas de crescimento."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "code_folding": [
     0
    ],
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "# solução\n",
    "\n",
    "A = 80000\n",
    "B = 200000\n",
    "n = 0\n",
    "while A < B:\n",
    "    n += 1\n",
    "    A += A * 0.03\n",
    "    B += B * 0.015\n",
    "print(f'Em {n} anos a população de A será de {A:.0f} ultrapassando a população de B em {(A - B):.0f} pessoas.')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "- Altere o programa anterior permitindo ao usuário informar as populações e as taxas de crescimento iniciais. Valide a entrada e permita repetir a operação."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Laços **for**\n",
    "\n",
    "É a estrutura de repetição mais usada no Python. A instrução aceita não só sequências estáticas, mas também sequências geradas por iteradores. Iteradores são estruturas que permitem iterações, ou seja, acesso aos itens de uma coleção de elementos, de forma sequencial. Nós estudaremos iteradores mais à frente."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Durante a execução de um laço *for*, a variável aponta para um elemento da sequência. A cada iteração, a variável é atualizada, para que o bloco de código do *for* processe o elemento correspondente.\n",
    "\n",
    "As cláusula opcional *break* interrompe o laço e a cláusula opcional *continue* passa para a próxima iteração. O código dentro do *else* (opcional) é executado ao final do laço, a não ser que o laço tenha sido interrompido por *break*.\n",
    "\n",
    "Sintaxe:\n",
    "```python\n",
    "    for <variable> in <sequência>:\n",
    "        <bloco de código>\n",
    "        continue\n",
    "        break\n",
    "    else:\n",
    "        <bloco de código>\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "![for](img/for-statement.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Exemplo: Vamos resolver o mesmo problema anterior usando o tipo \\textbf{str} ao invés de \\textbf{int}."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "num = 2**100\n",
    "count = 0\n",
    "for digit in str(num):\n",
    "    #print(digit, type(digit))\n",
    "    if digit == \"0\":\n",
    "        count = count + 1\n",
    "\n",
    "print(count)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "   - a título de curiosidade a solução mais eficiente em python é usando funções builtin de str:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "num = 2**100\n",
    "count = str.count(str(num), \"0\")\n",
    "print(count)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## A função `range`\n",
    "\n",
    "A função `range()` retorna uma série numérica no intervalo enviado como argumento.\n",
    "A série retornada é um objeto iterável  tipo range e os elementos contidos serão gerados sob demanda.\n",
    "É comum o uso da função `range()` com laços for."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "range( stop )                  #primeira definição ou definição simplificada\n",
    "range( [start], stop[, step] ) #segunda definição ou definição completa"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "A função `range()` exige a definição do último elemento da sequência numérica. Por padrão, o parâmetro start será igual a 0 e o step igual a 1:\n",
    "\n",
    "- start - valor onde o intervalo deve começar\n",
    "- stop - valor (menos um) onde o intervalo deve finalizar\n",
    "- step - passo (intervalo entre os elementos da sequência)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Note que o parâmetro stop possui o intervalo aberto, isto é, o número definido não estará contido na sequência numérica:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "for num in range(5):\n",
    "    print(num)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Exemplo: A soma dos números impares no intervalo de 0 a 100, usando uma variável \\textbf{acumuladora}."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "code_folding": [],
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "soma = 0\n",
    "for impar in range(1, 100, 2):\n",
    "    soma = soma + impar\n",
    "print(\"A soma dos impares até 100 é: \", soma)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Exercícios\n",
    "- Leia um inteiro positivo $n$, e imprima as potências: $2^0$, $2^1$, . . . , $2^n$.\n",
    "Dica: Use uma variável acumuladora que no início da i-ésima iteração de um laço, possui o valor $2^i$. Imprima este valor e atualize a variável acumuladora para a próxima iteração, multiplicando esta variável por 2."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "code_folding": [
     0
    ],
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "# solução\n",
    "n = int(input(\"Forneça a maior potência: \"))\n",
    "p = 1\n",
    "for i in range(n + 1):\n",
    "    print(f\"2 elevado à potencia {i} é igual a {p}\")\n",
    "    p = p * 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "- Faça um programa que mostre os n termos da Série a seguir:\n",
    "```\n",
    "S = 1/1 + 2/3 + 3/5 + 4/7 + 5/9 + ... + n/m. \n",
    "```\n",
    "Imprima no final a soma da série."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "code_folding": [
     0
    ],
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "# solução:\n",
    "\n",
    "n = int(input(\"Forneça o número de termos da série: \"))\n",
    "m = 1\n",
    "S = 1\n",
    "print(\"1/1\", end=' ')\n",
    "for i in range(2, n+1):\n",
    "    m += 2\n",
    "    S += i / m\n",
    "    print(f\"+ {i}/{m}\", end=' ')\n",
    "print(f\"= {S:.4f}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Escolhendo entre **for** e **while**\n",
    "Use um laço **for**, se você souber, antes de iniciar o laço, o número máximo de vezes que você precisará executar o corpo do laço. Por exemplo, se você estiver percorrendo uma lista de elementos, você sabe que o número máximo de iterações do laço que você pode precisar é \"todos os elementos da lista\". Problemas como: \"itere este modelo de previsão de tempo para 1000 ciclos\", ou \"pesquise esta lista de palavras\", ou ainda, \"encontre todos os números primos até 10000\", sugerem que um laço **for** é o mais adequado.\n",
    "\n",
    "Em contrapartida, se você precisar repetir alguma computação até que alguma condição seja atendida, e você não pode calcular antecipadamente quando isso acontecerá, como fizemos no \"programa de advinhação\", você precisará de um laço **while**.\n",
    "\n",
    "Chamamos de \"iteração definida\" o primeiro caso $-$ temos alguns limites definidos para o que é necessário. O último caso é chamado de \"iteração indefinida\" $-$ não temos certeza de quantas iterações precisamos $-$ nem podemos estabelecer um limite superior!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Exercício: Potenciação\n",
    "Faça um programa que lê dois números inteiros positivos $a$ e $b$. Utilizando laços (i.e., não utilizar $**$), o seu programa deve calcular e imprimir o valor $a^b$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "code_folding": [
     0
    ],
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "# solução\n",
    "#a, b = [int(num) for num in input(\"Forneça a e b, separados por espaço: \").split()]\n",
    "\n",
    "a = int(input(\"Forneça o valor de a: \"))\n",
    "b = int(input(\"Forneça o valor de b: \"))\n",
    "p = 1\n",
    "for _ in range(b):\n",
    "    p *= a \n",
    "print(f\"{a} elevado à potencia {b} é igual a {p}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Exercício: A sequencia $3n + 1$.\n",
    "Também conhecida como [Conjectura Collatz](https://en.wikipedia.org/wiki/Collatz_conjecture). Esta sequência tem fascinado matemáticos por vários anos.\n",
    "A regra para criar a sequência é começar com um dado $n$, e gerar o próximo termo da sequência a partir de $n$ da seguinte forma: se $n$ for par dividimos $n$ por $2$, ou senão, multiplicamos $n$ por $3$ e somamos $1$ quando $n$ for impar. A sequência termina quando $n$ se tornar $1$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "code_folding": [
     0,
     3
    ],
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "# solução\n",
    "n = int(input(\"Give-me an integer: \"))\n",
    "\"\"\" Print the 3n+1 sequence from n, terminating when it reaches 1.\"\"\"\n",
    "while n != 1:\n",
    "    print(n)\n",
    "    if n % 2 == 0:        # n is even\n",
    "        n = n // 2\n",
    "    else:                 # n is odd\n",
    "        n = n * 3 + 1\n",
    "print(n)                  # the last print is 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Variáveis Indicadoras"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Um uso comum de laços é para a verificação se um determinado objeto, ou conjunto de objetos, satisfaz uma propriedade ou não. Um padrão que pode ser útil na resolução deste tipo de problema é o uso de uma variável \\textbf{indicadora}:\n",
    "\n",
    "- Assumimos que o objeto satisfaz a propriedade (indicadora = True).\n",
    "- Com um laço verificamos se o objeto realmente satisfaz a propriedade.\n",
    "- Se em alguma iteração descobrirmos que o objeto não satisfaz a propriedade, então fazemos (indicadora = False)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Vamos usar este padrão na determinação se um número $n$ é primo ou não.\n",
    "\n",
    "- Um número é primo se seus únicos divisores são $1$ e ele mesmo.\n",
    "\n",
    "Dado um número $n$ como detectar se este é ou não primo?\n",
    "\n",
    "1. Leia o número $n$.\n",
    "2. Faça a variável indicadora = True, assumindo que $n$ é primo.\n",
    "3. Teste se nenhum dos números entre $2$ e $n − 1$ divide $n$. Lembre-se que o operador % retorna o resto da divisão. Portanto $a % b$ é zero se e somente se $b$ divide $a$.\n",
    "4. Se o resto da divisão for igual a zero então faça indicadora = False. Com isto descobrimos que $n$ não é primo."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "code_folding": [
     0
    ],
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "# solução\n",
    "n = int(input(\"Digite um número inteiro positivo:\"))\n",
    "div = 2\n",
    "e_primo = 1\n",
    "while div <= n-1:\n",
    "    if n % div == 0:\n",
    "        e_primo = False\n",
    "        break\n",
    "    div = div + 1\n",
    "if e_primo:\n",
    "    print(\"É primo!!\")\n",
    "else:\n",
    "    print(\"Não é primo!!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Exercício\n",
    "Escreva um programa que lê $n$ números inteiros do teclado, e no final informa se os números lidos estão ou não em ordem crescente.\n",
    "Dica: Use duas variáveis, uma que guarda o número lido na iteração atual, e uma que guarda o número lido na iteração anterior.\n",
    "Os números estarão ordenados se a condição (anterior <= atual) for válida durante a leitura de todos os números."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "code_folding": [
     0
    ],
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "# solução\n",
    "n = int(input(\"Digite o total de números:\"))\n",
    "anterior = int(input(\"Inicie a sequência:\"))\n",
    "i = 1 #leu um número\n",
    "ordenado = True\n",
    "while (i < n) and ordenado:\n",
    "    atual = int(input(\"continue:\"))\n",
    "    i += 1 #leu mais um número\n",
    "    if atual < anterior:\n",
    "        ordenado = False\n",
    "    anterior = atual\n",
    "if ordenado:\n",
    "    print(\"Sequência fornecida está ordenada\")\n",
    "else:\n",
    "    print(\"Sequência fornecida não está ordenada\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Variáveis Contadoras"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Considere ainda o uso de laços para a verificação se um determinado objeto, ou conjunto de objetos, satisfaz uma propriedade ou não.\n",
    "Um outro padrão que pode ser útil é o uso de uma variável \\textbf{contadora}.\n",
    "\n",
    "- Esperamos que um objeto satisfaça $x$ vezes uma sub-propriedade. Usamos um laço e uma variável que conta o número de vezes que o objeto tem a sub-propriedade satisfeita.\n",
    "- Ao terminar o laço, se a variável contadora for igual à $x$ então o objeto satisfaz a propriedade."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Vamos revisitar o problema de determinar se um número $n$, inteiro, é primo ou não.\n",
    "Podemos usar uma variável que conta quantos números dividem $n$. Se o número de divisores for $0$, então n é primo."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "code_folding": [
     0
    ],
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "# solução\n",
    "n = int(input(\"Digite um número inteiro positivo:\"))\n",
    "div = 2\n",
    "divisores = 0\n",
    "while div <= n-1:\n",
    "    if n % div == 0:\n",
    "        divisores += 1\n",
    "        break\n",
    "    div += 1\n",
    "if divisores == 0:\n",
    "    print(\"É primo!!\")\n",
    "else:\n",
    "    print(\"Não é primo!!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Questões\n",
    "1. No exemplo dos números primos não precisamos testar todos os números entre $2, . . . , n − 1$, para verificar se dividem ou não $n$. Basta testarmos até $n/2$. Por que? Qual o maior divisor possível de $n$?\n",
    "\n",
    "2. Na verdade basta testarmos os números $2, . . . , \\sqrt{n}$. Por que?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Exercício\n",
    "\n",
    "Escreva um programa Python para obter a série de Fibonacci entre 0 a 50.\n",
    "\n",
    "Nota: A seqüência de Fibonacci é a série de números:\n",
    "0, 1, 1, 2, 3, 5, 8, 13, 21, ....\n",
    "onde cada número que segue é encontrado somando os dois números antes dele."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "code_folding": [
     0
    ],
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "# Solução:\n",
    "x, y = 0, 1\n",
    " \n",
    "while y < 50:\n",
    "    print(y)\n",
    "    x, y = y, x + y"
   ]
  }
 ],
 "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
}