| Ambos lados, revisión anteriorRevisión previaPróxima revisión | Revisión previa |
| introalg:problemas07 [2007/05/10 13:47] – laura | introalg:problemas07 [2018/08/10 03:03] (actual) – editor externo 127.0.0.1 |
|---|
| Se pide: encontrar un predicado //pip.n//, //pip : Int -> Bool// que dado un número //0%%<=%%n<10000// devuelva diga cuando el jugador debe decir //pip//. \\ | Se pide: encontrar un predicado //pip.n//, //pip : Int -> Bool// que dado un número //0%%<=%%n<10000// devuelva diga cuando el jugador debe decir //pip//. \\ |
| Para hacerlo habrá que definir previamente las siguientes funciones: //unidad,decena,centena,unidadDeMil : Int -> Int//. | Para hacerlo habrá que definir previamente las siguientes funciones: //unidad,decena,centena,unidadDeMil : Int -> Int//. |
| | |
| | |
| |
| |
| |
| probar con [], [0], [0,0,0], [0,1], [0,1,0,1,0,1,0,1] | probar con [], [0], [0,0,0], [0,1], [0,1,0,1,0,1,0,1] |
| | |
| | * A partir de la [[http://es.wikipedia.org/wiki/Serie_de_Taylor | Serie de Taylor]] es posible aproximar la base de los logaritmos naturales o neperianos "[[http://es.wikipedia.org/wiki/N%C3%BAmero_e | e]]". \\ |
| | Definir la función //numeroE//, //numeroE : Integer -> Double//, donde //numeroE.n// retorna la sumatoria //1/0! + 1/1! + 1/2! + ... 1/n!//. Ejemplo: //numeroE.10 = 2.71828180114638//. \\ |
| | Probar como se pueden ir obteniendo todas los dígitos, comparar con el [[http://antwrp.gsfc.nasa.gov/htmltest/gifcity/e.1mil | primer millón de dígitos]]. |
| | |
| |
| ==== Generalizando los recursivos ==== | ==== Generalizando los recursivos ==== |
| probar con mapNumeroString.rangoPrecio.[1000,2000,3000,4000,5000,6000,7000] | probar con mapNumeroString.rangoPrecio.[1000,2000,3000,4000,5000,6000,7000] |
| |
| * Generalizar //mapNumero// y //mapNumeroString// con //map.f.xs//, //map : (a -> b) -> [a] -> [b]// que dada una función que lleva algo de tipo //a// a tipo //b// y una lista //xs// de cualquier tipo //a// devuelve una lista //b// con el resultado de aplicar la función //f// a cada elemento de //xs//. | * Generalizar //mapNumero// y //mapNumeroString// con //mapa.f.xs//, //mapa : (a -> b) -> [a] -> [b]// que dada una función que lleva algo de tipo //a// a tipo //b// y una lista //xs// de cualquier tipo //a// devuelve una lista //b// con el resultado de aplicar la función //f// a cada elemento de //xs//. |
| |
| probar con map.ordena.[(1,0)(0,1)], map.segundo3.[(10,20,30),(12,22,32),(14,24,34)], | probar con mapa.ordena.[(1,0)(0,1)], mapa.segundo3.[(10,20,30),(12,22,32),(14,24,34)], |
| map.longitud.[[],[1],[1,2]], map.(\x -> [x,x])."tartamuda". | mapa.longitud.[[],[1],[1,2]], mapa.(\x -> [x,x])."tartamuda". |
| |
| PREGUNTA: ¿Qué función del preámbulo de Haskell es un map genérico? | PREGUNTA: ¿Qué función del preámbulo de Haskell es un mapa genérico? |
| |
| |
| === Filtros (filter) === | === Filtros (filter) === |
| |
| * Definir la función //filtraNumeros.f.xs//, //filtraNumeros : (Int -> Bool) -> [Int] -> [Int]// que dada un predicado //f// y una lista de enteros //xs// devuelve la lista que contiene sólo aquellos números de //xs// que devuelven //True// en la función //f//. Ejemplo: //filtraNumeros.entre0y9.[11,4,37,3,10] = [4,3]//. Un ejemplo con algunas implicaciones más: //filtraNumeros.(esMultiplo.3).[1,2,3,4,5,6,7,8,9,10] = [3,6,9]//. | * Definir la función //filtraNumeros.p.xs//, //filtraNumeros : (Int -> Bool) -> [Int] -> [Int]// que dado 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 función //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]. | probar con filtraNumeros.entre0y9.[], filtraNumeros.entre0y9.[10,20,30]. |
| |
| * Generalice la función anterior para listas de cualquier tipo. Defina //filtro.f.xs//, //filtro : (a -> Bool) -> [a] -> [a]// que dado un predicado //f// y una lista //xs// de tipo //a//, devuelve una lista del mismo tipo que contiene sólo aquellos elementos de //xs// que son //True// en la función //f//. | * Generalice la función anterior para listas de cualquier tipo. Defina //filtro.f.xs//, //filtro : (a -> Bool) -> [a] -> [a]// que dado un predicado //f// y una lista //xs// de tipo //a//, devuelve una lista del mismo tipo que contiene sólo aquellos elementos de //xs// que son //True// en la función //f//. |
| probar con acumulaBool.(||).False.(map entre0y9 [10,20,30,2,40]). | probar con acumulaBool.(||).False.(map entre0y9 [10,20,30,2,40]). |
| |
| * Generalice la función anterior para operadores y listas de cualquier tipo. Definir //acumula.f.z.xs//, //acumula : (a->b->a) -> a -> [b] -> a//, que dado un operador binario //f// (asociativo a izquierda), un elemento //z// neutro (a izquierda) 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: //acumula.(++).[].["Hola", " ", "que", " ", "tal"] = "Hola que tal"//. | * Generalice la función anterior para operadores y listas de cualquier tipo. Definir //acumula.f.z.xs//, //acumula : (a->b->b) -> b -> [a] -> b//, que dado un operador binario //f// (asociativo a derecha), un elemento //z// neutro (a derecha) 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: //acumula.(++).[].["Hola", " ", "que", " ", "tal"] = "Hola que tal"//. |
| |
| probar con todos los ejemplos de las versiones menos generales. | probar con todos los ejemplos de las versiones menos generales. |
| |
| PREGUNTA: ¿Qué funciones del preámbulo de Haskell son los acumuladores genéricos? ¿Por qué hay 2? | PREGUNTA: ¿Qué funciones del preámbulo de Haskell son los acumuladores genéricos? ¿Por qué hay 2? |
| |
| |
| |
| |
| |
| |
| ==== Recursivos en dos argumentos ==== | ==== Recursivos en dos argumentos ==== |
| probar con [] [1,2,3], [1,2,3] [], [1,2,3] [4,5,6], [4,5,6] [1,2,3], | probar con [] [1,2,3], [1,2,3] [], [1,2,3] [4,5,6], [4,5,6] [1,2,3], |
| [0,1,2,5] [3,4], [1,2,3] [1,2,3], [] [], [3,4] [0,1,2,5]. | [0,1,2,5] [3,4], [1,2,3] [1,2,3], [] [], [3,4] [0,1,2,5]. |
| | |
| |
| ==== Para componer ==== | ==== Para componer ==== |
| |
| * Escribir una definición de //paraTodo// utilizando **//acumular//**. | * Escribir una definición de //paraTodo// utilizando **//acumular//**. |
| | |
| | * Escribir //factorial// utilizando //desdeHasta// y **//acumular//**. |
| |
| * Definir la función //insertaOrd : Int -> [Int] -> [Int]//, donde //insertaOrd.x.xs// inserta de manera ordenada el elemento //x// dentro de la lista //xs// que suponemos ordenada de menor a mayor. A partir de esta función definir //ordenaIns : [Int] -> [Int]// que ordena los elementos de una lista de menor a mayor. | * Definir la función //insertaOrd : Int -> [Int] -> [Int]//, donde //insertaOrd.x.xs// inserta de manera ordenada el elemento //x// dentro de la lista //xs// que suponemos ordenada de menor a mayor. A partir de esta función definir //ordenaIns : [Int] -> [Int]// que ordena los elementos de una lista de menor a mayor. |
| |
| Ejemplo: escalaImpuesto [("Perez",30), ("Gomez",67), ("Martinez",55), ("Rodriguez",24)] = [("Gomez",201),("Rodriguez",72)] | Ejemplo: escalaImpuesto [("Perez",30), ("Gomez",67), ("Martinez",55), ("Rodriguez",24)] = [("Gomez",201),("Rodriguez",72)] |
| | |
| |
| ==== Para lucirse ==== | ==== Para lucirse ==== |
| |
| * **Redefinir** la función escalaImpuesto: [(String,Int)] → [(String,Int)], que toma una lista de tuplas con el nombre de un usuario y su gasto mensual de electricidad, y devuelve una lista de tuplas con el nombre de aquellos usuarios que gastan más de **la media** de electricidad y su gasto multiplicado por la diferencia entre su gasto y el gasto medio. | * **Redefinir** la función escalaImpuesto: [(String,Int)] → [(String,Int)], que toma una lista de tuplas con el nombre de un usuario y su gasto mensual de electricidad, y devuelve una lista de tuplas con el nombre de aquellos usuarios que gastan más de **la media** de electricidad y su gasto multiplicado por la diferencia entre su gasto y el gasto medio. |
| | |
| | * La función //numeroE// puede ser extremadamente ineficiente para valores elevados de //n//, debido a que por cada sumando computa nuevamente el factorial. Generalizar la función de manera que tome un parámetro más y en ese se lleve el factorial que le corresponde a ese término. Comparar la eficiencia en término del tiempo. |
