Macmulti/exercicios_com_inteiros.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Exercícios com Inteiros\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercício 1\n",
    "Dada uma seqüência de números inteiros não-nulos, seguida por $0$, imprimir seus quadrados."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def main():\n",
    "    n = int(input('Digite um número inteiro, 0 para canelar: '))\n",
    "    soma = 0\n",
    "\n",
    "    while n != 0:\n",
    "        soma += n\n",
    "        n = int(input('Digite um número inteiro, 0 para canelar: '))\n",
    "\n",
    "    print(f'Soma: {soma}')\n",
    "\n",
    "\n",
    "main()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercício 2\n",
    "Dado um número inteiro positivo $n$, calcular a soma dos $n$ primeiros números inteiros positivos."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def main():\n",
    "    \n",
    "    soma = 0\n",
    "    n = int(input('Digite um numero para calcular a soma dos n primeiros numeros inteiros: '))\n",
    "\n",
    "    for i in range(1, n + 1):\n",
    "        soma += i\n",
    "\n",
    "    print(f'a soma dos numeros de 0 ate {n} eh: {soma}')\n",
    "\n",
    "\n",
    "main()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercício 3\n",
    "Dado um número inteiro positivo $n$, imprimir os $n$ primeiros naturais ímpares.\n",
    "\n",
    "Exemplo: Para $n = 4$ a saída deverá ser $1, 3, 5, 7$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CPU times: user 4 µs, sys: 1 µs, total: 5 µs\n",
      "Wall time: 10 µs\n"
     ]
    },
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Digite a quantidade de numeros impares que serao impressos:  10\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "3\n",
      "5\n",
      "7\n",
      "9\n",
      "11\n",
      "13\n",
      "15\n",
      "17\n",
      "19\n"
     ]
    }
   ],
   "source": [
    "def main():\n",
    "\n",
    "    n = int(input('Digite a quantidade de numeros impares que serao impressos: '))\n",
    "\n",
    "    for i in range(0, n):\n",
    "        print(i*2 + 1)\n",
    "\n",
    "\n",
    "main()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercício 4\n",
    "Dados um inteiro $x$ e um inteiro não-negativo $n$, calcular $x^n$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# O jeito que provavelmente vão pedir para fazer\n",
    "def main():\n",
    "    \n",
    "    x = int(input('Digite um valor de x: '))\n",
    "    n = int(input('Digite um valor de n: '))\n",
    "    \n",
    "    prod = 1\n",
    "    \n",
    "    for i in range(n):\n",
    "        prod *= x\n",
    "    \n",
    "main()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Outro jeito ex.4\n",
    "def main():\n",
    "    \n",
    "    x = int(input('Digite um valor de x: '))\n",
    "    n = int(input('Digite um valor de n: '))    \n",
    "    \n",
    "    print(f'{x} elevado a {n} é iguala {x**n}')  # o operador ** significa \"elevado\"\n",
    "    \n",
    "    \n",
    "main()    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercício 5\n",
    "Uma loja de discos anota diariamente durante o mês de março a quantidade de discos vendidos. Determinar em que dia desse mês ocorreu a maior venda e qual foi a quantidade de discos vendida nesse dia\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def main():\n",
    "    \n",
    "    maior = 0\n",
    "    for i in range(1,32):\n",
    "        discos_vendidos = int(input(f'Digite a quantidade de discos vendidos no dia {i} de março: '))\n",
    "\n",
    "        if discos_vendidos > maior:\n",
    "            maior = discos_vendidos\n",
    "            dia_maior = i\n",
    "\n",
    "    print(f'A maior venda ocorreu no dia {dia_maior} e foi de {maior} discos vendidos')\n",
    "    \n",
    "    \n",
    "main()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercício 6\n",
    "Dados o número $n$ de alunos de uma turma de *Introdução aos Autômatos a Pilha (MAC 414)* e suas notas da primeira prova, determinar a maior e a menor nota obtidas por essa turma (Nota máxima = $100$ e nota mínima = $0$)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def main():\n",
    "\n",
    "    n = int(input('Digite o número de alunos: '))\n",
    "    menor, maior = 0, 0 \n",
    "    \n",
    "    for i in range(1, n+1):\n",
    "        nota = int(input(f'Insira a nota do {i}º aluno (0 - 100): '))\n",
    "    \n",
    "        if nota > maior:\n",
    "            maior = nota\n",
    "        \n",
    "        if nota < menor:\n",
    "            menor = nota\n",
    "            \n",
    "    print(f'A maior nota foi {maior} e a menor nota foi {menor}')\n",
    "            \n",
    "        \n",
    "main()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercício 7\n",
    "Dados $n$ e uma seqüência de $n$ números inteiros, determinar a soma dos números pares."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def main():\n",
    "    \n",
    "    n = int(input('n: '))\n",
    "    soma = 0\n",
    "    \n",
    "    for i in range(1, n +1):\n",
    "        x  = i * 2\n",
    "        soma += x\n",
    "        \n",
    "    print(soma)\n",
    "    \n",
    "    \n",
    "main()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercício 8\n",
    "Dado um inteiro não-negativo $n$, determinar $n!$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# solução sem recursividade\n",
    "def main()\n",
    "\n",
    "    n = int(input('Digite um numero: '))\n",
    "    fact = 1\n",
    "\n",
    "    for i in range (1,n+1): \n",
    "        fact *= i\n",
    "    \n",
    "    print(f'O fatorial de {n} eh {fact}')\n",
    "\n",
    "    \n",
    "main()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercício 9\n",
    "Dados $n$ e dois números inteiros positivos $i$ e $j$ diferentes de $0$, imprimir em ordem crescente os $n$ primeiros naturais que são múltiplos de $i$ ou de $j$ e ou de ambos.\n",
    "\n",
    " Exemplo: Para $n = 6$ , $i = 2$ e $j = 3$ a saída deverá ser : $0, 2, 3, 4, 6, 8$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def main():\n",
    "    n = int(input('n: '))\n",
    "    i = int(input('i: '))\n",
    "    j = int(input('j: '))\n",
    "    \n",
    "    mult = 0\n",
    "    cont = 0\n",
    "    \n",
    "    while cont < n:\n",
    "        if mult%i == 0 or mult%j == 0:\n",
    "            print(mult, end=' ')\n",
    "            cont +=  1   \n",
    "        \n",
    "        mult += 1\n",
    "        \n",
    "        \n",
    "main()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercício 10\n",
    "Dizemos que um número natural é triangular se ele é produto de três números naturais consecutivos.\n",
    "\n",
    "Exemplo: $120$ é triangular, pois $4*5*6 = 120$.\n",
    "\n",
    "Dado um inteiro não-negativo $n$, verificar se $n$ é triangular."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def main():\n",
    "    n = int(input('n: '))\n",
    "    num = 0\n",
    "    flag = False\n",
    "    \n",
    "    while n >= num * (num+1) * (num+2):  \n",
    "        if num * (num+1) * (num+2) == n:\n",
    "            flag = True\n",
    "            break\n",
    "        \n",
    "        num += 1\n",
    "        \n",
    "    if flag:\n",
    "        print(f'O número {n} é triangular! {n} = {num}*{num+1}*{num+2}')\n",
    "    else:\n",
    "        print(f'O número {n} não é traingular.')\n",
    "        \n",
    "        \n",
    "main() "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercício 11\n",
    "Dado um inteiro positivo $n$, verificar se $n$ é primo."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "n:  127382173611\n"
     ]
    },
    {
     "ename": "KeyboardInterrupt",
     "evalue": "",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mKeyboardInterrupt\u001b[0m                         Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-7-05ebd0d4a87e>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m     18\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m     19\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m---> 20\u001b[1;33m \u001b[0mmain\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;32m<ipython-input-7-05ebd0d4a87e>\u001b[0m in \u001b[0;36mmain\u001b[1;34m()\u001b[0m\n\u001b[0;32m      9\u001b[0m     \u001b[1;32melse\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m     10\u001b[0m         \u001b[1;32mfor\u001b[0m \u001b[0mcand\u001b[0m \u001b[1;32min\u001b[0m \u001b[0mrange\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;36m1\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mn\u001b[0m\u001b[1;33m+\u001b[0m\u001b[1;36m1\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m---> 11\u001b[1;33m             \u001b[1;32mif\u001b[0m \u001b[0mn\u001b[0m \u001b[1;33m%\u001b[0m \u001b[0mcand\u001b[0m \u001b[1;33m==\u001b[0m \u001b[1;36m0\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m     12\u001b[0m                 \u001b[0msoma\u001b[0m \u001b[1;33m+=\u001b[0m \u001b[1;36m1\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m     13\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;31mKeyboardInterrupt\u001b[0m: "
     ]
    }
   ],
   "source": [
    "def main():\n",
    "    n = int(input('n: '))\n",
    "    soma = 0\n",
    "    \n",
    "    if n == 2:\n",
    "        print(f'{n} é um número primo')\n",
    "    elif n == 1 or n % 2 == 0:\n",
    "        print(f'{n} não é um número primo!')\n",
    "    else:\n",
    "        for cand in range(1, n+1):\n",
    "            if n % cand == 0:\n",
    "                soma += 1\n",
    "\n",
    "        if soma > 2:\n",
    "            print(f'{n} não é um número primo!')\n",
    "        else:\n",
    "            print(f'{n} é um número primo')\n",
    "\n",
    "        \n",
    "main()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercício 12\n",
    "Dados dois números inteiros positivos, determinar o máximo divisor comum entre eles usando o algoritmo de *Euclides*.\n",
    "\n",
    "  Exemplo:\n",
    "  \n",
    "  ![foto_1](https://www.ime.usp.br/~macmulti/figuras/Image113.gif)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def main():\n",
    "    n = int(input('n: '))\n",
    "    m = int(input('m: '))\n",
    "\n",
    "    # algoritmo de Euclides\n",
    "    anterior = n\n",
    "    atual = m\n",
    "    resto = anterior % atual\n",
    "\n",
    "    while resto != 0:\n",
    "        anterior = atual\n",
    "        atual    = resto\n",
    "        resto    = anterior % atual\n",
    "\n",
    "    print(f'MDC({n},{m}) = {atual}')\n",
    "\n",
    "\n",
    "main()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercício 13\n",
    "*(MAT 89)* Dizemos que um inteiro positivo $n$ é perfeito se for igual à soma de seus divisores positivos diferentes de $n$.\n",
    "\n",
    "Exemplo: $6$ é perfeito, pois $1+2+3 = 6$.\n",
    "       Dado um inteiro positivo $n$, verificar se $n$ é perfeito."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def main():\n",
    "    n = int(input('n: '))\n",
    "    soma = 0\n",
    "    \n",
    "    for divisor in range(1,n):\n",
    "        if n % divisor == 0:\n",
    "            soma += divisor \n",
    "\n",
    "    if n == soma:\n",
    "        print(f'O número {n} é perfeito!')\n",
    "    else:\n",
    "        print(f'O número {n} não é perfeito.')\n",
    "\n",
    "\n",
    "main()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercício 14\n",
    "Um matemático italiano da idade média conseguiu modelar o ritmo de crescimento da população de coelhos através de uma sequência de números naturais que passou a ser conhecida como **sequência de Fibonacci**. O $n$-ésimo número da sequência de Fibonacci $F_{n}$ é dado pela seguinte fórmula de recorrência:\n",
    "\n",
    "<center><img src='https://www.ime.usp.br/~macmulti/figuras/Image115.gif'></center>\n",
    "\n",
    "Faça um programa que, dado $n$, calcula $F_{n}$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def main():\n",
    "    n = int(input('n: '))\n",
    "    \n",
    "    f_ant = 0\n",
    "    f_atual = 1\n",
    "    \n",
    "    for i in range(1, n):\n",
    "        f_prox = f_ant + f_atual\n",
    "        f_ant = f_atual\n",
    "        f_atual = f_prox\n",
    "        \n",
    "    print(f'F({n}) = {f_atual}')\n",
    "    \n",
    "    \n",
    "main()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercício 15\n",
    "Dizemos que um número $i$ é congruente módulo $m$ a $j$ se $i$ % $m = j$ % $m$.\n",
    " \n",
    "  Exemplo: $35$ é congruente módulo $4$ a $39$, pois $35$ % $4 = 3 = 39$ % $4$.\n",
    "\n",
    "Dados inteiros positivos $n$, $j$ e $m$, imprimir os $n$ primeiros naturais congruentes a $j$ módulo $m$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def main():\n",
    "    n = int(input('n: '))\n",
    "    j = int(input('j: '))\n",
    "    m = int(input('m: '))\n",
    "    \n",
    "    i = 0\n",
    "    while n != 0:\n",
    "        if i % m == j % m:\n",
    "            print(i)\n",
    "            n = n - 1\n",
    "        i += 1\n",
    "    \n",
    "    \n",
    "main()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercício 16\n",
    "Dado um número natural na base binária, transformá-lo para a base decimal.\n",
    "\n",
    "Exemplo: Dado $10010$ a saída será $18$, pois $1*2^4 + 0*2^3 + 0*2^2 + 1*2^1 + 0*2^0 = 18$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def main():\n",
    "    num = input('Digite um número em binário: ')\n",
    "    \n",
    "    soma = 0\n",
    "\n",
    "    for i in range (len(num)):\n",
    "        x = int(num[-1-i]) * 2**i\n",
    "        soma += x\n",
    "    print(soma)\n",
    "    \n",
    "    \n",
    "main()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercício 17\n",
    "Dado um número natural na base decimal, transformá-lo para a base binária.\n",
    "\n",
    "Exemplo: Dado $18$ a saída deverá ser $10010$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def main():\n",
    "    num = int(input('Digite um número em decimal: '))\n",
    "    \n",
    "    while num >= 1:\n",
    "        if num > 1:\n",
    "            num  = num // 2\n",
    "        else:\n",
    "            num = 0\n",
    "            \n",
    "        print(num % 2, end= '')\n",
    "    \n",
    "    \n",
    "main()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercício 18\n",
    "Dados três números naturais, verificar se eles formam os lados de um triângulo retângulo."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def main():\n",
    "    a = int(input('Lado a: '))\n",
    "    b = int(input('Lado b: '))\n",
    "    c = int(input('Lado c: '))\n",
    "\n",
    "    if a > b and a > c:\n",
    "        hip = a\n",
    "        cat_1 = b\n",
    "        cat_2 = c\n",
    "    elif b > a and b > c:\n",
    "        hip = b\n",
    "        cat_1 = c\n",
    "        cat_2 = a\n",
    "    elif c > a and c > b:\n",
    "        hip = c\n",
    "        cat_1 = a\n",
    "        cat_2 = b\n",
    "        \n",
    "    \n",
    "    if hip**2 == cat_1**2 + cat_2**2:\n",
    "        print('É um triângulo retângulo!')\n",
    "    else:\n",
    "        print('Não é um triângulo retângulo :c')\n",
    "    \n",
    "    \n",
    "main()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercício 19\n",
    "Dados três números, imprimi-los em ordem crescente.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def main():\n",
    "    a = int(input('a: '))\n",
    "    b = int(input('b: '))\n",
    "    c = int(input('c: '))\n",
    "    \n",
    "    maior = 0\n",
    "    medio = 0\n",
    "    menor = 0\n",
    "    \n",
    "    if a > b and a > c:\n",
    "        maior = a\n",
    "        if b > c:\n",
    "            medio = b\n",
    "            menor = c\n",
    "        else:\n",
    "            medio = c\n",
    "            menor = b\n",
    "    elif b > a and b > c:\n",
    "        maior = b\n",
    "        if a > c:\n",
    "            medio = a\n",
    "            menor = c\n",
    "        else:\n",
    "            medio = c\n",
    "            menor = a\n",
    "    elif c > a and c > b:\n",
    "        maior = c\n",
    "        if a > b:\n",
    "            medio = a\n",
    "            menor = b\n",
    "        else:\n",
    "            medio = b\n",
    "            menor = a\n",
    "            \n",
    "    print(f'{menor} < {medio} < {maior}')\n",
    "            \n",
    "    \n",
    "main()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercício 20\n",
    "*(FIS 88)* Qualquer número natural de quatro algarismos pode ser dividido em duas dezenas formadas pelos seus dois primeiros e dois últimos dígitos.\n",
    "\n",
    "Exemplos:\n",
    "   * $1297: 12$ e $97.$\n",
    "   * $5314: 53$ e $14.$\n",
    "   \n",
    "Escreva um programa que imprime todos os milhares ($4$ algarismos) cuja raiz quadrada seja a soma das dezenas formadas pela divisão acima.\n",
    "\n",
    "Exemplo: raiz de $9801 = 99 = 98 + 01$.\n",
    "Portanto $9801$ é um dos números a ser impresso."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def main():\n",
    "    from math import sqrt\n",
    "    \n",
    "    for i in range(1000, 10000):\n",
    "        num = str(i)\n",
    "        esq = int(num[:2])\n",
    "        dire = int(num[2:])\n",
    "        if sqrt(i) == esq + dire:\n",
    "            print(i)\n",
    "            \n",
    "            \n",
    "main()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercício 21\n",
    "*(POLI 87)* 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",
    "Exemplo: A seguinte seqüência é formada por $5$ segmentos de números iguais: $5,  2,  2,  3,  4,  4,  4,  4,  1,  1$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def main():\n",
    "    n = int(input('n: '))\n",
    "    \n",
    "    anterior = int(input('1º: '))\n",
    "    cont = 1\n",
    "    \n",
    "    for i in range(2, n+1):\n",
    "        atual = int(input(f'{i}º: '))\n",
    "        if atual != anterior:\n",
    "            cont += 1\n",
    "            anterior = atual\n",
    "            \n",
    "    print(f'Segmentos de números iguais: {cont}')\n",
    "            \n",
    "    \n",
    "main()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercício 22\n",
    "*(POLI 89)* Dados $n$ e uma sequência de $n$ números inteiros, determinar o comprimento de um segmento crescente de comprimento máximo.\n",
    "\n",
    "Exemplos:\n",
    "\n",
    "Na sequência:  $5,  10,  3,  2,  4,  7,  9,  8,  5$   o comprimento do segmento crescente máximo é $4$.\n",
    "\n",
    "Na sequência   $10,  8,  7,  5,  2$   o comprimento de um segmento crescente máximo é $1$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def main():\n",
    "    n = int(input('n: '))\n",
    "    \n",
    "    anterior = int(input('1º: '))\n",
    "    tam = 1\n",
    "    tam_max = 1\n",
    "    \n",
    "    for i in range(1, n):\n",
    "        num = int(input(f'{i+1}º: '))\n",
    "        \n",
    "        if num > anterior:\n",
    "            tam += 1\n",
    "            if tam_max < tam:\n",
    "                tam_max = tam\n",
    "        else:\n",
    "            tam = 1\n",
    "        \n",
    "        anterior = num\n",
    "        \n",
    "    print(f'Comprimento do segmento crescente: {tam_max}')\n",
    "        \n",
    "        \n",
    "main()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercício 23\n",
    "Dizemos que um número natural $n$ é palíndromo se\n",
    "\n",
    "   * $1º$ algarismo de $n$ é igual ao seu último algarismo,\n",
    "   * $2º$ algarismo de $n$ é igual ao penúltimo algarismo, e assim sucessivamente.\n",
    "\n",
    "Exemplos:\n",
    "\n",
    "$567765$ e $32423$ são palíndromos.\n",
    "\n",
    "$567675$ não é palíndromo.\n",
    "\n",
    "Dado um número natural $n \\geq 10$ , verificar se $n$ é palíndrome.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def main():\n",
    "    n = input('n: ')  # string\n",
    "    cont = 0\n",
    "    \n",
    "    for i in range(len(n)):\n",
    "        if n[i] == n[-(i+1)]:\n",
    "            cont += 1\n",
    "            \n",
    "    if cont == len(n):\n",
    "        print(f'{n} é palíndromo.')\n",
    "    else:\n",
    "        print(f'{n} não é palíndromo.')\n",
    "    \n",
    "    \n",
    "main()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercício 24\n",
    " São dados dois números inteiros positivos $p$ e $q$, sendo que o número de dígitos de $p$ é menor ou igual ao número de dígitos de $q$. Verificar se $p$ é um subnúmero de $q$.\n",
    "\n",
    "Exemplos:\n",
    "\n",
    "* $p = 23$, $q = 57238$, $p$ é subnúmero de $q$.\n",
    "* $p = 23$, $q = 258347$, $p$ não é subnúmero de $q$.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def main():\n",
    "    p = input('p: ')\n",
    "    q = input('q: ')\n",
    "    \n",
    "    achou = False\n",
    "    \n",
    "    for i in range(len(q) - len(p) + 1):\n",
    "        if p == q[i:len(p)+i]:\n",
    "            achou = True\n",
    "            print('oi')\n",
    "            \n",
    "    if achou:\n",
    "        print(f'{p} é subnúmero de {q}')\n",
    "    else:\n",
    "        print(f'{p} não é subnúmero de {q}')\n",
    "    \n",
    "    \n",
    "main()"
   ]
  }
 ],
 "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.8.5"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {},
   "toc_section_display": true,
   "toc_window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}