Diferencias

Muestra las diferencias entre dos versiones de la página.

--- introalg:taller08_4 [2008/05/11 00:35] – laura
+++ introalg:taller08_4 [2018/08/10 03:03] (actual) – editor externo 127.0.0.1
@@ Línea 75: / Línea 75: @@
   [False,False,False,False]
-=== Ejercicio ===
-  * Utilizando aplicación parcial en //( /= )//, definir la función //noEsCero :: Int -> Bool// que decide si un entero //x// es distinto a 0.
+===== Generalización de las funciones vistas (map, filter, fold) =====
-===== Generalización de las funciones vistas (map, filter, fold) =====
 ==== Aplicaciones (map) ====
@@ Línea 128: / Línea 124: @@
   rangoEdades (x:xs) = rangoEdad x : rangoEdades xs
-              :: [Int] -> [String]
+  ___________ :: [Int] -> [String]
-              []     = []
+  ___________ []     = []
-              (x:xs) =           x :             xs
+  ___________ (x:xs) = _________ x : ___________ xs
 Si queremos hacer esta expresión independiente de tipos, usaremos los comodines de tipo //a//, //b//, etc. en lugar de los tipos comunes //Int//, //String//, etc.
-              :: [a] -> [b]
+  ___________ :: [a] -> [b]
-              []     = []
+  ___________ []     = []
-              (x:xs) =           x :             xs
+  ___________ (x:xs) = _________ x : ___________ xs
 A esta base común hay que añadir un argumento más: la función que se aplicará a todos los elementos de la lista. En el ejemplo anterior, la función era //rangoEdad//, pero en el caso generalizado no la vamos a especificar en la función sino que vamos a pedir que nos venga dada como un argumento más cuando se llama a la función.
@@ Línea 156: / Línea 152: @@
   cuadrados = aplicar (^2)
   rangoEdades = aplicar rangoEdad
-=== Ejercicio ===
-  * Definir la función //mapNumeros.f.xs//, //mapNumeros : (Int -> Int) -> [Int] -> [Int]// que dada una función //f// y una lista de enteros //xs//, les aplica una función aritmética //f// y concatena el resultado en una lista. Ejemplo: //mapNumeros.(+2).[0,1,2,3] = [2,3,4,5]//.
-  probar con mapNumeros.(*2).[0,1,2,3], mapNumeros.absoluto.[-10,0,10].
@@ Línea 226: / Línea 212: @@
 Observemos que en el caso de los filtros, los elementos de la lista resultado tienen que ser del mismo tipo que los elementos de la lista que damos como argumento (//[a] -> [a]//), ya que la función filtro **no modifica** los elementos, sino que solamente determina si deben o no deben formar parte del resultado. En cambio, en las aplicaciones el resultado puede ser de distinto tipo que el argumento (//[a] -> [b]//), porque la aplicación sí puede modificar los elementos de la lista de entrada, incluso cambiándolos de tipo. Notemos que //[a] -> [b]// significa que **podemos** encontrar tipos distintos (como en //rangoEdad//) pero esto no es obligatorio: podemos encontrar que //a// y //b// representen el mismo tipo (como en //duplicar//).
-=== Ejercicio ===
-  * Definir la función //filtraNumeros.p.xs//, //filtraNumeros : (Int -> Bool) -> [Int] -> [Int]// que dada un predicado //p// y una lista de enteros //xs// devuelve la lista que contiene sólo aquellos números de //xs// que devuelven //True// en la predicado //p//. Ejemplo: //filtraNumeros.entre0y9.[11,4,37,3,10] = [4,3]//. Un ejemplo con algunas implicaciones más: //filtraNumeros.(esDivisor.3).[1,2,3,4,5,6,7,8,9,10] = [3,6,9]//.
-  probar con filtraNumeros.entre0y9.[], filtraNumeros.entre0y9.[10,20,30].
@@ Línea 281: / Línea 257: @@
 Por lo tanto, la generalización de los acumuladores es la siguiente:
-  acumular :: (a -> b ->) -> b -> [a] -> b
+  acumular :: (a -> b -> b) -> b -> [a] -> b
   acumular f n []     = n
   acumular f n (x:xs) =  f x (acumular f n xs)
@@ Línea 298: / Línea 274: @@
-=== Ejercicio ===
+===== Ejercicios =====
-Definir la primera generalización.
-  * Definir la función //paraTodoInt.p.xs//, //paraTodoInt : (Int->Bool) -> [Int] -> Bool//, que dado un predicado //p// retorna verdadero si y solo si, el predicado es válido para todos los elementos de la lista. Ejemplo //paraTodoInt.multiplo2.[2,4,6] = True//.
-  probar con paraTodoInt.multiplo2.[2,3,4], paraTodoInt.entre0y9.[1,2,4,2,1], paraTodoInt.multiplo2.[].
-Y luego esta que es casi completa.
-  * Definir la función //acumulaInt.f.z.xs//, //acumulaInt : (Int->Int->Int) -> Int -> [Int] -> Int//, que dado un operador //f//, un elemento //z// neutro del operador y una lista //xs//, retorna la acumulación del operador con //z// (cero) y con cada uno de los elementos de la lista. Ejemplo: //acumulaInt.max.0.[1,9,3,7,0] = 9//.
-  probar con acumulaInt.(+).0.[1,2,3], acumulaInt.(*).1.[1,2,3].
-===== Reescribiendo funciones usando map, fold y filter =====
-==== Ejercicios ====
   * Escribir //duplicar// y //multiplicar// con //aplicar//.
     * Reescribir ambas utilizando aplicación parcial sobre //mapa// para evitar escribir el argumento de la lista.
-  * Utilizando //aplicar// escribir la función //largos :: [String] -> [Int]// que dada una lista de cadenas, retorna la lista con la longitud de cada una.
+  * Utilizando //aplicar// escribir la función //largos :: [String] -> [Int]// que dada una lista de strings, retorna la lista con la longitud de cada una. //Ayuda: recordar que los strings son listas de caracteres.//
   * Escribir //soloPares// y //quitar0s// con //filtrar//.
     * Reescribir ambas utilizando aplicación parcial sobre //aplicar// para evitar escribir el argumento de la lista.
@@ Línea 329: / Línea 287: @@
   * Escribir //reversa// usando //acumular//.
   * **(DIFÍCIL)** Escribir //aplicar// y //filtrar// usando //acumular//.
+  * Definir la función //cuantosCumplen//, //cuantosCumplen :: (Int -> Bool) -> [Int] -> Int//, que dado un predicado //p// y una lista de enteros //xs//, cuenta cuántos elementos de la lista cumplen con //p//.
+  * Definir la función //sumaPares//, //sumaPares :: [Int] -> Int//, que suma sólo los elementos pares de una lista.
+  * Definir la función //estudiantesMayores35//, //estudiantesMayores35 :: [(String,Int,Int,Int)] -> Int//, que dada una lista de cuatro-uplas //(String,Int,Int,Int)// que se corresponden con //(Nombre,Año-Nacimiento,Año-Inicio-Estudios,Año-Fin-Estudios)//, devuelve la cantidad de estudiantes que fueron mayores de 35 años en algún momento en el transcurso de sus estudios.
+  * Definir la función //listaMayorQue//, //listaMayorQue :: Int -> [ [ a ] ] -> Bool//, que dado un número //n// y una lista de listas, devuelve True si todas las listas de la lista tienen por lo menos //n// elementos.
+  * Definir la función //totalSueldos//, //totalSueldos :: [Int] -> Int//, que dada una lista con el monto de cada uno de los sueldos que paga una empresa, aplica una suba del 5% a todos los sueldos y devuelve el monto total que gastará la empresa en sueldos.
+  * Definir la función //impuestoLujo//, //impuestoLujo :: [(String,Int)] -> [(String,Int)]//, que dada una lista de tuplas //(Producto, Precio)//, aplica un impuesto del 21% extra a todos los productos que salen más de 10000 pesos.
+  * Definir la función //cuentaInteresantes//, //cuentaInteresantes :: [(String,Bool)] -> Int//, que cuenta la cantidad de libros interesant es que hay en una biblioteca. Los libros están representados mediante una tupla //(String, Bool)//, que contiene el título del libro en el primer elemento y en el segundo el elemento contiene True si el libro es interesante y False si no lo es.
+  * Definir la función //edadPromedio//, //edadPromedio:: [(String,Int)] -> Int//, que dada una lista de pares //(nombre,edad)//, retorna el promedio de edad de las personas.