{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# MiniEP5 - MAC0110 - Introdução à Computação"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "NOME: insira seu nome\n",
    "\n",
    "NUSP: insira seu número USP"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Parte 0 - Testes automatizados\n",
    "\n",
    "**NÃO ALTERE O CÓDIGO ABAIXO**\n",
    "\n",
    "Rode o trecho de código abaixo após terminar a tarefa para verificar se \n",
    "suas funções estão funcionando como o esperado. Não é necessário \n",
    "entender o código abaixo, mas já é possível entender :). \n",
    "\n",
    "Lembrando que, na correção, utilizaremos também testes adicionais."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Tudo ok :)"
     ]
    }
   ],
   "source": [
    "function test()\n",
    "    if !palindromo(0) ||\n",
    "            !palindromo(8) ||\n",
    "            !palindromo(66) ||\n",
    "            !palindromo(10001) ||\n",
    "            palindromo(1357) ||\n",
    "            palindromo(112233)\n",
    "        return \"Erro. Verifique sua função palindromo(n)\"\n",
    "    end\n",
    "    \n",
    "    if !digitos_decrescentes(0) ||\n",
    "            !digitos_decrescentes(8) ||\n",
    "            !digitos_decrescentes(21) ||\n",
    "            !digitos_decrescentes(930) ||\n",
    "            digitos_decrescentes(200) ||\n",
    "            digitos_decrescentes(404)\n",
    "        return \"Erro. Verifique sua função digitos_decrescentes(n)\"\n",
    "    end\n",
    "    \n",
    "    return \"Tudo ok :)\"\n",
    "end\n",
    "\n",
    "print(test())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Parte 1 - Números palíndromos\n",
    "\n",
    "Palíndromos são palavras, frases ou números que são iguais se lidos de trás para frente e de frente para trás. Exemplos: `arara`, `1001` e `A mãe te ama`.\n",
    "\n",
    "Crie uma função `palindromo(n)` que recebe um número inteiro `n`, e devolve um booleano indicando se o `n` é palíndromo ou não.\n",
    "\n",
    "Considere que `n >= 0` e que números de um único dígito são palíndromos.\n",
    "\n",
    "**Obs:** você _DEVE_ usar um laço para resolver este exercício (pode ser `while` ou `for`).\n",
    "\n",
    "**Dica:** Use a função `imprimedigito(n)` vista em sala como base para te ajudar neste exercício. Você também pode usar o operador `÷` para fazer uma divisão inteira. Exemplo: `5 / 2 = 2.5`, enquanto `5 ÷ 2 = 2`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "| n | Retorno esperado |\n",
    "|--:|-----------------:|\n",
    "| 0 | true |\n",
    "| 1 | true |\n",
    "| 101 | true |\n",
    "| 1001 | true |\n",
    "| 123 | false |\n",
    "| 1010 | false |\n",
    "| 4242 | false |"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "palindromo (generic function with 1 method)"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# escreva o código da parte 1 aqui\n",
    "\n",
    "function palindromo(n)\n",
    "    n_original = n\n",
    "    n_invertido = 0\n",
    "\n",
    "    while n != 0\n",
    "        resto = n % 10\n",
    "        n_invertido = (n_invertido * 10) + resto\n",
    "        n ÷= 10\n",
    "    end\n",
    "\n",
    "    return n_original == n_invertido      \n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "true\n",
      "true\n",
      "true\n",
      "true\n",
      "false\n",
      "false\n",
      "false\n"
     ]
    }
   ],
   "source": [
    "println(palindromo(0))\n",
    "println(palindromo(1))\n",
    "println(palindromo(101))\n",
    "println(palindromo(1001))\n",
    "println(palindromo(123))\n",
    "println(palindromo(1010))\n",
    "println(palindromo(4242))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Parte 2 - Dígitos decrescentes\n",
    "\n",
    "Crie uma função `digitos_decrescentes(n)` que recebe um número inteiro `n`, e devolve um booleano indicando se seus dígitos estão em ordem decrescente ou não. **Atenção:** você deve verificar se os dígitos estão em ordem estritamente decrescente, ou seja, se um número possuir os dígitos `abcd` então `a > b > c > d`.\n",
    "\n",
    "Considere que `n >= 0` e que números de apenas um dígito devolvem `true`.\n",
    "\n",
    "**Obs:** você _DEVE_ usar um laço para resolver este exercício (pode ser `while` ou `for`).\n",
    "\n",
    "**Dica:** Novamente, use a função `imprimedigito(n)` vista em sala como base para te ajudar neste exercício."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "| n | Retorno esperado |\n",
    "|--:|-----------------:|\n",
    "| 0 | true |\n",
    "| 1 | true |\n",
    "| 10 | true |\n",
    "| 321 | true |\n",
    "| 12 | false |\n",
    "| 33 | false |\n",
    "| 100 | false |\n",
    "| 123 | false |"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "digitos_decrescentes (generic function with 1 method)"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "function digitos_decrescentes(n)\n",
    "    ultimo = -1\n",
    "\n",
    "    while n != 0\n",
    "        atual = n % 10\n",
    "        \n",
    "        if ultimo >= atual\n",
    "            return false\n",
    "        end\n",
    "\n",
    "        ultimo = atual \n",
    "        n ÷= 10\n",
    "    end\n",
    "\n",
    "    return true    \n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "true\n",
      "true\n",
      "true\n",
      "true\n",
      "true\n",
      "true\n",
      "false\n",
      "false\n",
      "false\n",
      "false\n",
      "false\n",
      "false\n"
     ]
    }
   ],
   "source": [
    "println(digitos_decrescentes(0))\n",
    "println(digitos_decrescentes(1))\n",
    "println(digitos_decrescentes(10))\n",
    "println(digitos_decrescentes(21))\n",
    "println(digitos_decrescentes(321))\n",
    "println(digitos_decrescentes(4321))\n",
    "println(digitos_decrescentes(12))\n",
    "println(digitos_decrescentes(33))\n",
    "println(digitos_decrescentes(100))\n",
    "println(digitos_decrescentes(123))\n",
    "println(digitos_decrescentes(200))\n",
    "println(digitos_decrescentes(404))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Playground\n",
    "\n",
    "Utilize a área abaixo para testar suas funções, criar novas e brincar com a linguagem. Essa parte não será avaliada."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 288,
   "metadata": {},
   "outputs": [],
   "source": [
    "# utilize essa área como playground"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Julia 1.3.1",
   "language": "julia",
   "name": "julia-1.3"
  },
  "language_info": {
   "file_extension": ".jl",
   "mimetype": "application/julia",
   "name": "julia",
   "version": "1.3.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}