{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "authorship_tag": "ABX9TyOvZ5dJCLARb21GNOkgiahn",
      "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/financieras/AdventOfCode2021/blob/master/test.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "kTtdRJZ9QNRA",
        "outputId": "ae91ce70-0021-4c90-ae89-89eb422f9f0f"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Suma: 8\n",
            "Resta: 6\n",
            "Multiplicación: 12\n",
            "División: 5.0\n",
            "Operación inválida: None\n"
          ]
        }
      ],
      "source": [
        "def operacion_matematica(operador):\n",
        "    if operador == 'suma':\n",
        "        return lambda a, b: a + b\n",
        "    elif operador == 'resta':\n",
        "        return lambda a, b: a - b\n",
        "    elif operador == 'multiplicacion':\n",
        "        return lambda a, b: a * b\n",
        "    elif operador == 'division':\n",
        "        return lambda a, b: a / b\n",
        "    else:\n",
        "        return lambda a, b: None  # Si el operador no es válido, devuelve None\n",
        "\n",
        "# Definir las funciones lambda dentro de la función operacion_matematica\n",
        "suma = operacion_matematica('suma')\n",
        "resta = operacion_matematica('resta')\n",
        "multiplicacion = operacion_matematica('multiplicacion')\n",
        "division = operacion_matematica('division')\n",
        "\n",
        "# Utilizar las funciones lambda definidas dentro de la función operacion_matematica\n",
        "print(\"Suma:\", suma(5, 3))                 # Salida: 8\n",
        "print(\"Resta:\", resta(10, 4))               # Salida: 6\n",
        "print(\"Multiplicación:\", multiplicacion(2, 6))  # Salida: 12\n",
        "print(\"División:\", division(15, 3))         # Salida: 5.0\n",
        "print(\"Operación inválida:\", operacion_matematica('potencia')(2, 3))  # Salida: None\n"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "def ordenar_por_criterio(lista, criterio):\n",
        "    # Utilizar una función lambda para definir el criterio de ordenamiento\n",
        "    if criterio == 'longitud':\n",
        "        return sorted(lista, key=lambda x: len(x))\n",
        "    elif criterio == 'mayusculas':\n",
        "        return sorted(lista, key=lambda x: x.upper())\n",
        "    elif criterio == 'minusculas':\n",
        "        return sorted(lista, key=lambda x: x.lower())\n",
        "    else:\n",
        "        return None  # Si el criterio no es válido, devuelve None\n",
        "\n",
        "# Lista de palabras desordenadas\n",
        "palabras = ['Python', 'es', 'un', 'lenguaje', 'de', 'programacion']\n",
        "\n",
        "# Ordenar la lista por longitud de palabras utilizando una función lambda dentro de otra función\n",
        "print(\"Ordenado por longitud:\", ordenar_por_criterio(palabras, 'longitud'))\n",
        "# Salida: ['es', 'un', 'de', 'Python', 'programacion', 'lenguaje']\n",
        "\n",
        "# Ordenar la lista por palabras en mayúsculas utilizando una función lambda dentro de otra función\n",
        "print(\"Ordenado por mayúsculas:\", ordenar_por_criterio(palabras, 'mayusculas'))\n",
        "# Salida: ['de', 'es', 'lenguaje', 'programacion', 'Python', 'un']\n",
        "\n",
        "# Ordenar la lista por palabras en minúsculas utilizando una función lambda dentro de otra función\n",
        "print(\"Ordenado por minúsculas:\", ordenar_por_criterio(palabras, 'minusculas'))\n",
        "# Salida: ['de', 'es', 'lenguaje', 'programacion', 'Python', 'un']\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Jti4jO56Q50t",
        "outputId": "6fc83e4c-6ef7-4646-8389-9c9e4a7f5e3f"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Ordenado por longitud: ['es', 'un', 'de', 'Python', 'lenguaje', 'programacion']\n",
            "Ordenado por mayúsculas: ['de', 'es', 'lenguaje', 'programacion', 'Python', 'un']\n",
            "Ordenado por minúsculas: ['de', 'es', 'lenguaje', 'programacion', 'Python', 'un']\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "def filtrar_lista(lista, condicion):\n",
        "    # Utilizar una función lambda para filtrar la lista según la condición especificada\n",
        "    return list(filter(lambda x: condicion(x), lista))\n",
        "\n",
        "# Lista de números\n",
        "numeros = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]\n",
        "\n",
        "# Función lambda para verificar si un número es par\n",
        "es_par = lambda x: x % 2 == 0\n",
        "\n",
        "# Función lambda para verificar si un número es impar\n",
        "es_impar = lambda x: x % 2 != 0\n",
        "\n",
        "# Filtrar la lista de números para obtener solo los pares utilizando una función lambda dentro de otra función\n",
        "numeros_pares = filtrar_lista(numeros, es_par)\n",
        "print(\"Números pares:\", numeros_pares)  # Salida: [2, 4, 6, 8, 10]\n",
        "\n",
        "# Filtrar la lista de números para obtener solo los impares utilizando una función lambda dentro de otra función\n",
        "numeros_impares = filtrar_lista(numeros, es_impar)\n",
        "print(\"Números impares:\", numeros_impares)  # Salida: [1, 3, 5, 7, 9]\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "kn3LGAKeRanE",
        "outputId": "170d09a1-babe-43e9-f34a-0277f82c0c40"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Números pares: [2, 4, 6, 8, 10]\n",
            "Números impares: [1, 3, 5, 7, 9]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "def funcion_padre():\n",
        "    # Definir una función lambda dentro de otra función que recibe dos parámetros\n",
        "    elevar = lambda x, y: x ** y\n",
        "    # Utilizar la función lambda definida dentro de la función padre\n",
        "    return elevar(2, 3)  # Elevar 2 a la potencia 3\n",
        "\n",
        "# Llamar a la función padre\n",
        "print(funcion_padre())  # Salida: 8\n"
      ],
      "metadata": {
        "id": "6-Oqx4itSpQ3"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "def operacion_matematica(x, y):\n",
        "    # Definir una función lambda dentro de otra función que recibe dos parámetros\n",
        "    diferencia_cuadrados = lambda a, b: a ** 2 - b ** 2  # a^2-b^2\n",
        "    # Utilizar la función lambda definida dentro de la función padre\n",
        "    return diferencia_cuadrados(x, y)  # Realizar la operación matemática con los valores x e y\n",
        "\n",
        "# Llamar a la función para calcular la operación matemática con diferentes valores\n",
        "print(\"Resultado:\", operacion_matematica(5, 3))  # 5 ** 2 - 3 ** 2 = 16\n",
        "print(\"Resultado:\", operacion_matematica(10, 5)) # 10 ** 2 - 5 ** 2 = 75"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Ji0aZAGcTlLj",
        "outputId": "c52135d9-aeb4-4b18-8b29-4366f1ffddf6"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Resultado: 16\n",
            "Resultado: 75\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "def aumentar_valor(n):\n",
        "    # Definir una función lambda dentro de otra función\n",
        "    amplificar = lambda x: x * n\n",
        "    # Utilizar la función lambda definida dentro de la función padre\n",
        "    doblar = amplificar(2)      # doble de n\n",
        "    triplicar = amplificar(3)   # triple de n\n",
        "    return doblar + triplicar\n",
        "\n",
        "# Llamar a la función padre\n",
        "print(aumentar_valor(10))  # Salida: 50"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "TO5X54JrU8vo",
        "outputId": "797003ba-c77c-4442-9744-4cb00f23f2be"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "50\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "def myfunc(n):\n",
        "  return lambda a : a * n\n",
        "\n",
        "mydoubler = myfunc(2)\n",
        "print(mydoubler)\n",
        "\n",
        "print(mydoubler(11))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "2Y0TzzQbW70U",
        "outputId": "11c0be6e-e4f5-4895-e8d9-cced0d08430a"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "<function myfunc.<locals>.<lambda> at 0x7f80d5c89990>\n",
            "22\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "_=lambda x,y: x+y\n",
        "_(2,3)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "tkBGVsZMmWfH",
        "outputId": "c9900cad-7613-4a71-bb9b-b263b94fe674"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "5"
            ]
          },
          "metadata": {},
          "execution_count": 12
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "(lambda x, y: x + y)(2, 6)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "oPj-OgFNm3OK",
        "outputId": "3ecb8f04-7aba-4481-c846-702a54781a9d"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "8"
            ]
          },
          "metadata": {},
          "execution_count": 13
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "doble = lambda x: 2 * x\n",
        "\n",
        "doble(4)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "YYXq5JLtpYuY",
        "outputId": "bf97f9b5-e319-4fee-adad-999e01780945"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "8"
            ]
          },
          "metadata": {},
          "execution_count": 14
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "maxi = lambda a,b: a if a > b else b\n",
        "\n",
        "maxi(-2, -7)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "z354p2X_qlAq",
        "outputId": "21f0e63b-32e1-49ef-bd83-594b77c27751"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "-2"
            ]
          },
          "metadata": {},
          "execution_count": 15
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "matriz = [[2, 3, 4], [30, 4, 12, 0], [1, 4, 15, 20]]\n",
        "\n",
        "# Lambda para ordenar cada fila de la matriz\n",
        "ordenar = lambda x: [sorted(i) for i in x]\n",
        "\n",
        "# Lambda para encontrar el segundo mayor elemento de cada fila\n",
        "segundo_mayor = lambda matrix, ordena: [y[-2] for y in ordena(matrix)]\n",
        "\n",
        "# Llamar a la función segundo_mayor con la matriz y la función de ordenamiento\n",
        "print(segundo_mayor(matriz, ordenar))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "-raoWy0vrPQN",
        "outputId": "2bd865d4-d5ab-4eb4-b2de-dc593544539a"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[3, 12, 15]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "def segundo_max(matriz):\n",
        "    result = []\n",
        "    for fila in matriz:\n",
        "        result.append(sorted(list(set(fila)))[-2])\n",
        "    return result\n",
        "\n",
        "matriz = [[2, 3, 4], [30, 4, 12, 0], [1, 4, 20, 20]]\n",
        "segundo_max(matriz)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "zuOLVxyGviCn",
        "outputId": "259a9987-66bc-4ee1-8903-c64fc1187b74"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[3, 12, 4]"
            ]
          },
          "metadata": {},
          "execution_count": 32
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "matriz = [[2, 3, 4], [30, 4, 12, 0], [1, 4, 20, 20]]\n",
        "\n",
        "# Lambda para ordenar cada fila de la matriz\n",
        "ordenar = lambda x: [sorted(i) for i in x]\n",
        "\n",
        "# Lambda para encontrar el segundo mayor elemento de cada fila\n",
        "segundo_mayor = lambda matrix, ordena: [y[-2] for y in ordena(matrix)]\n",
        "\n",
        "# Llamar a la función segundo_mayor con la matriz y la función de ordenamiento\n",
        "print(segundo_mayor(matriz, ordenar))\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "k7-cDbBlyB-n",
        "outputId": "31fae90c-7d46-4207-dea5-8f2337d7da2a"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[3, 12, 20]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Uso de reduce\n",
        "# se necesitan dos cosas:\n",
        "#   1. Una función (que en este caso es una función lambda)\n",
        "#   2. Un iterable (que en este caso es una lista)\n",
        "\n",
        "from functools import reduce\n",
        "\n",
        "def producto(lista):\n",
        "    return reduce(lambda a,b:a*b, lista)\n",
        "\n",
        "lista = [2,4,3,6,7]\n",
        "producto(lista)"
      ],
      "metadata": {
        "id": "s6kTtwGzoVea",
        "outputId": "a8d6c6ce-24cd-43bf-dbab-11cb2fa51d3a",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": 1,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "1008"
            ]
          },
          "metadata": {},
          "execution_count": 1
        }
      ]
    }
  ]
}