Solução_01.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Solução dos Exercícios da Revisão 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Questão 1:** Escreva um programa que, dada uma seqüência de N inteiros fornecidos\n",
    "pelo usuário, determina se esta seqüência está em ordem crescente. Leia todos\n",
    "os números antes de exibir a resposta. Veja os exemplos abaixo:\n",
    "\n",
    "  Exemplo 1:\n",
    "  ```\n",
    "  N: 7\n",
    "  1 5 8 2 17 21 53\n",
    "  Não está em ordem crescente.\n",
    "  ```\n",
    "  Exemplo 2:\n",
    "  ```\n",
    "  N: 7\n",
    "  3 5 10 16 24 32 61\n",
    "  Ordem crescente.\n",
    "  ```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "code_folding": [
     0
    ]
   },
   "outputs": [],
   "source": [
    "# solução\n",
    "n = int(input(\"Comprimento da seqüência: \"))\n",
    "crescente = True\n",
    "print(\"Sequência:\")\n",
    "for i in range(n):\n",
    "    x = int(input())\n",
    "    if i != 0:\n",
    "        if x < last:\n",
    "            crescente = False\n",
    "    last = x\n",
    "if crescente:\n",
    "    print(\"Ordem crescente.\")\n",
    "else:\n",
    "    print(\"Não está em ordem crescente.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Questão 2:** Escreva um programa que imprime, em ordem crescente, os números\n",
    "ímpares menores ou iguais a um valor N fornecido pelo usuário. Veja o exemplo\n",
    "abaixo:\n",
    "```\n",
    "  N: 7\n",
    "  1\n",
    "  3\n",
    "  5\n",
    "  7\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "code_folding": [
     0
    ]
   },
   "outputs": [],
   "source": [
    "# solução\n",
    "n = int(input(\"N : \"))\n",
    "print(\"Ímpares menor ou igual a \", n, \":\")\n",
    "for i in range(1, n + 1, 2):\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Questão 3:** Escreva um programa que calcule um conceito (A, B, C, D ou E) de\n",
    "acordo com o valor da nota de um aluno.\n",
    "```\n",
    "  A -- se 8.5 <= nota <= 10\n",
    "  B -- se 7.0 <= nota < 8.5\n",
    "  C -- se 5.0 <= nota < 7.0\n",
    "  D -- se 3.0 <= nota < 5.0\n",
    "  E -- se 0.0 <= nota < 3.0\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "code_folding": [
     0
    ]
   },
   "outputs": [],
   "source": [
    "# solução\n",
    "conceito = 'E'\n",
    "n = float(input(\"Nota: \"))\n",
    "if n >= 8.5:\n",
    "    conceito = 'A'\n",
    "elif n >= 7:\n",
    "    conceito = 'B'\n",
    "elif n >= 5:\n",
    "    conceito = 'C'\n",
    "elif n >= 3:\n",
    "    conceito = 'D'\n",
    "print(\"Conceito=\", conceito)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Questão 4:** Escreva a saída dos programas abaixo:\n",
    "\n",
    "(a)\n",
    "```\n",
    "for i in range(4):\n",
    "    for j in range(4 - i):\n",
    "        print(\"+\", end=\"\")\n",
    "    for j in range(2 * i):\n",
    "        print(\"-\", end=\"\")\n",
    "    for j in range(4 - i):\n",
    "        print(\"+\", end=\"\")\n",
    "    print()\n",
    "```\n",
    "(b)\n",
    "```\n",
    "for i in range(5):\n",
    "    for j in range(i):\n",
    "        print(\"-\", end=\"\")\n",
    "    for j in range(5 - i):\n",
    "        print(\"+\", end=\"\")\n",
    "    print()\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "code_folding": [
     0,
     9
    ]
   },
   "outputs": [],
   "source": [
    "for i in range(4):\n",
    "    for j in range(4 - i):\n",
    "        print(\"+\", end=\"\")\n",
    "    for j in range(2 * i):\n",
    "        print(\"-\", end=\"\")\n",
    "    for j in range(4 - i):\n",
    "        print(\"+\", end=\"\")\n",
    "    print()\n",
    "    \n",
    "for i in range(5):\n",
    "    for j in range(i):\n",
    "        print(\"-\", end=\"\")\n",
    "    for j in range(5 - i):\n",
    "        print(\"+\", end=\"\")\n",
    "    print()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Questão 5:** Escreva um programa que leia o comprimento dos lados a, b e c de um\n",
    "triângulo, calcule o seu perímetro e verifique se este triângulo é ou não\n",
    "eqüilátero. Exemplo:\n",
    "```\n",
    "  a: 10\n",
    "  b: 8\n",
    "  c: 10\n",
    "  Perimetro: 28\n",
    "  O triangulo nao é equilatero.\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "code_folding": [
     0
    ]
   },
   "outputs": [],
   "source": [
    "# solução\n",
    "a = int(input(\"a: \"))\n",
    "b = int(input(\"b: \"))\n",
    "c = int(input(\"c: \"))\n",
    "perimetro = a + b + c\n",
    "equilatero = (a == b) and (b == c)\n",
    "print('perimetro: ', perimetro)\n",
    "if equilatero:\n",
    "    print('O triangulo é equilatero')\n",
    "else:\n",
    "    print('O trinagulo não é equilatero')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Questão 6:** Escreva um programa para calcular o valor de x na série abaixo, para\n",
    "um valor de N, fornecido pelo usuário:\n",
    "```\n",
    "  x = 1 - 1/2 + 1/4 - 1/6 + ... + 1/N , N >= 2\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "code_folding": [
     0
    ]
   },
   "outputs": [],
   "source": [
    "# solução\n",
    "n = int(input(\"N: \"))\n",
    "x = 1\n",
    "signal = -1\n",
    "for i in range(2, n + 1, 2):\n",
    "    x += (1 / i) * signal\n",
    "    signal *= -1\n",
    "print(\"x = \", x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Questão 7:** Escreva um programa que leia uma seqüência de N valores inteiros\n",
    "fornecidos pelo usuário e imprima o número de valores positivos, de valores\n",
    "negativos e de zeros."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "code_folding": [
     0
    ]
   },
   "outputs": [],
   "source": [
    "# solução\n",
    "n = int(input(\"Comprimento da seqüência: \"))\n",
    "positivos = 0\n",
    "negativos = 0\n",
    "zeros = 0\n",
    "print(\"Sequência:\")\n",
    "for i in range(n):\n",
    "    x = int(input())\n",
    "    if x > 0:\n",
    "        positivos +=1\n",
    "    elif x < 0:\n",
    "        negativos +=1\n",
    "    else:\n",
    "        zeros +=1\n",
    "print(\"Valores positivos=\", positivos, \" Negativos=\", negativos, \" e zeros=\", zeros)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Questão 8:** Escreva um programa que leia um inteiro n ≥ 1 e uma sequência de n\n",
    "números inteiros, e imprima o número de subidas na mesma.  Por subida\n",
    "entenda-se um elemento da sequência que seja estritamente maior que o elemento\n",
    "imediatamente anterior. Por exemplo, a sequência\n",
    "```\n",
    "  1, 2, 1, 4, 2, 1, 3, 3, 3, 1\n",
    "     -     -        -\n",
    "```\n",
    "tem exatamente três subidas (os elementos sublinhados)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "code_folding": [
     0
    ]
   },
   "outputs": [],
   "source": [
    "# solução\n",
    "n = int(input(\"Comprimento da seqüência: \"))\n",
    "subidas = 0\n",
    "print(\"Sequência:\")\n",
    "for i in range(n):\n",
    "    x = int(input())\n",
    "    if i != 0:\n",
    "        if x > last:\n",
    "            subidas += 1\n",
    "    last = x\n",
    "print(\"Número de subidas=\", subidas)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Questão 9:** Faça um programa que imprima todos os números primos < 1000 que\n",
    "sejam terminados por 7 ou por 9."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "code_folding": [
     0
    ]
   },
   "outputs": [],
   "source": [
    "# solução\n",
    "def is_prime(n):\n",
    "    div = 2\n",
    "    while div <= (n // 2):\n",
    "        if n % div == 0:\n",
    "            return False\n",
    "        div += 1\n",
    "    return True\n",
    "    \n",
    "primes_7_9 = []\n",
    "for i in range(2, 1000):\n",
    "    if is_prime(i):\n",
    "        resto = i % 10\n",
    "        if (resto == 7) or (resto == 9):\n",
    "            primes_7_9.append(i)\n",
    "\n",
    "print(primes_7_9)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Questão 10:** Faça um programa que dados 2 números inteiros a, b > 0, imprime o\n",
    "MDC destes números."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "code_folding": [
     0
    ]
   },
   "outputs": [],
   "source": [
    "# solução\n",
    "def mdc(a, b):\n",
    "    \"\"\"Calcula o MDC de a, b > 0.\n",
    "    \"\"\"\n",
    "    while b:\n",
    "        a, b = b, a % b\n",
    "    return a\n",
    "\n",
    "assert(mdc(44, 24) == 4)\n",
    "assert(mdc(97, 17) == 1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Questão 11:** Faça um programa que leia um número indeterminado de valores, correspondentes a notas, encerrando a entrada de dados quando for informado um valor igual a -1 (que não deve ser armazenado). Após esta entrada de dados,\n",
    "\n",
    "- Mostre a quantidade de valores que foram lidos;\n",
    "- Exiba todos os valores na ordem em que foram informados, um ao lado do outro;\n",
    "- Calcule e mostre a soma dos valores;\n",
    "- Calcule e mostre a média dos valores;\n",
    "- Calcule e mostre a quantidade de valores acima da média calculada;\n",
    "- Calcule e mostre a quantidade de valores abaixo de sete (7.0);\n",
    "- Encerre o programa com uma mensagem."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "code_folding": [
     0
    ]
   },
   "outputs": [],
   "source": [
    "# solução:\n",
    "notas = []\n",
    "print(\"Forneça as notas (-1 para fim):\")\n",
    "while True:\n",
    "    n = float(input())\n",
    "    if n == -1:\n",
    "        break\n",
    "    else:\n",
    "        notas.append(n)\n",
    "print(\"Quantidade de notas:\", len(notas))\n",
    "for i in range(len(notas)):\n",
    "    print(notas[i], \" \", end=\"\")\n",
    "print()\n",
    "soma = sum(notas)\n",
    "print(\"Soma:\", format(soma, \".2f\"))\n",
    "media = soma / len(notas)\n",
    "print(\"Média:\", format(media, \".2f\"))\n",
    "print(\"Notas acima da média: \", end=\"\")\n",
    "for x in notas:\n",
    "    if x > media:\n",
    "        print(x, \" \", end=\"\")\n",
    "print()\n",
    "print(\"Notas abaixo de 7.0: \", end=\"\")\n",
    "for x in notas:\n",
    "    if x < 7:\n",
    "        print(x, \" \", end=\"\")\n",
    "print()    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Questão 12:** Faça um programa que simule um lançamento de dados. Lance o dado 100 vezes e armazene os resultados em uma lista. Depois, mostre quantas vezes cada valor foi conseguido. Dica: use uma lista de contadores(1-6) e uma função para gerar numeros aleatórios, simulando os lançamentos dos dados."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "code_folding": [
     0
    ]
   },
   "outputs": [],
   "source": [
    "# solução\n",
    "from random import randint\n",
    "\n",
    "resultado = [0] * 7   # posição 0 não será usada.\n",
    "for i in range(100):\n",
    "    x = randint(1,6)\n",
    "    resultado[x] += 1\n",
    "    \n",
    "for i in range(1, 7):\n",
    "    print(i, \": \", resultado[i])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Questão 13:** Faça um Programa que leia dois vetores (listas) com 10 elementos cada. Gere um terceiro vetor de 20 elementos, cujos valores deverão ser compostos pelos elementos intercalados dos dois outros vetores."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "code_folding": [
     0
    ]
   },
   "outputs": [],
   "source": [
    "# solução\n",
    "\n",
    "print(\"Lendo vetor 1:\")\n",
    "vetor1 = []\n",
    "for _ in range(10):\n",
    "    x = int(input())\n",
    "    vetor1.append(x)\n",
    "    \n",
    "print(\"Lendo vetor 2:\")\n",
    "vetor2 = []\n",
    "for _ in range(10):\n",
    "    x = int(input())\n",
    "    vetor2.append(x)\n",
    "    \n",
    "print(\"Intercalando:\")\n",
    "vetor3 = []\n",
    "for i in range(10):\n",
    "    vetor3.append(vetor1[i])\n",
    "    vetor3.append(vetor2[i])\n",
    "\n",
    "print(vetor3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Questão 14:** Desenvolva um jogo da forca. O programa terá uma lista de 20 palavras lidas de um arquivo texto e escolherá uma aleatoriamente. O jogador poderá errar 6 vezes antes de ser enforcado.\n",
    "```\n",
    "Digite uma letra: A\n",
    "-> Você errou pela 1ª vez. Tente de novo!\n",
    "\n",
    "Digite uma letra: O\n",
    "A palavra é: _ _ _ _ O\n",
    "\n",
    "Digite uma letra: E\n",
    "A palavra é: _ E _ _ O\n",
    "\n",
    "Digite uma letra: S\n",
    "-> Você errou pela 2ª vez. Tente de novo!\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "code_folding": [
     0
    ]
   },
   "outputs": [],
   "source": [
    "# solução:\n",
    "palavras = ['cidade', 'pesca', 'revista', 'novidade', 'perdido', 'planeta']\n",
    "\n",
    "from random import randint\n",
    "selecao = palavras[randint(0, 5)]\n",
    "forca = ['_'] * len(selecao)\n",
    "tentativa = 0\n",
    "match = False\n",
    "while (tentativa <= 6) and not match:\n",
    "    letra = input(\"Digite uma letra: \")\n",
    "    indices = [i for i in range(len(selecao)) if selecao.startswith(letra, i)]\n",
    "    if indices == []:\n",
    "        tentativa += 1\n",
    "        print(f'Você errou pela {tentativa}a vez. Tente de novo!')\n",
    "    else:\n",
    "        for i in indices:\n",
    "            forca[i] = letra\n",
    "        print('A palavra é:', ' '.join(forca))\n",
    "        if ''.join(forca) == selecao:\n",
    "            print(\"Parabéns!\")\n",
    "            match = True\n",
    "if not match:\n",
    "    print(\"Infelizmente vc foi enforcado!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Questão 15:** O sistema de cifras romanas é escrito com determinadas letras, que representam os números.\n",
    "As letras são sempre maiúsculas e o Zero não é representado. Escreva um programa para transformar um número inteiro < 4000 em romano"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "code_folding": [
     0
    ]
   },
   "outputs": [],
   "source": [
    "# solução\n",
    "def int_to_roman(n):\n",
    "    \"\"\"\n",
    "    Converte Inteiros para Romanos\n",
    "    \"\"\"\n",
    "    ints = (1000, 900, 500, 400, 100, 90, 50, 40, 10, 9, 5, 4, 1)\n",
    "    nums = ('M', 'CM', 'D', 'CD', 'C', 'XC', 'L', 'XL', 'X', 'IX', 'V', 'IV', 'I')\n",
    "    result = []\n",
    "\n",
    "    for i in range(len(ints)):\n",
    "        count = n // ints[i]\n",
    "        if count:\n",
    "            result.append(nums[i] * count)\n",
    "        n = n % ints[i]\n",
    "    return ''.join(result)\n",
    "\n",
    "\n",
    "n = int(input(\"Forneça um número inteiro, positivo < 4000 \"))\n",
    "print(\"Valor em romanos = \", int_to_roman(n))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Questão 16:** Se listarmos todos os números naturais abaixo de 10 que são múltiplos de 3 ou 5, obtemos 3, 5, 6 e 9. A soma desses múltiplos é 23.\n",
    "\n",
    "Encontre a soma de todos os múltiplos de 3 ou 5 abaixo de 1000."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "code_folding": [
     0
    ]
   },
   "outputs": [],
   "source": [
    "# solução\n",
    "sum = 0\n",
    "for i in range(3, 1000):\n",
    "    if (i % 3 == 0) or (i % 5 == 0):\n",
    "        sum += i\n",
    "print(sum)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Questão 17:** A \"Fatoração por números primos\" é descobrir quais números primos se multiplicam para formar o número original. Um número primo só pode ser dividido por 1 ou por si mesmo. Todos os outros números inteiros podem ser divididos em fatores de números primos. É como se os números primos fossem os blocos básicos de todos os números.\n",
    "Os fatores primos de 13195 são 5, 7, 13 e 29. Escreva um programa para encontrar o maior fator primo de um dado número."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "code_folding": [
     0
    ]
   },
   "outputs": [],
   "source": [
    "# solução\n",
    "def factors(nr):\n",
    "    i = 2\n",
    "    factors = []\n",
    "    while i <= nr:\n",
    "        if nr % i == 0:\n",
    "            factors.append(i)\n",
    "            nr = nr // i\n",
    "        else:\n",
    "            i = i + 1\n",
    "    return factors\n",
    "\n",
    "assert factors(13195)[-1] == 29\n",
    "\n",
    "n = int(input(\"Forneça um número: \"))\n",
    "print(f\"O maior fator primo de {n} é {factors(n)[-1]}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Questão 18:** Dizemos que uma matriz quadrada inteira é um quadrado mágico se a soma dos elementos de cada linha, a soma dos elementos de cada coluna e a soma dos elementos das diagonais principal e secundária são todas iguais.\n",
    "\n",
    "Exemplo: A matriz\n",
    "```\n",
    "    [[8, 0, 7]\n",
    "     [4, 5, 6]\n",
    "     [3, 10, 2]]\n",
    "```\n",
    "é um quadrado mágico. Dada uma matriz quadrada $A_{nxn}$ , verificar se $A$ é um quadrado mágico. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "code_folding": [
     0
    ]
   },
   "outputs": [],
   "source": [
    "# solução:\n",
    "def quadrado_magico(m):\n",
    "    row = len(m)\n",
    "    col = len(m[0])\n",
    "    if row != col:\n",
    "        return False\n",
    "    magic = sum(m[0])\n",
    "    for i in range(row):\n",
    "        if sum(m[i]) != magic:\n",
    "            return False\n",
    "    for i in range(col):\n",
    "        aux = 0\n",
    "        for j in range(row):\n",
    "            aux += m[i][j]\n",
    "        if aux != magic:\n",
    "            return False\n",
    "    aux = 0\n",
    "    for i in range(row):\n",
    "        for j in range(col):\n",
    "            if i == j:\n",
    "                aux += m[i][j]\n",
    "    if aux != magic:\n",
    "        return False\n",
    "    aux = 0\n",
    "    for i in range(row):\n",
    "        for j in range(col):\n",
    "            if i == (col - 1 - j):\n",
    "                aux += m[i][j]\n",
    "    if aux != magic:\n",
    "        return False\n",
    "    return True\n",
    "    \n",
    "assert(quadrado_magico([[8, 0, 7], [4, 5, 6], [3, 10, 2]]) == True)\n",
    "assert(quadrado_magico([[8, 0, 7], [5, 4, 6], [3, 10, 2]]) == False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Questão 19:** Escreva uma função **sumall** que recebe qualquer número de argumentos (inteiros ou floats) e retorna a soma deles."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "code_folding": [
     0
    ]
   },
   "outputs": [],
   "source": [
    "# solução\n",
    "def sumall (*args):\n",
    "    soma = 0\n",
    "    for x in args:\n",
    "        soma += x\n",
    "    return soma\n",
    "\n",
    "assert(sumall() == 0)\n",
    "assert(sumall(1, 3, 5, 7) == 16)\n",
    "\n",
    "print(sumall(2.2, 1.1))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Questão 20:** Dado uma string, se o seu comprimento for pelo menos 3, adicione 'ing' ao final. Caso já termine em 'ing' adicionar \"ly\". Se o comprimento da string for inferior a 3, deixe-o inalterado. Exemplos:\n",
    "```\n",
    "'hail' resulta em 'hailing'\n",
    "'swiming' resulta em 'swimingly'\n",
    "'do' resulta em 'do'\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "code_folding": [
     0
    ]
   },
   "outputs": [],
   "source": [
    "# solução\n",
    "def verbing(s):\n",
    "    if len(s) >= 3:\n",
    "        if s[-3:] != 'ing':\n",
    "            s = s + 'ing'\n",
    "        else:\n",
    "            s = s + 'ly'\n",
    "    return s\n",
    "\n",
    "\n",
    "assert(verbing('hail') == 'hailing')\n",
    "assert(verbing('swiming') == 'swimingly')\n",
    "assert(verbing('do') == 'do')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Questão 21:** Dado uma string, procurar a primeira ocorrência da substring 'not' e 'bad'. Se 'bad' vier após o 'not', substituir todo o trecho \"not ... bad\" por 'good'. Exemplos:\n",
    "```\n",
    "'This movie is not so bad' resulta em 'This movie is good'\n",
    "'This dinner is not that bad!' resulta em 'This dinner is good!'\n",
    "'This tea is not hot' resulta em 'This tea is not hot'\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "code_folding": [
     0
    ]
   },
   "outputs": [],
   "source": [
    "# solução\n",
    "def not_bad(s):\n",
    "    n = s.find('not')\n",
    "    b = s.find('bad')\n",
    "    if n != -1 and b != -1 and b > n:\n",
    "        s = s[:n] + 'good' + s[b+3:]\n",
    "    return s\n",
    "\n",
    "\n",
    "assert(not_bad('This movie is not so bad') == 'This movie is good')\n",
    "assert(not_bad('This dinner is not that bad!') == 'This dinner is good!')\n",
    "assert(not_bad('This tea is not hot') == 'This tea is not hot')\n",
    "assert(not_bad(\"It's bad yet not\") == \"It's bad yet not\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Questão 22:** Dado uma string `s`, retornar uma string onde todas as ocorrências de seu primeiro caractere seja alterado para '*', exceto o primeiro caracter. Exemplo:\n",
    "```\n",
    "babble ---> ba**le\n",
    "```\n",
    "Presuma que o tamanho da string seja 1 ou mais. Dica: s.replace (strA, strB) retorna uma versão da string s com strB no lugar de strA."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "code_folding": [
     0
    ]
   },
   "outputs": [],
   "source": [
    "# solução\n",
    "def fix_start(s):\n",
    "    front = s[0]\n",
    "    back = s[1:]\n",
    "    fixed_back = back.replace(front, '*')\n",
    "    return front + fixed_back\n",
    "\n",
    "\n",
    "assert(fix_start('babble') == 'ba**le')\n",
    "assert(fix_start('aardvark') == 'a*rdv*rk')\n",
    "assert(fix_start('google') == 'goo*le')\n",
    "assert(fix_start('donut') == 'donut')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Questão 23:** # Dado uma lista de números, retorne uma lista onde todo elemento adjacente e repetido será deletado reduzindo a um único elemento. Por exemplo:\n",
    "```\n",
    "[1, 2, 2, 3] deve retornar [1, 2, 3]\n",
    "porém\n",
    "[1, 2, 3, 2, 3] deve retornar [1, 2, 3, 2, 3]\n",
    "\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "code_folding": [
     0
    ]
   },
   "outputs": [],
   "source": [
    "# solução\n",
    "def remove_adjacent(nums):\n",
    "    result = []\n",
    "    if len(nums) > 1:\n",
    "        result.append(nums[0])\n",
    "    for num in nums:\n",
    "        if num != result[-1]:\n",
    "            result.append(num)\n",
    "    return result\n",
    "\n",
    "\n",
    "assert(remove_adjacent([1, 2, 2, 3]) == [1, 2, 3])\n",
    "assert(remove_adjacent([2, 2, 3, 3, 3]) == [2, 3])\n",
    "assert(remove_adjacent([1, 2, 3, 2, 3]) == [1, 2, 3, 2, 3])\n",
    "assert(remove_adjacent([]) == [])"
   ]
  }
 ],
 "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
  },
  "toc": {
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": false,
   "toc_cell": false,
   "toc_position": {},
   "toc_section_display": "block",
   "toc_window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}