{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Aula de primeiro de Abril ##\n",
    "\n",
    "A ideia da aula de hoje é de se mostrar que há outra forma de se fazer um número arbitrário de repetições sem usar recursão, mas com o uso de laços.\n",
    "\n",
    "O primeiro a ser visto é o __while__ ou seja enquanto, na sua forma básica ele é da seguinte forma\n",
    "\n",
    "while condição\n",
    "\n",
    "  comandos\n",
    "\n",
    "end\n",
    "\n",
    "Ou seja, enquando a condição for válida, os comandos são executados.\n",
    "Vamos a um exemplo:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "function regressiva(n)\n",
    "    while n > 0\n",
    "        print(n, \" \")\n",
    "        print(\" . \")\n",
    "        n = n - 1\n",
    "    end\n",
    "    println(\"Fim\")\n",
    "end\n",
    "regressiva(10)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Claro que a condição de parada pode ser mais complexa e o número de comandos dentro do corpo do __while__ pode ser variado, e sim, nada impede de se ter um __while__ dentro de outro __while__"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "function regressivalenta(n)\n",
    "    while n > 0\n",
    "        print(n, \" \")\n",
    "        i = 10\n",
    "        while i > 0\n",
    "            print(\"loading \")\n",
    "            sleep(10)\n",
    "            i = i - 1\n",
    "        end\n",
    "        println(\"...\")\n",
    "        n = n - 1\n",
    "    end\n",
    "    println(\"Fim\")\n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "regressivalenta(8)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Para continuar, vamos refazer os mesmos exercícios da aula anterior, agora usando o __while__. São eles:\n",
    "* Verificar se um número é primo\n",
    "* Imprimir os n primeiros primos\n",
    "* Imprimir os n primeiros primos de Mersenne"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "imprimenmersenne (generic function with 1 method)"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "function testedivisores()\n",
    "    if ndivisores(14) != 4\n",
    "        println(\"Não funcionou para 14: \",ndivisores(14))\n",
    "    end\n",
    "    if ndivisores(16) != 5\n",
    "        println(\"Não funcionou para 16: \", ndivisores(16))\n",
    "    end\n",
    "    if ndivisores(1) != 1\n",
    "        println(\"Não funcionou para 1: \", ndivisores(1))\n",
    "    end\n",
    "    if ndivisores(1024) != 11\n",
    "        println(\"Não funcionou para 1024\", ndivisores(1024))\n",
    "    end\n",
    "    if ndivisores(0) != 0\n",
    "        println(\"Não funcionou para zero\", ndivisores(0))\n",
    "    end\n",
    "    if ndivisores(13) != 2\n",
    "        println(\"Não funcionou para 13\", ndivisores(13))\n",
    "    end\n",
    "    println(\"Final dos testes\")\n",
    "end    \n",
    "     \n",
    "\n",
    "function ndivisores(n)\n",
    "    divi = 0\n",
    "    i = 1\n",
    "    while i < sqrt(n) \n",
    "        if n % i == 0\n",
    "            divi += 1\n",
    "        end\n",
    "        i += 1\n",
    "    end\n",
    "    divi *= 2\n",
    "    if i == sqrt(n)\n",
    "        divi += 1\n",
    "    end\n",
    "    return divi\n",
    "end    \n",
    "\n",
    "function eprimo(n)\n",
    "    if ndivisores(n) == 2\n",
    "        return true\n",
    "    else\n",
    "        return false\n",
    "    end\n",
    "end\n",
    "\n",
    "function imprimenprimos(x)\n",
    "    i = 0\n",
    "    candidato = 1\n",
    "    while i < x\n",
    "        if eprimo(candidato)\n",
    "            println(candidato)\n",
    "            i += 1\n",
    "        end\n",
    "        candidato += 1\n",
    "    end\n",
    "end\n",
    "\n",
    "function imprimenmersenne(x)\n",
    "    i = 0\n",
    "    pot = 0\n",
    "    while i < x\n",
    "        if eprimo(2^pot - 1)\n",
    "            println(\"2^\", pot, \"-1 é primo: \", 2^pot -1)\n",
    "            i += 1\n",
    "        end\n",
    "        pot += 1\n",
    "    end\n",
    "end\n",
    "        "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Escolha um dos exercícios de repetição das aulas anteriores para fazermos com o __while__"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2^2-1 é primo: 3\n",
      "2^3-1 é primo: 7\n",
      "2^5-1 é primo: 31\n",
      "2^7-1 é primo: 127\n",
      "2^13-1 é primo: 8191\n",
      "2^17-1 é primo: 131071\n",
      "2^19-1 é primo: 524287\n",
      "2^31-1 é primo: 2147483647\n"
     ]
    }
   ],
   "source": [
    "imprimenmersenne(8)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "12586269025"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "function test()\n",
    "    if fibo2(1) != 1 ||\n",
    "            fibo2(2) != 1||\n",
    "            fibo2(5) != 5||\n",
    "            fibo2(10) != 55 ||\n",
    "            fibo2(50) != 12586269025\n",
    "        return \"Erro. Verifique sua função fibo2(n)\"\n",
    "    end\n",
    "    return \"Final dos testes\"\n",
    "end\n",
    "\n",
    "function fibo2(n)\n",
    "  a = 1\n",
    "  b = 1\n",
    "  i = 1\n",
    "  while i < n\n",
    "    temp = a + b\n",
    "    a = b\n",
    "    b = temp\n",
    "    i += 1\n",
    "  end\n",
    "  return a\n",
    "end\n",
    "\n",
    "test()\n",
    "fibo2(50)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Como vocês devem ter percebido um while que começa em 1 e vai até $n$, de um em um é muito usual. Logo há um comando que resume isso, o __for__\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n",
      "4\n",
      "5\n",
      "6\n",
      "7\n",
      "8\n"
     ]
    }
   ],
   "source": [
    "for j = 3:8\n",
    "    println(j)\n",
    "end"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Historicamente, o __for__ foi criado para acompanhar operações com vetores e matrizes, mas é usado em diversas situações atualmente. Em Julia o comando __for__ voltou as origens\n",
    "\n",
    "Agora escolha um exercício para resolvermos com o __for__ :)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"Final dos testes\""
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "function test()\n",
    "    if fibo2(1) != 1 ||\n",
    "            fibo2(2) != 1||\n",
    "            fibo2(5) != 5||\n",
    "            fibo2(10) != 55 ||\n",
    "            fibo2(50) != 12586269025\n",
    "        return \"Erro. Verifique sua função fibo2(n)\"\n",
    "    end\n",
    "    return \"Final dos testes\"\n",
    "end\n",
    "\n",
    "function fibo2(n)\n",
    "  a = 1\n",
    "  b = 1\n",
    "  i = 1\n",
    "  for i in 1:n-1\n",
    "    temp = a + b\n",
    "    a = b\n",
    "    b = temp\n",
    "  end\n",
    "  return a\n",
    "end\n",
    "test()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Há dois comandos usados em laços, o __break__ e o __continue__ vamos ver como eles funcionam no __for__ abaixo:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "3\n",
      "5\n",
      "7\n",
      "9\n"
     ]
    }
   ],
   "source": [
    "for i in 1:20\n",
    "    if i > 10\n",
    "        break\n",
    "    end\n",
    "    if i % 2 == 0\n",
    "        continue\n",
    "    end\n",
    "    println(i)\n",
    "   \n",
    "end\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Mas, notem que o uso de __continue__ e __break__ nem sempre ajuda a entender o código."
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Julia 1.1.1",
   "language": "julia",
   "name": "julia-1.1"
  },
  "language_info": {
   "file_extension": ".jl",
   "mimetype": "application/julia",
   "name": "julia",
   "version": "1.1.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}