{
"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
}
]
}
]
}