PRG_K09_Lambdas.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "03dd0e09",
   "metadata": {
    "toc": true
   },
   "source": [
    "<h1>Table of Contents<span class=\"tocSkip\"></span></h1>\n",
    "<div class=\"toc\"><ul class=\"toc-item\"><li><span><a href=\"#K09.-Lambdas-básico\" data-toc-modified-id=\"K09.-Lambdas-básico-1\">K09. Lambdas básico</a></span><ul class=\"toc-item\"><li><span><a href=\"#1.-Introdución\" data-toc-modified-id=\"1.-Introdución-1.1\">1. Introdución</a></span></li><li><span><a href=\"#2.-Definición-de-Lambdas\" data-toc-modified-id=\"2.-Definición-de-Lambdas-1.2\">2. Definición de Lambdas</a></span><ul class=\"toc-item\"><li><span><a href=\"#Sintaxis-simplificada\" data-toc-modified-id=\"Sintaxis-simplificada-1.2.1\">Sintaxis simplificada</a></span></li></ul></li><li><span><a href=\"#3.-Lambdas-como-argumentos-de-funciones\" data-toc-modified-id=\"3.-Lambdas-como-argumentos-de-funciones-1.3\">3. Lambdas como argumentos de funciones</a></span></li><li><span><a href=\"#4.-Lambdas-sin-valor-de-retorno\" data-toc-modified-id=\"4.-Lambdas-sin-valor-de-retorno-1.4\">4. Lambdas sin valor de retorno</a></span></li><li><span><a href=\"#5.-Clausuras\" data-toc-modified-id=\"5.-Clausuras-1.5\">5. Clausuras</a></span></li><li><span><a href=\"#6.-Lambdas-y-Colecciones\" data-toc-modified-id=\"6.-Lambdas-y-Colecciones-1.6\">6. Lambdas y Colecciones</a></span><ul class=\"toc-item\"><li><span><a href=\"#forEach\" data-toc-modified-id=\"forEach-1.6.1\">forEach</a></span></li><li><span><a href=\"#filter()\" data-toc-modified-id=\"filter()-1.6.2\">filter()</a></span></li><li><span><a href=\"#map()\" data-toc-modified-id=\"map()-1.6.3\">map()</a></span></li><li><span><a href=\"#fold()\" data-toc-modified-id=\"fold()-1.6.4\">fold()</a></span></li><li><span><a href=\"#reduce()\" data-toc-modified-id=\"reduce()-1.6.5\">reduce()</a></span></li><li><span><a href=\"#Encadenado-de-funciones\" data-toc-modified-id=\"Encadenado-de-funciones-1.6.6\">Encadenado de funciones</a></span></li></ul></li><li><span><a href=\"#7.-Ejercicios\" data-toc-modified-id=\"7.-Ejercicios-1.7\">7. Ejercicios</a></span><ul class=\"toc-item\"><li><span><a href=\"#Soluciones\" data-toc-modified-id=\"Soluciones-1.7.1\">Soluciones</a></span></li></ul></li></ul></li></ul></div>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ad869821",
   "metadata": {},
   "source": [
    "# K09. Lambdas básico\n",
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "417b0721",
   "metadata": {},
   "source": [
    "## 1. Introdución\n",
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cb814157",
   "metadata": {},
   "source": [
    "Las funciones **lambda** también se conocen como **funciones anónimas**. Su nombre proviene del [cálculo lambda](https://es.wikipedia.org/wiki/C%C3%A1lculo_lambda), introducido por **Alonzo Church** y **Stephen Kleene** en la década de 1930, en un intento de crear un sistema formal de definición de funciones computables.\n",
    "\n",
    "<br>En algunos lenguajes, las funciones lambda son sinónimos también de las [**clausuras**](https://es.wikipedia.org/wiki/Clausura_(inform%C3%A1tica)), cuyo nombre provienen de su capacidad de \"enclaustrar\" las variables del mismo ámbito en el que se definió la función. Es decir, una función lambda puede acceder y manipular cualquier variable del contexto circundante, actuando como una función anidada dentro de otra."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "acbf8794",
   "metadata": {},
   "source": [
    "## 2. Definición de Lambdas\n",
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "909fdebd",
   "metadata": {},
   "source": [
    "<br>Dado que las lambdas no tienen nombre, ¿cómo las definimos e invocamos? \n",
    "\n",
    "<br>Para poder usar una lambda, lo primero que tenemos que hacer es asignarla a una variable o constante, cuyo tipo será el correspondiente a la firma (_signature_) de la función lambda. Es lo que llamamos **tipo de función**, como por ejemplo ```(Int) -> String``` que representa el fipo de una función con un parámetro de tipo ```Int``` y un valor de retorno de tipo  ```String```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "379fc64b",
   "metadata": {},
   "outputs": [],
   "source": [
    "val multLambda: (Int, Int) -> Int = { a, b ->\n",
    "    a * b\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "63efc398",
   "metadata": {},
   "source": [
    "En el ejemplo anterior, creamos una variable (```multLambda```) con el tipo función: ```(Int, Int) -> Int```. Es decir, dicha variable podrá referenciar una función que reciba dos argumentos de tipo entero y devuelva un valor entero.\n",
    "\n",
    "<br>A continuación, le asignamos (=) un valor, como a cualquier otra variable o constante. La diferencia es que, en este caso, el valor será el **cuerpo de una función**. En dicha función declaramos los parámetros **a** y **b**, que serán los receptores de los argumentos, y tras el **->** añadiremos las sentencias del cuerpo de la función. El valor devuelto por la expresión de la última línea del cuerpo, será el valor devuelto por la función.\n",
    "\n",
    "<br>Ahora, podemos usar nuestra variable como si de una función se tratara (a diferencia de las funciones, las lambdas no permiten usar los nombres de los parámetros en el paso de argumentos. Es decir, no podemos hacer algo como: ```multLambda(a=2, b=3)```)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f014d4ae",
   "metadata": {},
   "outputs": [],
   "source": [
    "multLambda(2, 3)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "57a54171",
   "metadata": {},
   "source": [
    "Alternativamente, podríamos usar la siguiente sintaxis para declarar nuestra lambda anterior:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "508ccf1c",
   "metadata": {},
   "outputs": [],
   "source": [
    "val multLambdaInf = { a: Int, b: Int ->\n",
    "    a * b\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "01a5b66b",
   "metadata": {},
   "source": [
    "En este caso, añadimos el tipo a los parámetros de la función, por lo que el tipo de la constante ```(Int, Int) -> Int``` se obtiendrá por **inferencia**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a5193887",
   "metadata": {},
   "outputs": [],
   "source": [
    "multLambdaInf(3, 4)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4071f1f3",
   "metadata": {},
   "source": [
    "### Sintaxis simplificada"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "abe26b38",
   "metadata": {},
   "source": [
    "Comparadas con las funciones, las lambdas están diseñada para ser ligeras. Existen diversas maneras de simplificar su declaración. Como hemos visto, una de ellas es la inferencia de tipos. \n",
    "\n",
    "\n",
    "<br>Otra característica que ya hemos usado puntualmente es el empleo del **parámetro it**. Para una lambda que tenga **sólo un parámetro**, kotlin usa de forma implícita el término **```it```** para referirse al mismo"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "82335155",
   "metadata": {},
   "outputs": [],
   "source": [
    "// devuelve el cuadrado de un número\n",
    "val cuadrado: (Int) -> Int = { it * it }\n",
    "\n",
    "// devuelve el factorial de un número\n",
    "val factorial: (Int) -> Int = { \n",
    "    var fact = 1\n",
    "    for(i in 2..it) fact *= i \n",
    "    fact\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c84ef0ad",
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "val n = 5\n",
    "println(\"El cuadrado de $n es ${cuadrado(n)}\")\n",
    "println(\"El factorial de $n es ${factorial(n)}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ee9e2dc1",
   "metadata": {},
   "source": [
    "## 3. Lambdas como argumentos de funciones\n",
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3d790754",
   "metadata": {},
   "source": [
    "En kotlin las funciones son **_first-class_**, por lo que son tratadas como cualquier otra variable y pueden ser pasadas como argumento o devuleta como resultado de otra función. Lógicamente, esto también es aplicable a las lambdas.\n",
    "\n",
    "<br>A modo de ejemplo, definamos una fucnión donde uno de sus parámetros es de **tipo función**, es decir, espera recibir una función los los parámetros y retornos indicados:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "185cca08",
   "metadata": {},
   "outputs": [],
   "source": [
    "fun opera(a: Int, b: Int, operation: (Int, Int) -> Int): Int {\n",
    "    println(\"Realizando la operación...\")\n",
    "    val result = operation(a, b)\n",
    "    println(\"Operación finalizada\")\n",
    "    return result\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ed2e9c40",
   "metadata": {},
   "source": [
    "Podemos invocar la función anterior pasándole una lambda..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7328f48a",
   "metadata": {},
   "outputs": [],
   "source": [
    "// lambda\n",
    "val suma = { a: Int, b: Int -> a + b }\n",
    "\n",
    "opera(5, 3, suma)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8ee1ab85",
   "metadata": {},
   "source": [
    "No hay necesidad de definir previamente la lambda, asignarla a una variable local y, posteriormente, pasarla como argumento de la función. Simplemente, podemos decalararla en el momento de pasarla como argumento (declaración **_in-line_**) en la invocación de la función:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0630341b",
   "metadata": {},
   "outputs": [],
   "source": [
    "opera(3, 4, operation={ a, b -> a + b })"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "13e7d884",
   "metadata": {},
   "source": [
    "En el ejemplo anterior, los tipos de los parámetros de la lambda se infieren automáticamente de la declaración de la función a la que se va a pasar la lambda como argumento.\n",
    "\n",
    "<br>En ocasiones nos encontraremos con la siguiente sintáxis, donde la declaración de la lambda se saca fuera de los paréntesis (esto sólo se puede hacer si el parámetro de tipo función es el último de la lista de parámetros)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "80d7fcf9",
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "opera(3, 4) { a, b -> a + b }"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "de99c5dd",
   "metadata": {},
   "source": [
    "## 4. Lambdas sin valor de retorno\n",
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "dc6435a9",
   "metadata": {},
   "source": [
    "Las lambdas siempre devuelven el valor de la última expresión contenida en su cuerpo de función. En caso de no queramos que dicha lambda devuelva un valor, debemos indicarlo de forma explícita estableciendo **```Unit```** como valor de retorno en la declaración de la lambda"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "36f64441",
   "metadata": {},
   "outputs": [],
   "source": [
    "val lambdaSinRetorno: () -> Unit = {\n",
    "    println(\"No tengo parámetros y tampoco devuelvo nada\")\n",
    "}\n",
    "\n",
    "lambdaSinRetorno()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a64fd1a8",
   "metadata": {},
   "source": [
    "<br>En realidad, la función anterior sí que devuelve \"algo\" (Unit) aunque sin un significado o valor concreto que podamos usar. Como vimos en su momento, podemos definir funciones que no retornen nunca (por lo que nunca devolverán nada), en cuyo caso podemos establecer el tipo del retorno a **```Nothing```**. Una lambda de ese tipo puede ser como la siguiente, que lanza una excepción, con lo que se aborta la ejecución de la función:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b6b655ef",
   "metadata": {},
   "outputs": [],
   "source": [
    "val exitWithException: () -> Nothing = {\n",
    "    throw NullPointerException()\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "68833b56",
   "metadata": {},
   "source": [
    "## 5. Clausuras\n",
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "95006eb9",
   "metadata": {},
   "source": [
    "Una característica importante de las lambdas es que actúan como **clausuras**, pudiendo por tanto acceder a las variables y constantes de su propio ámbito. Recordemos que el ámbito define el rango en que una variable, constante,... puede ser accedida. Las lambdas **heredan** todas las entidades del ámbito en el que son definidas.\n",
    "\n",
    "<br>Por ejemplo:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "61f215f7",
   "metadata": {},
   "outputs": [],
   "source": [
    "var contador = 0\n",
    "val incrementaContador = { contador += 1 }"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e762c37b",
   "metadata": {},
   "source": [
    "A pesar de que la varaible ```contador``` está definida fuera de la lambda, como pertenece al ámbito en que fue declarada, podremos acceder a ella desde dentro de la misma. Es decir, ```contador``` no es una variable local a la lambda, si no que estamos accediendo a una variable externa al cuerpo de la misma como podemos ver al ejecutar el siguiente código"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9609ed1e",
   "metadata": {},
   "outputs": [],
   "source": [
    "incrementaContador()\n",
    "incrementaContador()\n",
    "incrementaContador()\n",
    "incrementaContador()\n",
    "incrementaContador()\n",
    "\n",
    "println(\"contador = $contador\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "697c61f6",
   "metadata": {},
   "source": [
    "EL hecho de que las lambdas puedan \"capturar\" variables fuera de su ámbito local, puede ser extremadamente útil. Por ejemplo, la siguietne función:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f77541a2",
   "metadata": {},
   "outputs": [],
   "source": [
    "fun creaContador(): () -> Int {\n",
    "    var cont = 0\n",
    "    val incrementaCont: () -> Int = {\n",
    "        cont += 1\n",
    "        cont\n",
    "    }\n",
    "    return incrementaCont    \n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7dcd7ebb",
   "metadata": {},
   "source": [
    "La función anterior no recibe argumentos y devuelve una lambda, la cual tampoco define parámetros y devuelve un valor entero (```() -> Int```). La lambda devuelta por esta función incrementará su contador interno cada vez que la invoquemos:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "229b648f",
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "// creamos dos contaadores independientes\n",
    "val counter1 = creaContador()\n",
    "val counter2 = creaContador()\n",
    "\n",
    "println(\"contador1 = ${counter1()}\")\n",
    "println(\"contador2 = ${counter2()}\")\n",
    "println(\"contador2 = ${counter2()}\")\n",
    "println(\"contador1 = ${counter1()}\")\n",
    "println(\"contador1 = ${counter1()}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "55fc0044",
   "metadata": {},
   "source": [
    "Aquí, es importante fijarse como en el momento de llamar a la función **```creaContador()```**, se ha creado una lambda asignada a la constante **```incrementaCont```** que ha **capturado** las variables y constantes del ámbito de la función, con los valores que tuvieran en ese momento. Así, aunque dicho ámbito se destruya al finalizar la función, o se cree un nuevo al invocarla de nuevo, la lambda generada tendrá una \"copia\" del estado en el momento que fue creada"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7b3847cf",
   "metadata": {},
   "source": [
    "## 6. Lambdas y Colecciones\n",
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8a0d6c33",
   "metadata": {},
   "source": [
    "Las funciones lambda se emplean con frecuencia para operar sobre fuentes o colecciones de datos. \n",
    "\n",
    "<br>Por ejemplo, en unidades anteriores vimos como ordenar una colección empleando el método **```sort()```**. \n",
    "\n",
    "<br>Alternativamente, las colecciones disponen de otro método, **```sortedWith()```** que recibe un objeto de tipo **```Comparator```** que permite establecer el criterio de comparación. Este objeto lo podemos crear mediante la función **```conpareBy()```**, la cual acepta un lambda que devuelve el criterio para evaluar el orden de los elementos de la colección.\n",
    "\n",
    "<br>En el siguiente ejemplo se ordena en función de la longitud de los nombres emplando dos comparadores diferentes. Uno define un lambda que devuelve la longitud del nombre y, el otro, la longitud en negativo, de forma que se invierta el orden"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9e71ebcf",
   "metadata": {},
   "outputs": [],
   "source": [
    "val names = arrayOf(\"Brian\", \"Paul\", \"Kevin\", \"Aaron\", \"Roy\", \"Russell\")\n",
    "\n",
    "val namesByLenAsc = names.sortedWith(compareBy { it.length })\n",
    "println(namesByLenAsc)\n",
    "\n",
    "val namesByLenDesc = names.sortedWith(compareBy { -it.length })\n",
    "println(namesByLenDesc)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "11d1b056",
   "metadata": {},
   "source": [
    "En Kotlin, las colecciones implementan diversas funcionalidades asociadas frecuentemente a la programación funcional. Estas funcionalidades están relacionadas con la aplicación de operaciones sobre la colección commo, por ejemplo, transformaciones o filtrado de ciertos elementos."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "622e319d",
   "metadata": {},
   "source": [
    "### forEach"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "85636cc4",
   "metadata": {},
   "source": [
    "La primera de tales funciones, **```forEach```**, nos permite iterar sosbre los elementos de la colección y poder extraerlos para realizar una determinada acción u operación:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "214282aa",
   "metadata": {},
   "outputs": [],
   "source": [
    "val values = (1..6).toList()\n",
    "values.forEach {\n",
    "    println(\"$it² = ${it * it}\")\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a90224b7",
   "metadata": {},
   "source": [
    "La función anterior itera sobre los elementos de la colección imprimiendo su valor y su cuadrado"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "faa499a3",
   "metadata": {},
   "source": [
    "### filter()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5cb602dc",
   "metadata": {},
   "source": [
    "La función anterior itera sobre los elementos de la colección imprimiendo su valor y su cuadrado\n",
    "\n",
    "<br>Otra función de uso muy habitual es **```filter()```**, la cual nos permite filtrar los elementos de la colección que cumplen un determinado requisito. Básicamente, se evalua la expresión indicada y se devuelven aquellos elementos que satisfacen dicha condición (= true)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "eba53309",
   "metadata": {},
   "outputs": [],
   "source": [
    "val prices = listOf(3.25, 7.0, 12.50, 2.25, 1.0, 9.92)\n",
    "val pricesOver5 = prices.filter { it > 5.0 }\n",
    "pricesOver5"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bb0ee2c5",
   "metadata": {},
   "source": [
    "Como vemos en el ejemplo anterior, obtendremos una nueva colección formada por aquellos elementos de la colección original que satisfacen la condición establecida"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "39cf779d",
   "metadata": {},
   "source": [
    "### map()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "40c111ee",
   "metadata": {},
   "source": [
    "En ocasiones, lo que nos interesa es realizar una operación de **transformación** de transformación sobre una colección. La función **```map()```** nos permite obtener una nueva colección a partir de la original tras realizar algún tipo de operación sobre cada uno de sus elementos."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9ba2f029",
   "metadata": {},
   "outputs": [],
   "source": [
    "val prices = listOf(3.25, 7.0, 12.50, 2.25, 1.0, 9.92)\n",
    "val discount = 0.15\n",
    "val pricesWithDiscount = prices.map { it * discount }\n",
    "pricesWithDiscount"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "42183fa4",
   "metadata": {},
   "source": [
    "Otra función útil de transformación es **```mapNotNull()```** que nos permite descartar los elementos nulos de la colección resultante"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6dce0f94",
   "metadata": {},
   "outputs": [],
   "source": [
    "val inputCommands = listOf(\"1\", \"3\", \"xxx\", \"1\", \"2\", \"blabla\")\n",
    "val validCommands = inputCommands.mapNotNull { it.toIntOrNull() }\n",
    "validCommands"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8d13b21b",
   "metadata": {},
   "source": [
    "### fold()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5c0bde70",
   "metadata": {},
   "source": [
    "La función **```fold()```** nos permite realizar operaciones de tipo acumulación sobre los elementos de una colección. Toma dos parámetros de entrada: un valor incial y un lambda. Dicho lambda, a su vez, define dos parámetros de entrada: el valor resultado de la última operación (parámetro valor inicial en el caso de la primera iteración) y el siguiente elemento de la colección.\n",
    "\n",
    "<br>El siguiente ejemplo muestra como podemos emplear esta función para sumar todos los elementos de una colección de forma fácil:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d9ab5932",
   "metadata": {},
   "outputs": [],
   "source": [
    "val values = listOf(3, 4, 1, 2, 5, 5, 1)\n",
    "val total = values.fold(0.0) { acc, it -> acc + it }\n",
    "total"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c66c5ef6",
   "metadata": {},
   "source": [
    "### reduce()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "22b80024",
   "metadata": {},
   "source": [
    "La función **```reduce()```** es similar a **```fold()```** con la única diferencia de que emplea el primer elemento de la colección como valor inicial"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "57f3d7b1",
   "metadata": {},
   "outputs": [],
   "source": [
    "val values = listOf(3, 4, 1, 2, 5, 5, 1)\n",
    "val total = values.reduce { acc, it -> acc + it }\n",
    "total"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cf9aea48",
   "metadata": {},
   "source": [
    "### Encadenado de funciones"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5ecaed7e",
   "metadata": {},
   "source": [
    "Dado que la salida de muchas de estas funciones es, a su vez, una nueva colección, podremos encadenar varias de estas operaciones"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c1512f2e",
   "metadata": {},
   "outputs": [],
   "source": [
    "val gastos = listOf(1.15, 1.15, 2.25, 3.0, 3.50, 1.15, 2.75, 5.25, 1.15, 2.0)\n",
    "val totalCafes = gastos.filter { it == 1.15 }.reduce { a, b -> a + b }\n",
    "totalCafes"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e91c260d",
   "metadata": {},
   "source": [
    "## 7. Ejercicios\n",
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "96a8a641",
   "metadata": {},
   "source": [
    "1. \n",
    "Crea una lista que contenga una serie de nombres. Emplea una de las funciones vistas para concatenar todos los nombres separaados por comas "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "797287d2",
   "metadata": {},
   "outputs": [],
   "source": [
    "// SOLUCIÓN\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "40339dd7",
   "metadata": {},
   "source": [
    "2. \n",
    "A partir de la misma lista de nombres anterior, extrae aquellos que tengan cinco o más caracteres y concaténalos de la misma manera que en el ejercicio previo"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a027173e",
   "metadata": {},
   "outputs": [],
   "source": [
    "// SOLUCIÓN\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4c72b658",
   "metadata": {},
   "source": [
    "3. \n",
    "Crea un mapa que asocie nombres con edades. Filtra los adultos (18 años o más)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6cc4f0a5",
   "metadata": {},
   "outputs": [],
   "source": [
    "// SOLUCIÓN\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "02c6baf6",
   "metadata": {},
   "source": [
    "4. \n",
    "Usando el mismo mapa anterior, filtra los adultos y devuelve una lista conteniendo sólo los nombres"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "65e4d2fa",
   "metadata": {},
   "outputs": [],
   "source": [
    "// SOLUCIÓN\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3c27844b",
   "metadata": {},
   "source": [
    "5. \n",
    "Crea una función denominada **repeatTask** que repetirá la ejecución de un lambda el número indicado de veces- Las funciones lambda aceptadas como argumento no tiene parámetros y no devuelven nada. Usando dicha función, imprime el mensaje \"Hello, Kotlin!\" 5 veces"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "29cd60d9",
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "// SOLUCIÓN\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5579f0d2",
   "metadata": {},
   "source": [
    "6. \n",
    "Crea un mapa a partir de las siguientes valoraciones de una serie de apps:\n",
    "\n",
    "<br>\n",
    "\n",
    "| App Name | Ratings |\n",
    "|---|---|\n",
    "| Calendar Pro | 1, 5, 5, 4, 2, 1, 5, 4 |\n",
    "| The Messenger | 5, 4, 2, 5, 4, 1, 1, 2 |\n",
    "| Socialise | 2, 1, 2, 2, 1, 2, 4, 2 |\n",
    "\n",
    "<br>A partir del mapa anterior, crea un nuevo mapa que asocie a cada app la media de sus valoraciones\n",
    "\n",
    "<br>Finalmente, obtén una lista de las apps con media de valoración superior a 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ebda7e3c",
   "metadata": {},
   "outputs": [],
   "source": [
    "// SOLUCIÓN\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "55768f02",
   "metadata": {},
   "source": [
    "7. \n",
    "Empleando las funciones de las colecciones, escribe un método denominado **hasOdd** que acepte un Set de enteros y devuelva true o false dependiendo de si el Set contiene algún número impar o no."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "760eaacb",
   "metadata": {},
   "outputs": [],
   "source": [
    "// SOLUCIÓN\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2f622358",
   "metadata": {},
   "outputs": [],
   "source": [
    "// TESTS\n",
    "// --> true\n",
    "println(hasOdd(setOf(2, 4, 6, 8, 7, 10)))\n",
    "\n",
    "// --> false\n",
    "println(hasOdd(setOf(2, -4, 6)))\n",
    "\n",
    "// --> false\n",
    "println(hasOdd(setOf()))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2ec297b3",
   "metadata": {},
   "source": [
    "8. \n",
    "Empleando las funciones de las colecciones, escribe un método denominado **maxLength** que acepte un Set de cadenas de caracteres y devuelva la longitud de la cadena más larga"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8d0e2326",
   "metadata": {},
   "outputs": [],
   "source": [
    "// SOLUCIÓN\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "16fc414b",
   "metadata": {},
   "outputs": [],
   "source": [
    "// TESTS\n",
    "// --> 25\n",
    "println(maxLength(setOf(\"one\", \"two\", \"three\", \"four\", \"get your person\", \"on the floor\", \"gotta gotta get up to get\", \"down\")))\n",
    "\n",
    "// --> 0\n",
    "println(maxLength(setOf()))\n",
    "\n",
    "// --> 10\n",
    "println(maxLength(setOf(\"tenletters\")))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fef62bf7",
   "metadata": {},
   "source": [
    "9. \n",
    "Empleando las funciones de las colecciones, escribe un método denominado **removeEvenLength** que acepte un Set de cadenas de caracteres y devuelva un Set sin las cadenas de longitud par"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a109704e",
   "metadata": {},
   "outputs": [],
   "source": [
    "// SOLUCIÓN\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e736ce99",
   "metadata": {},
   "outputs": [],
   "source": [
    "// TESTS\n",
    "// --> [foo, bar]\n",
    "val set1 = mutableSetOf(\"foo\", \"bar\")\n",
    "println(removeEvenLength(set1))\n",
    "\n",
    "// --> []\n",
    "val set2 = mutableSetOf<String>()\n",
    "println(removeEvenLength(set2))\n",
    "\n",
    "// --> [foo, bar, baz, qux, corge, waldo, plugh, xyzzy]\n",
    "val set3 = mutableSetOf<String>(\"foobar\", \"foo\", \"bar\", \"baz\", \"qux\", \"quux\", \"corge\", \"grault\", \"garply\", \"waldo\", \"fred\", \"plugh\", \"xyzzy\", \"thud\")\n",
    "println(removeEvenLength(set3))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2b223eaa",
   "metadata": {},
   "source": [
    "10. \n",
    "Empleando las funciones de las colecciones, escribe un método denominado **reverse** que acepte un mapa de enteros a cadenas de caracteres como parámetro y devuelva un nuevo mapa de cadenas de caracteres a enteros tal que invierta las claves y valores de las parejas. Es decir, los valores del primero pasan a ser la claves del nuevo, y las claves del primero, los valores del nuevo.\n",
    "\n",
    "\n",
    "Dado que los valores pueden no ser únicos, se acepta cualquier pareja formada con alguna de sus claves. Además, el orden es irrelevante\n",
    "\n",
    "\n",
    "Por ejemplo, dada la siguiente entrada: {42=Marty, 81=Sue, 17=Ed, 31=Dave, 56=Ed, 3=Marty, 29=Ed}\n",
    "el método podría devolver: {Marty=3, Sue=81, Ed=29, Dave=31}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c4ae95e1",
   "metadata": {},
   "outputs": [],
   "source": [
    "// SOLUCIÓN\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1b88231a",
   "metadata": {},
   "outputs": [],
   "source": [
    "// TESTS\n",
    "// {Sue=81, Marty=3, Dave=31, Ed=29}\n",
    "println(reverse(mapOf(42 to \"Marty\", 81 to \"Sue\", 17 to \"Ed\", 31 to \"Dave\", 56 to \"Ed\", 3 to \"Marty\", 29 to \"Ed\")))\n",
    "\n",
    "// {King=13, Queen=12, Jack=11, Ace=1}\n",
    "println(reverse(mapOf(13 to \"King\", 12 to \"Queen\", 11 to \"Jack\", 1 to \"Ace\")))\n",
    "\n",
    "// {Obama=13, McCain=0}\n",
    "println(reverse(mapOf(1 to \"Obama\", 25 to \"Obama\", 47 to \"Obama\", 13 to \"Obama\", 0 to \"McCain\")))\n",
    "\n",
    "// {}\n",
    "println(reverse(mapOf()))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e4f86a53",
   "metadata": {},
   "source": [
    "### Soluciones\n",
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "197051ea",
   "metadata": {},
   "source": [
    "##### 1.\n",
    "```kotlin\n",
    "val nombres = listOf(\"Brian\", \"Paul\", \"Kevin\", \"Aaron\", \"Roy\", \"Russell\")\n",
    "nombres.reduce { a, b -> a + \", \" + b }\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "355f5b54",
   "metadata": {},
   "source": [
    "##### 2. \n",
    "```kotlin\n",
    "nombres.filter { it.length >= 5 }.reduce { a, b -> a + \", \" + b }\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9a73a358",
   "metadata": {},
   "source": [
    "##### 3. \n",
    "```kotlin\n",
    "val namesAndAges = mapOf(\"Brian\" to 21, \"Paul\" to 32, \"Kevin\" to 15, \"Aaron\" to 16, \"Roy\" to 12, \"Russell\" to 29)\n",
    "namesAndAges.filter { it.value >= 18 }\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "11cf9a6f",
   "metadata": {},
   "source": [
    "##### 4. \n",
    "```kotlin\n",
    "namesAndAges.filter { it.value >= 18 }.map { it.key }\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f40d0498",
   "metadata": {},
   "source": [
    "##### 5.\n",
    "```kotlin\n",
    "fun repeatTask(times: Int, task: () -> Unit)  {\n",
    "    (1..times).forEach{ task() }\n",
    "}\n",
    "\n",
    "repeatTask(5) { println(\"Hello, Kotlin!\") }\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6631c542",
   "metadata": {},
   "source": [
    "##### 6.\n",
    "```kotlin\n",
    "val ratings = mapOf(\n",
    "    \"Calendar Pro\" to arrayOf(1, 5, 5, 4, 2, 1, 5, 4),\n",
    "    \"The Messenger\" to arrayOf(5, 4, 2, 5, 4, 1, 1, 2),\n",
    "    \"Socialise\" to arrayOf(2, 1, 2, 2, 1, 2, 4, 2)\n",
    "    )\n",
    "\n",
    "// mapa de valoración media\n",
    "val ratingsAvg = ratings.map { it.key to it.value.reduce { a, b -> a + b } / it.value.size.toDouble() }.toMap()\n",
    "\n",
    "// lista de apps con media superior a 3\n",
    "ratingsAvg.filter { it.value > 3 }\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "074bc45a",
   "metadata": {},
   "source": [
    "##### 7.\n",
    "```kotlin\n",
    "fun hasOdd(conjunto: Set<Int>) = conjunto.filter { it % 2 != 0 }.size > 0\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e9adfd86",
   "metadata": {},
   "source": [
    "##### 8. \n",
    "```kotlin\n",
    "fun maxLength(conjunto: Set<String>) = conjunto.sortedWith(compareBy { it.length }).lastOrNull()?.length?:0\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "91912022",
   "metadata": {},
   "source": [
    "##### 9.\n",
    "```kotlin\n",
    "fun removeEvenLength(conjunto: MutableSet<String>) = conjunto.filter { it.length % 2 != 0 }.toSet()\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d83e4bc5",
   "metadata": {},
   "source": [
    "##### 10.\n",
    "```kotlin\n",
    "fun reverse(map: Map<Int, String>) =  map.map { it.value to it.key }.toMap() \n",
    "```\n"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Kotlin",
   "language": "kotlin",
   "name": "kotlin"
  },
  "language_info": {
   "codemirror_mode": "text/x-kotlin",
   "file_extension": ".kt",
   "mimetype": "text/x-kotlin",
   "name": "kotlin",
   "nbconvert_exporter": "",
   "pygments_lexer": "kotlin",
   "version": "1.8.0-RC"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": false,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": true,
   "toc_position": {},
   "toc_section_display": true,
   "toc_window_display": false
  },
  "varInspector": {
   "cols": {
    "lenName": 16,
    "lenType": 16,
    "lenVar": 40
   },
   "kernels_config": {
    "python": {
     "delete_cmd_postfix": "",
     "delete_cmd_prefix": "del ",
     "library": "var_list.py",
     "varRefreshCmd": "print(var_dic_list())"
    },
    "r": {
     "delete_cmd_postfix": ") ",
     "delete_cmd_prefix": "rm(",
     "library": "var_list.r",
     "varRefreshCmd": "cat(var_dic_list()) "
    }
   },
   "types_to_exclude": [
    "module",
    "function",
    "builtin_function_or_method",
    "instance",
    "_Feature"
   ],
   "window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}