Python_CoderDojo08.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "Python_CoderDojo08.ipynb",
      "provenance": [],
      "collapsed_sections": [],
      "authorship_tag": "ABX9TyPqucLCIoaBTbBN3sA8pM4F",
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/seldoncode/Python_CoderDojo/blob/main/Python_CoderDojo08.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "iunBA2ZeH0il"
      },
      "source": [
        "# Bucle ```for```\n",
        "Cuando se sabe el número de ciclos que debe dar el loop es mejor usar un bucle ```for```."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "kI3UfWihIIev",
        "outputId": "7d9972ba-f9d1-4b40-b832-51ddc555ceb6"
      },
      "source": [
        "for i in range(10):      # objeto de tipo range\n",
        "  print(i)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "0\n",
            "1\n",
            "2\n",
            "3\n",
            "4\n",
            "5\n",
            "6\n",
            "7\n",
            "8\n",
            "9\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "hf5VzftaIWL8",
        "outputId": "aa6f6de2-63cb-4a49-ac65-a8ee2f7aeb2a"
      },
      "source": [
        "for _ in range(3):   # también se puede usar como variable _, que es habitual cuando luego no se utiliza\n",
        "  print(\"Hola\")"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Hola\n",
            "Hola\n",
            "Hola\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "JXAySTJKI5bQ",
        "outputId": "c02a4cc8-0a26-4240-ca2a-019c7fff3a39"
      },
      "source": [
        "for letra in \"Europa\":      # string\n",
        "  print(letra)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "E\n",
            "u\n",
            "r\n",
            "o\n",
            "p\n",
            "a\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "XNiuWr0AJGAE",
        "outputId": "4b54f62c-934a-4c7e-a9b8-5d5763ba240f"
      },
      "source": [
        "for numero in [10,20,30,40]:      # lista\n",
        "  print(numero)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "10\n",
            "20\n",
            "30\n",
            "40\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "bTSxOBq9JS5H",
        "outputId": "2290dbfb-a19b-4404-a031-3187e9478f57"
      },
      "source": [
        "for dia in (\"lunes\",\"martes\",\"miércoles\",\"jueves\",\"viernes\",\"sábado\",\"domingo\"):     # tupla\n",
        "  print(dia)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "lunes\n",
            "martes\n",
            "miércoles\n",
            "jueves\n",
            "viernes\n",
            "sábado\n",
            "domingo\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "qIf8rNTbKIxx"
      },
      "source": [
        "### Countdown to Zero (Cuenta atrás)\n",
        "Realizar una cuenta regresiva desde 10 hasta 0."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "A8h3Z4-fLLhm"
      },
      "source": [
        "#### Solución 1"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "VLFEHuMkKoc5",
        "outputId": "7a524c8b-73f3-4ba8-f5c3-d3108b24fb3e"
      },
      "source": [
        "for i in range(10,-1,-1):\n",
        "  print(i)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "10\n",
            "9\n",
            "8\n",
            "7\n",
            "6\n",
            "5\n",
            "4\n",
            "3\n",
            "2\n",
            "1\n",
            "0\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Wefvcfp4LOLY"
      },
      "source": [
        "#### Solución 2"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "k19ZOaRLLQI0",
        "outputId": "840f93ac-5bcd-4680-e3c9-847cdb27b242"
      },
      "source": [
        "for i in range(11):\n",
        "  print(10-i)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "10\n",
            "9\n",
            "8\n",
            "7\n",
            "6\n",
            "5\n",
            "4\n",
            "3\n",
            "2\n",
            "1\n",
            "0\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "KQMBIHAhC8XY"
      },
      "source": [
        "#### Solución 3 usando un bucle ```while```\n",
        "Al comparar las resolución con ambos búcles vemos que con un ```for``` se resuelve en menos líneas en este caso.  \n",
        "Un bucle ```for``` será más interesante que un bucle ```while``` normalmente pero es necesario conocer cuantos ciclos se van a realizar. "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "-oFmy4aLCzvG",
        "outputId": "cb108b86-40c5-4cce-d834-8b85363be145"
      },
      "source": [
        "i = 10\n",
        "while i>=0:\n",
        "  print(i)\n",
        "  i -= 1"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "10\n",
            "9\n",
            "8\n",
            "7\n",
            "6\n",
            "5\n",
            "4\n",
            "3\n",
            "2\n",
            "1\n",
            "0\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "skGooYSVozHs"
      },
      "source": [
        "### Reto 8.1. Bucle ```for``` con los pares\n",
        "Crear un bucle ```for``` con los pares entre 10 y 30, ambos incluidos y en orden inverso."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "NBBoxJzCET-K"
      },
      "source": [
        "### Sumar cinco números\n",
        "* Pedir al usuario cinco números.\n",
        "* Después de introducir cada número se proporcionará el valor acumulado."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "9skKPesTF3ZW"
      },
      "source": [
        "#### Solución ```for```\n",
        "Podemos solucionar este caso con ```for``` o con ```while```, pero es más interesate resolverlo con ```for``` ya que sabemos cuantas iteraciones son necesarias."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "8m5FsSXKEyYK",
        "outputId": "131fbeaf-23e4-4281-f0bf-888e82b0561b"
      },
      "source": [
        "total = 0\n",
        "for i in range(5):\n",
        "  valor = float(input(f\"Indique el número {i+1}: \"))\n",
        "  total += valor\n",
        "  print(f\"El acumulado asciende a {total}.\")"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Indique el número 1: 1\n",
            "El acumulado asciende a 1.0.\n",
            "Indique el número 2: 2\n",
            "El acumulado asciende a 3.0.\n",
            "Indique el número 3: 3\n",
            "El acumulado asciende a 6.0.\n",
            "Indique el número 4: 4\n",
            "El acumulado asciende a 10.0.\n",
            "Indique el número 5: 90\n",
            "El acumulado asciende a 100.0.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "LLswKiVpGUZN"
      },
      "source": [
        ""
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "sfXmFo_wGZ5q"
      },
      "source": [
        "### Sumar hasta llegar a 100\n",
        "Programa que va pidiendo números hasta llegar a 100 o más, momento en el que termina.  \n",
        "Ir mostrando el acumulado en cada tirada."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Kjq1gFA_GvfW"
      },
      "source": [
        "#### Solución ```while```\n",
        "En este caso, como no sabemos cuantas tiradas serán necesarias, es recomendable utilizar un bucle ```while```."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "jsSh6VPnG8PE",
        "outputId": "b87dbc5f-2288-4ea3-dd01-1cce34afe94f"
      },
      "source": [
        "total = 0\n",
        "while total<100:\n",
        "  n = int(input(\"Introduzca un número entero: \"))\n",
        "  total += n\n",
        "  print(f\"El acumulado asciende a {total}.\")\n",
        "\n",
        "print(\"Fin del programa.\")"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Introduzca un número entero: 10\n",
            "El acumulado asciende a 10.\n",
            "Introduzca un número entero: 60\n",
            "El acumulado asciende a 70.\n",
            "Introduzca un número entero: 40\n",
            "El acumulado asciende a 110.\n",
            "Fin del programa.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "iVKSB_TnscYh"
      },
      "source": [
        "# Añadir un elemento a una lista\n",
        "Podemos añadir un elemento al final de una lista con ```append```.\n",
        "\n",
        "* Crear una lista de 8 números aleatorios entre 1 y 9.\n",
        "* Ir mostrando la lista a medida que se van añadiendo elementos."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "HYvIHdNAspPm",
        "outputId": "60ad1a45-d335-4af0-c921-7569caf86351"
      },
      "source": [
        "import random\n",
        "lista=[]                         # inicializamos una lista vacía\n",
        "for i in range(8):\n",
        "  n = random.randint(1,10)\n",
        "  lista.append(n)                # append añade el elemento al final de la lista\n",
        "  print(lista)\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[2]\n",
            "[2, 1]\n",
            "[2, 1, 5]\n",
            "[2, 1, 5, 7]\n",
            "[2, 1, 5, 7, 6]\n",
            "[2, 1, 5, 7, 6, 8]\n",
            "[2, 1, 5, 7, 6, 8, 6]\n",
            "[2, 1, 5, 7, 6, 8, 6, 2]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "K8LM7KNkrT9a"
      },
      "source": [
        "### Reto 8.2. Generar listas de aleatorios que sumen 100\n",
        "Generar diez listas de números aleatorios, entre 10 y 20, ambos incluidos, que sumen exactamente 100."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "1HU82OHcIGHB"
      },
      "source": [
        "## Recorrer un dato secuencia con un ```for```\n",
        "* Para ver si un dato está en una lista o\n",
        "* Para ver si un dato está en una tupla o\n",
        "* Para ver si un caracter está en un string\n",
        "\n",
        "en Python podemos utilizar el comando ```in```. Sería la forma más sencilla.\n",
        "\n",
        "También podemos utilizar un bucle ```for``` para recorrer la secuencia e ir comprobando si está el dato."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "EWiepaDPIxHP",
        "outputId": "eaa799ac-4d4c-4a5e-93ad-b94da405b347"
      },
      "source": [
        "# resuelto con in\n",
        "\n",
        "palabra = \"ahorrar\"\n",
        "'h' in palabra"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "True"
            ]
          },
          "metadata": {},
          "execution_count": 11
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "6etXTK9uI72C",
        "outputId": "9b76751d-4185-44b5-bd6f-84917b28a7f4"
      },
      "source": [
        "existe = False            # bandera inicializada como False\n",
        "palabra = \"ahorrar\"\n",
        "for caracter in palabra:\n",
        "  if caracter == \"h\": existe = True\n",
        "\n",
        "print(\"¿Está la 'h' en la palabra?\", existe)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "¿Está la 'h' en la palabra? True\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "wHrk4gg2UqRX",
        "outputId": "0a41a11c-4d22-4c45-9871-10041cdb14b2"
      },
      "source": [
        "lista = [2,5,9,14,19,20]\n",
        "9 in lista "
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "True"
            ]
          },
          "metadata": {},
          "execution_count": 12
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "qLiko1h5WQJ8",
        "outputId": "7102de0c-c86c-4d84-8f60-ba271a9ea9db"
      },
      "source": [
        "lista = [2,5,9,14,19,20]\n",
        "for num in lista:\n",
        "  if num==9:\n",
        "    print(\"El número si está en la lista.\")\n",
        "  else:\n",
        "    print(\"El número no está en la lista.\")"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "El número no está en la lista.\n",
            "El número no está en la lista.\n",
            "El número si está en la lista.\n",
            "El número no está en la lista.\n",
            "El número no está en la lista.\n",
            "El número no está en la lista.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ZaeshZZkXcTV"
      },
      "source": [
        "Es posible que no deseemos que nos informe de si está o no el número analizado por cada ciclo del bucle.  \n",
        "Vamos a incluir una bandera para saber si está y mostrarlo solo al final."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "jOeRE8VDXzWg",
        "outputId": "4b59ff81-ab85-49d5-ba63-c57dabc9f3c7"
      },
      "source": [
        "lista = [2,5,9,14,19,20]\n",
        "esta = False                 # bandera\n",
        "for num in lista:\n",
        "  if num==9:\n",
        "    esta = True\n",
        "\n",
        "if esta:                      # analizamos si la bandera es True o False\n",
        "  print(\"El número si está en la lista.\")\n",
        "else:\n",
        "  print(\"El número no está en la lista.\")"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "El número si está en la lista.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "CfX1Bwe5ZHFv"
      },
      "source": [
        "Otra forma de solucionarlo es accediendo a cada elemento de la lista con lista[i].  \n",
        "En este caso, i es el índice que va entre 0 y la longitud de la cadena -1. "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "i_FthMuxU_oO",
        "outputId": "622ca8da-ae39-45c5-ef14-bbde3a6a3597"
      },
      "source": [
        "lista = [2,5,9,14,19,20]\n",
        "existe = False                # bandera\n",
        "for i in range(len(lista)):   # recorremos todos los index desde cero hasta la longitud-1\n",
        "  if lista[i]==9:             # accedemos al elemento i-ésimo\n",
        "    existe = True\n",
        "\n",
        "if existe:                    # convertimos la bandera 'existe' en un si o un no según sea True o False\n",
        "  sino=\"si\"\n",
        "else:\n",
        "  sino=\"no\"\n",
        "\n",
        "print(f\"El número 9 {sino} esta en la lista.\")"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "El número 9 si esta en la lista.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ohzMR-kzZpkj"
      },
      "source": [
        "# Generar una lista de números aleatorios sin repetición\n",
        "La librería ```random``` tiene una función que nos permite generar listas, sin repetición, utilizando la función sample."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ziHsmjP-af_u",
        "outputId": "a3a6e72f-3c20-409d-ae8a-5c244707da65"
      },
      "source": [
        "import random\n",
        "# genera 5 números aleatorios entre 10 and 20\n",
        "randomlist = random.sample(range(10, 21), 5)\n",
        "print(randomlist)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[15, 13, 10, 16, 17]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "6Kz20jjcbGu3",
        "outputId": "bd210d69-12e8-4cda-fe79-db88454419ae"
      },
      "source": [
        "# ordenando la lista\n",
        "randomlist.sort()\n",
        "print(randomlist)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[10, 13, 15, 16, 17]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "vwlFRebDbsmB"
      },
      "source": [
        "### Comprobar si un número está en una lista de números aleatorios\n",
        "* Generar una lista de 20 números aleatorios enteros entre 1 y 99, ambos incluidos.\n",
        "* Imprimir la lista ordenada.\n",
        "* Generar un número aleatorio entero entre 1 y 99\n",
        "* Imprimir el número.\n",
        "* Comprobar si ese número sumado a alguno de los elementos de la lista da 100."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "LGfwLrcjS4bb"
      },
      "source": [
        "#### Solución 1. Usando ```in```"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "61as9ODT7CRf",
        "outputId": "f518d7ef-4d3f-4fed-8a44-c3dc123903ee"
      },
      "source": [
        "import random\n",
        "lista = random.sample(range(1, 100), 20)\n",
        "lista.sort()\n",
        "print(lista)\n",
        "num =random.randint(1,100)\n",
        "print(num)\n",
        "if 100-num in lista:                               # si 100-num está en la lista quiere decir que num más algún valor de la lista suman 100\n",
        "  print(f\"El número {num} cumple la condición.\")\n",
        "\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[1, 3, 11, 21, 24, 29, 33, 37, 44, 45, 55, 56, 59, 67, 84, 86, 93, 96, 98, 99]\n",
            "67\n",
            "El número 67 cumple la condición.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "GtLwWBR0TDZt"
      },
      "source": [
        "#### Solución 2. Usando ```for``` y una bandera lógica"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "GsrAR9KmTHNn",
        "outputId": "7c6ed082-6310-479c-9e1e-14c9dc455e66"
      },
      "source": [
        "import random\n",
        "lista = random.sample(range(1, 100), 20)\n",
        "lista.sort()\n",
        "print(lista)\n",
        "num =random.randint(1,100)\n",
        "print(num)\n",
        "\n",
        "encontrado = False            # bandera\n",
        "\n",
        "for elemento in lista:        # para cada elemento en la lista\n",
        "  if num+elemento==100:       # si se cumple la condición\n",
        "    encontrado = True         # hacemos que la bandera sea True\n",
        "\n",
        "if encontrado:                # si la bandera es True\n",
        "  print(f\"El número {num} si cumple la condición.\")\n",
        "else:\n",
        "  print(f\"El número {num} no cumple la condición.\")\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[7, 9, 17, 20, 28, 32, 33, 38, 53, 54, 57, 58, 61, 64, 66, 67, 82, 83, 91, 96]\n",
            "80\n",
            "El número 80 si cumple la condición.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "MvaKwdT5BHsT"
      },
      "source": [
        "### Reto 8.3. Ver en cuantas tiradas un número está en una lista de números aleatorios\n",
        "* Generar una lista de 20 números aleatorios enteros entre 1 y 99, ambos incluidos.\n",
        "* Generar un número aleatorio entero entre 1 y 99\n",
        "* Comprobar si ese número sumado a alguno de los elementos de la lista da 100.\n",
        "* Si ese número no da 100 con ninguno de los elementos de la lista, en otra tirada, generar otro número y comprobar la condición de la suma.\n",
        "* Al final se pide mostrar por pantalla:\n",
        " - La lista ordenada\n",
        " - Los dos números que sumados dan 100\n",
        " - El número de tiradas que han sido necesarias para conseguirlo."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "xH_bwqK3WDs2"
      },
      "source": [
        "## Generación de una lista de números aleatorios con repetición\n",
        "Usando la librería ```random``` y la función ```choices``` podemos generar una lista de números aleatorios enteros con posible repetición.\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "EIk1cmDsXNCB",
        "outputId": "0a4bab7a-c614-4f42-8c15-af7afd5c8398"
      },
      "source": [
        "import random\n",
        "random.seed()\n",
        "lista = random.choices(range(10), k=8)   # elige 8 elementos, con posible repetición, del rango que va entre 0 y 9\n",
        "print(lista)                             # imprimimos la lista\n",
        "lista.sort()\n",
        "lista                                    # imprimimos la list ordenada"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[41, 25, 20, 11, 22, 15, 13, 28, 33, 39, 14, 37, 39, 20, 21, 32, 35, 24, 20]\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[11, 13, 14, 15, 20, 20, 20, 21, 22, 24, 25, 28, 32, 33, 35, 37, 39, 39, 41]"
            ]
          },
          "metadata": {},
          "execution_count": 16
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "2og-JXBATWZ3"
      },
      "source": [
        "## Cuantas veces aparece un número en una lita\n",
        "Dada una lista decir cuantas veces aparece un elemento.\n",
        "\n",
        "Para resolverlo, es preferible usar un ```for``` en lugar de un ```in``` ya que la instrucción ```in``` solo nos proporcionará si el número está o no en la lista, pero no nos dice cuantas veces aparece."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "qhKeR0PETmaI",
        "outputId": "7f47fc77-33b7-4466-dc3f-ea892e92fa14"
      },
      "source": [
        "lista = [41, 25, 20, 11, 22, 15, 13, 28, 33, 39, 14, 37, 39, 20, 21, 32, 35, 24, 20]\n",
        "print(lista)\n",
        "num = 20                 # queremos saber cuantas veces aparece le 20 en la lista\n",
        "contador = 0\n",
        "for elemento in lista:   # para cada elemento de la lista\n",
        "  if elemento==num:\n",
        "    contador += 1\n",
        "\n",
        "print(f\"El número {num} aparece {contador} veces en la lista.\")\n",
        "lista.sort()\n",
        "print(lista)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[41, 25, 20, 11, 22, 15, 13, 28, 33, 39, 14, 37, 39, 20, 21, 32, 35, 24, 20]\n",
            "El número 20 aparece 3 veces en la lista.\n",
            "[11, 13, 14, 15, 20, 20, 20, 21, 22, 24, 25, 28, 32, 33, 35, 37, 39, 39, 41]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "3AEQnpKFFsjk"
      },
      "source": [
        "### Reto 8.4. Frecuencia de cada elemento de una lista\n",
        "* Generar una lista de 19 números aleatorios enteros, entre 1 y 30, ambos incluidos, con posible repetición.\n",
        "* Mostrar en pantalla, cada elemento de esa lista en orden creciente, indicando cuántas veces aparece, esto es, indicando su frecuencia.\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "WFOk4lVRYxDw"
      },
      "source": [
        "### Dada una tupla con los meses calcular cuántos tienen 'r'.\n",
        "Mostrar los meses que tienen 'r' y decir cuántos son.  \n",
        "El saber popular dice que los meses con 'r' son buenos meses para el marisco."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "OD0BWyGIO98E"
      },
      "source": [
        "#### Solución 1\n",
        "Imprimiendo los meses."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "QxxcxZJjUO97",
        "outputId": "2ab667ae-1231-48e9-e4ca-13fb00ca31a2"
      },
      "source": [
        "meses = (\"Enero\",\"Febrero\",\"Marzo\",\"Abril\",\"Mayo\",\"Junio\",\"Julio\",\"Agosto\",\"Septiembre\",\"Octubre\",\"Noviembre\",\"Diciembre\")\n",
        "contador = 0\n",
        "for mes in meses:\n",
        "  if 'r' in mes:\n",
        "    contador += 1\n",
        "    print(mes)\n",
        "\n",
        "print(f\"Existen {contador} meses con 'r'.\")"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Enero\n",
            "Febrero\n",
            "Marzo\n",
            "Abril\n",
            "Septiembre\n",
            "Octubre\n",
            "Noviembre\n",
            "Diciembre\n",
            "Existen 8 meses con 'r'.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "XvSD-ECAPQQV"
      },
      "source": [
        "#### Solución 2\n",
        "Creando una tupla con los meses que cumplen la condición."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "W6FHFNgOPYZS",
        "outputId": "98b6b82c-2ab4-40fe-9d1a-005d9bd8115a"
      },
      "source": [
        "meses = (\"Enero\",\"Febrero\",\"Marzo\",\"Abril\",\"Mayo\",\"Junio\",\"Julio\",\"Agosto\",\"Septiembre\",\"Octubre\",\"Noviembre\",\"Diciembre\")\n",
        "contador = 0\n",
        "meses_elegidos = ()    # inicializamos una tupla vacía\n",
        "\n",
        "for mes in meses:\n",
        "  if 'r' in mes:\n",
        "    contador += 1\n",
        "    meses_elegidos += (mes,)   # añadimos los meses a la tupla, la coma es necesaria\n",
        "\n",
        "print(f\"Existen {contador} meses con 'r'.\")\n",
        "print(meses_elegidos)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Existen 8 meses con 'r'.\n",
            "('Enero', 'Febrero', 'Marzo', 'Abril', 'Septiembre', 'Octubre', 'Noviembre', 'Diciembre')\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "8vRpPUrhQCz0"
      },
      "source": [
        "#### Solución 3\n",
        "Creando una lista con los meses que cumplen la condición."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "FctEYzkQQLgA",
        "outputId": "1ddcdf09-04db-4e02-a600-58b7713f99cd"
      },
      "source": [
        "meses = (\"Enero\",\"Febrero\",\"Marzo\",\"Abril\",\"Mayo\",\"Junio\",\"Julio\",\"Agosto\",\"Septiembre\",\"Octubre\",\"Noviembre\",\"Diciembre\")\n",
        "contador = 0\n",
        "meses_elegidos = []    # inicializamos una lista vacía\n",
        "\n",
        "for mes in meses:\n",
        "  if 'r' in mes:\n",
        "    contador += 1\n",
        "    meses_elegidos += [mes]   # añadimos los meses a la lista\n",
        "\n",
        "print(f\"Existen {contador} meses con 'r'.\")\n",
        "print(meses_elegidos)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Existen 8 meses con 'r'.\n",
            "['Enero', 'Febrero', 'Marzo', 'Abril', 'Septiembre', 'Octubre', 'Noviembre', 'Diciembre']\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "KNIhCy_hQixo"
      },
      "source": [
        "#### Solución 4\n",
        "Creando una lista con los meses que cumplen la condición, usando ```append```."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "5iBq-JPjQqv7",
        "outputId": "08643ec1-ac30-4cc3-b4ef-ac56b4bdefe5"
      },
      "source": [
        "meses = (\"Enero\",\"Febrero\",\"Marzo\",\"Abril\",\"Mayo\",\"Junio\",\"Julio\",\"Agosto\",\"Septiembre\",\"Octubre\",\"Noviembre\",\"Diciembre\")\n",
        "contador = 0\n",
        "meses_elegidos = []    # inicializamos una lista vacía\n",
        "\n",
        "for mes in meses:\n",
        "  if 'r' in mes:\n",
        "    contador += 1\n",
        "    meses_elegidos.append(mes)   # añadimos los meses a la lista usando append\n",
        "\n",
        "print(f\"Existen {contador} meses con 'r'.\")\n",
        "print(meses_elegidos)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Existen 8 meses con 'r'.\n",
            "['Enero', 'Febrero', 'Marzo', 'Abril', 'Septiembre', 'Octubre', 'Noviembre', 'Diciembre']\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "vy2lUnSLQ5RQ"
      },
      "source": [
        "## Ver si un elemento está en la lista y su índice\n",
        "Creamos un programa que comprueba si un elemento está en la lista y nos dice en qué posición (índice) se encuentra."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "66msv0Q2RQjS",
        "outputId": "6eca9b58-619f-4069-f5ca-9cd69421489e"
      },
      "source": [
        "lista = [41,25,11,22,15,13,28,33,39,14,37,20,21,32,35,24]\n",
        "print(lista)\n",
        "num = 25\n",
        "\n",
        "for i in range(len(lista)):\n",
        "  if lista[i]==num:\n",
        "    print(f\"El número {num} está en la lista en el índice {i}.\")"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[41, 25, 11, 22, 15, 13, 28, 33, 39, 14, 37, 20, 21, 32, 35, 24]\n",
            "El número 25 está en la lista en el índice 1.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "sVen-xjbU-6A"
      },
      "source": [
        "## Tabla de multiplicar de un número dado\n",
        "Dado un número mostrar su tabla de multiplicar."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "odJyn4DaVGsJ",
        "outputId": "4ed918ac-7f18-4ab2-f9aa-f9f90768590a"
      },
      "source": [
        "n = int(input(\"Dime un número entre 1 y 10: \"))\n",
        "for i in range(1,11):\n",
        "  print(f\"{n}x{i}={n*i}\")"
      ],
      "execution_count": 3,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Dime un número entre 1 y 10: 7\n",
            "7x1=7\n",
            "7x2=14\n",
            "7x3=21\n",
            "7x4=28\n",
            "7x5=35\n",
            "7x6=42\n",
            "7x7=49\n",
            "7x8=56\n",
            "7x9=63\n",
            "7x10=70\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "FMV6_BTTVu38"
      },
      "source": [
        "## Comprobar si un número está dentro de un rango\n",
        "Dado un objeto de tipo ```range``` y un número, comprobar si está dentro del rango."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "fzxZRT0cW6DZ"
      },
      "source": [
        "#### Solución 1\n",
        "Usando ```in```."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "iYo1QN2PV9XK",
        "outputId": "55fbfc22-3c18-491a-826a-3c49bf9250c6"
      },
      "source": [
        "num = 6\n",
        "rango = range(2,101,2)     # step=2 y comenzando en 2, son 50 pares\n",
        "if num in rango:\n",
        "  print(f\"El número {num} si está dentro del rango.\")\n",
        "else:\n",
        "  print(f\"El número {num} no está dentro del rango.\")"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "El número 6 si está dentro del rango.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "87m10nrSXC-d"
      },
      "source": [
        "#### Solución 2\n",
        "Usando un ```for``` y hanciendo un rango más grande.  \n",
        "Deseamos mostrar que la condición se cumple al inicio del bucle y luego el resto de las comprobaciones no serían necesarias.  \n",
        "Estaría bien disponer de una instrucción que nos permitiera salir del bucle una vez que ya hemos comprobado que se cumple la condición."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "CyzMyrdcXJ29",
        "outputId": "cb21fc39-f733-49f1-b459-745a9195f667"
      },
      "source": [
        "num = 6\n",
        "rango = range(2,101,2)\n",
        "for i in rango:\n",
        "  if i==num:\n",
        "    print(f\"El número {num} si está dentro del rango.\")\n",
        "  else:\n",
        "    print(f\"No está.\")"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "No está.\n",
            "No está.\n",
            "El número 6 si está dentro del rango.\n",
            "No está.\n",
            "No está.\n",
            "No está.\n",
            "No está.\n",
            "No está.\n",
            "No está.\n",
            "No está.\n",
            "No está.\n",
            "No está.\n",
            "No está.\n",
            "No está.\n",
            "No está.\n",
            "No está.\n",
            "No está.\n",
            "No está.\n",
            "No está.\n",
            "No está.\n",
            "No está.\n",
            "No está.\n",
            "No está.\n",
            "No está.\n",
            "No está.\n",
            "No está.\n",
            "No está.\n",
            "No está.\n",
            "No está.\n",
            "No está.\n",
            "No está.\n",
            "No está.\n",
            "No está.\n",
            "No está.\n",
            "No está.\n",
            "No está.\n",
            "No está.\n",
            "No está.\n",
            "No está.\n",
            "No está.\n",
            "No está.\n",
            "No está.\n",
            "No está.\n",
            "No está.\n",
            "No está.\n",
            "No está.\n",
            "No está.\n",
            "No está.\n",
            "No está.\n",
            "No está.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "nMknIUmgYFnc"
      },
      "source": [
        "#### Solución 3\n",
        "Usando un ```for``` y usando un ```brake``` que nos permite salir del bucle.  \n",
        "De esta forma conseguimos que no sea necesario imprimir 50 frases, sino solo 3, ya que cuando se cumple la condición finaliza el bucle."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "CMnF2WvZYVua",
        "outputId": "da6e6468-667e-4dc6-f6f1-0f3396d528da"
      },
      "source": [
        "num = 6\n",
        "rango = range(2,101,2)\n",
        "for i in rango:\n",
        "  if i==num:\n",
        "    print(f\"El número {num} si está dentro del rango.\")\n",
        "    break                                                 # permite salir del bucle\n",
        "    print(\"Esta frase está después del 'break' y nunca se imprimirá\") # esto nunca se imprime\n",
        "  else:\n",
        "    print(f\"No está.\")\n",
        "\n",
        "print(\"Fin del programa.\")"
      ],
      "execution_count": 2,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "No está.\n",
            "No está.\n",
            "El número 6 si está dentro del rango.\n",
            "Fin del programa.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "1pf1UqCEfm1g"
      },
      "source": [
        "### Reto 8.5. Comprobar valores de una lista\n",
        "* Dada una lista de edades, comprobar que están en el rango entre 14 y 24, ambas incluidas.  \n",
        "* Por cada edad ir diciendo si está en el rango o no.\n",
        "* Si existe alguna fuera del rango, informar que no está en el rango y deterner la comprobación.\n",
        "* edades = [15, 22, 20, 26, 23, 18, 17, 24, 21, 19, 14]"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "V1rcBqgVLtFg",
        "outputId": "bec86303-d2cb-4c33-8242-1d38ed8e69fd"
      },
      "source": [
        "import random\n",
        "# genera 5 números aleatorios entre 10 and 20\n",
        "randomlist = random.sample(range(14, 25), 10)\n",
        "print(randomlist)"
      ],
      "execution_count": 9,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[15, 22, 20, 23, 18, 17, 24, 21, 19, 14]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ODHbKkD5OM7Z"
      },
      "source": [
        "### Adivinar un número\n",
        "Dado un número secreto entre 1 y 10, pedir al usuario que diga números en ese rango hasta que lo adivine.  \n",
        "En el momento en el que se adivina al número ya no se siguen pidiendo número y finaliza el programa."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "-MieZYSNOuuv"
      },
      "source": [
        "#### Solución 1. Usando una bandera\n",
        "Será necesario usar un bucle ```while``` ya que no sabemos en cuantas tiradas se adivinará el número secreto."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "8g6YVahTPShI",
        "outputId": "787702c6-65ef-4e3a-885f-1031c456821f"
      },
      "source": [
        "secreto = 3\n",
        "jugando = True             # bandera\n",
        "while jugando:\n",
        "  n = int(input(\"Diga un número entre 1 y 10: \"))\n",
        "  if n==secreto:\n",
        "    print(f\"Felicidades, adivinó que el número secreto es {n}.\")\n",
        "    jugando = False\n",
        "  else:\n",
        "    print(\"No es correcto.\")\n",
        "\n",
        "print(\"Fin del programa.\")"
      ],
      "execution_count": 13,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Diga un número entre 1 y 10: 1\n",
            "No es correcto.\n",
            "Diga un número entre 1 y 10: 2\n",
            "No es correcto.\n",
            "Diga un número entre 1 y 10: 3\n",
            "Felicidades, adivinó que el número secreto es 3.\n",
            "Fin del programa.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "j40S4qcaPGAi"
      },
      "source": [
        "#### Solución 2. Usando ```break```\n",
        "También usaremos un bucle ```while```."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Gbt7Jn-RQP_I",
        "outputId": "3db306b2-6cb5-4dc5-8d33-ba18f04be047"
      },
      "source": [
        "secreto = 3\n",
        "while True:\n",
        "  n = int(input(\"Diga un número entre 1 y 10: \"))\n",
        "  if n==secreto:\n",
        "    print(f\"Felicidades, adivinó que el número secreto es {n}.\")\n",
        "    break\n",
        "  else:\n",
        "    print(\"No es correcto.\")\n",
        "\n",
        "print(\"Fin del programa.\")"
      ],
      "execution_count": 14,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Diga un número entre 1 y 10: 1\n",
            "No es correcto.\n",
            "Diga un número entre 1 y 10: 2\n",
            "No es correcto.\n",
            "Diga un número entre 1 y 10: 3\n",
            "Felicidades, adivinó que el número secreto es 3.\n",
            "Fin del programa.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Czxyen5kQod0"
      },
      "source": [
        "## Sentencia ```break``` en un ```for```\n",
        "### Juego para adivinar una letra\n",
        "El juego te pide continuamente que adivines la letra secreta.\n",
        "Se puede probar con cualquier letra salvo la 'ñ' que no está permitida y el juego se para."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "j1zNUxaCRpUb"
      },
      "source": [
        "#### Solución 1\n",
        "Usando solo una bandera."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "xEvDENCjRtJj",
        "outputId": "973f8f86-5709-4ed3-8d92-1ed649713c3b"
      },
      "source": [
        "letra = 'p'\n",
        "jugando = True                               # usamos solo una bandera\n",
        "while jugando:\n",
        "  intento = input(\"Dime una letra: \")\n",
        "  if intento != letra:\n",
        "    if intento == \"ñ\":\n",
        "      print(\"Esta letra no está permitida.\")\n",
        "      jugando = False                        # aquí la bandera es False si hemos pulsado la letra no permitida\n",
        "    else:\n",
        "      print(\"No es correcta.\")\n",
        "  else:\n",
        "    print(\"Felicidades, has acertado\")\n",
        "    jugando = False                          # aquí la bandera el False si ya hemos ganado y se termina el juego"
      ],
      "execution_count": 17,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Dime una letra: f\n",
            "No es correcta.\n",
            "Dime una letra: e\n",
            "No es correcta.\n",
            "Dime una letra: ñ\n",
            "Esta letra no está permitida.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "WieP3XyRTSD8"
      },
      "source": [
        "#### Solución 2\n",
        "Usando dos banderas:\n",
        "* una para controlar si la letra está o no permitida\n",
        "* otra para controlar si se ha ganado el juego en cuyo caso se finaliza "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "w5_AWdqYTosh",
        "outputId": "34a00570-8fd1-4de8-fc4d-a861f91dd933"
      },
      "source": [
        "letra = 'p'\n",
        "jugando = True                               # usamos una bandera para controlar si se ha ganado\n",
        "correcto = True                              # usamos otra bandera para saber si la letra está permitida\n",
        "while jugando and correcto:\n",
        "  intento = input(\"Dime una letra: \")\n",
        "  if intento != letra:\n",
        "    if intento == \"ñ\":\n",
        "      print(\"Esta letra no está permitida.\")\n",
        "      correcto = False                        # aquí la bandera es False si hemos pulsado la letra no permitida\n",
        "    else:\n",
        "      print(\"No es correcta.\")\n",
        "  else:\n",
        "    print(\"Felicidades, has acertado\")\n",
        "    jugando = False                          # aquí la bandera el False si ya hemos ganado y se termina el juego"
      ],
      "execution_count": 19,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Dime una letra: q\n",
            "No es correcta.\n",
            "Dime una letra: w\n",
            "No es correcta.\n",
            "Dime una letra: o\n",
            "No es correcta.\n",
            "Dime una letra: p\n",
            "Felicidades, has acertado\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "sQBJCSxRU6dr"
      },
      "source": [
        "#### Solución 3\n",
        "Con una bandera y un ```break```."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "s_fzQ04iU_4p",
        "outputId": "1a248923-dfaf-471a-923f-b1f96b3dae20"
      },
      "source": [
        "letra = 'p'\n",
        "jugando = True                               # usamos solo una bandera y un breake\n",
        "while jugando:\n",
        "  intento = input(\"Dime una letra: \")\n",
        "  if intento != letra:\n",
        "    if intento == \"ñ\":\n",
        "      print(\"Esta letra no está permitida.\")\n",
        "      break                        # aquí el break si hemos pulsado la letra no permitida\n",
        "    else:\n",
        "      print(\"No es correcta.\")\n",
        "  else:\n",
        "    print(\"Felicidades, has acertado\")\n",
        "    jugando = False                          # aquí la bandera el False si ya hemos ganado y se termina el juego"
      ],
      "execution_count": 23,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Dime una letra: q\n",
            "No es correcta.\n",
            "Dime una letra: w\n",
            "No es correcta.\n",
            "Dime una letra: o\n",
            "No es correcta.\n",
            "Dime una letra: p\n",
            "Felicidades, has acertado\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "UvEdB-3ygTNY"
      },
      "source": [
        "#### Solución 4\n",
        "Usando dos ```break``` y sin banderas."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "morH-C1Mgkmm",
        "outputId": "3dbfca9e-9391-4e91-e5ea-57710a61c43a"
      },
      "source": [
        "letra = 'p'\n",
        "\n",
        "while True:\n",
        "  intento = input(\"Dime una letra: \")\n",
        "  if intento != letra:\n",
        "    if intento == \"ñ\":\n",
        "      print(\"Esta letra no está permitida.\")\n",
        "      break                        # aquí el break si hemos pulsado la letra no permitida\n",
        "    else:\n",
        "      print(\"No es correcta.\")\n",
        "  else:\n",
        "    print(\"Felicidades, has acertado\")\n",
        "    break                          # este break actúa cuando se acierta y finaliza el juego"
      ],
      "execution_count": 2,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Dime una letra: k\n",
            "No es correcta.\n",
            "Dime una letra: l\n",
            "No es correcta.\n",
            "Dime una letra: ñ\n",
            "Esta letra no está permitida.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "GgfuUCzohzU1"
      },
      "source": [
        "## Sentencia ```continue``` en un ```for```\n",
        "Programa que muestra todas las letras de un palabra a excepción de la 'h'."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "qoTZGYMOiHn2",
        "outputId": "1a686f0f-f0d6-4f14-9355-3d80889d34db"
      },
      "source": [
        "palabra = 'zanahoria'\n",
        "for letra in palabra:\n",
        "  if letra=='h':\n",
        "    continue    # al llegar al 'continue' ya no se sigue ejecutando y comienza una nueva iteración\n",
        "  print(letra)"
      ],
      "execution_count": 3,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "z\n",
            "a\n",
            "n\n",
            "a\n",
            "o\n",
            "r\n",
            "i\n",
            "a\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "7GtjnziWlBBP"
      },
      "source": [
        "### Reto 8.6. Recorre una lista y saltar un número\n",
        "Dada una lista con números positivos, negativos o ceros, recorrer la lista diciendo si el número es positivo o negativo. Si se trata de un cero se salta y no se dice nada.\n",
        "\n",
        "numeros = [3,-2,7,4,-3,0,-5,-9,0,5]"
      ]
    }
  ]
}