Está en la página 1de 12

1

-- 1.- FUNCIN RESTO. resto :: Int -> Int -> Int resto x y |x<y = x |otherwise = resto (x-y) y -- 2.- FUNCIN COCIENTE. cociente :: Int -> Int -> Int cociente x y |x<y = 0 |otherwise = 1 + cociente (x-y) y -- 3.- FUNCIN MCD. mcd :: Int -> Int -> Int mcd x y |x==y = x |x<y = mcd x (y-x) |otherwise = mcd (x-y) y -- 4.- FUNCIN FACTORIAL. fact :: Int -> Int fact 0 = 1 fact (n+1) = (n+1) * fact n -- 5.- VARIACIONES DE n ELEMENTOS TOMADOS DE r EN r. var :: Int -> Int -> Int var n 1 = n var n r = n * var (n-1) (r-1) -- 6.- COMBINACIONES DE n ELEMENTOS TOMADOS DE r EN r. comb :: Int -> Int -> Int comb n 1 = 1 comb n r |n==r = 1 |otherwise = comb (n-1) (r-1) + comb (n-1) r -- 7.- FUNCIN QUE ADJUNTA UN DGITO A LA DERECHA DE UN ENTERO. adj :: Int -> Int -> Int adj x y = (x * 10) + y -- 8.- SEPARACIN DEL LTIMO DGITO DE UN NMERO. sep :: Int -> (Int,Int) sep x |x<10 = (0,x) |otherwise = (x/10,rem x 10) -- 9.- CONCATENACIN DE DOS NMEROS ENTEROS IGNORANDO EL CERO. enlaza :: Int -> Int -> Int enlaza x 0 = x enlaza x y = adj (enlaza x u) v where (u,v) = sep y -- 10.- BINARIO a DECIMAL y VICEVERSA. binario :: Int -> Int binario 0 = 0 binario 1 = 1 binario n = adj u v where v = rem n 2 u = binario (n/2) decimal :: Int -> Int decimal n = dec n 0 where dec :: Int -> Int -> Int dec 0 _ = 0 dec 1 i = 1*2^i dec n i = x + y

2
where (x,y) = (dec u (i+1) , v*2^i) where (u,v) = sep n -- 11.- CAMBIO DE A UNA BASE<10. cambioAbase :: Int -> Int -> Int cambioAbase b n |n<b = n |otherwise = adj u v where (u,v) = (cambioAbase b (n/b), rem n b) -- 12.- FUNCIN QUE PASE DE DGITO a CARACTER Y VICEVERSA. valorCar :: Int -> Char valorCar n |n<10 = chr (n+48) |otherwise = error "Fuera de rango." valorNum :: Char -> Int valorNum x = (ord x)-48 -- 13.- PASO DE UN CARACTER A MAYSCULA Y A MINSCULA. may :: Char -> Char may x |(ord x)<97 = x |(ord x)>122 = x |otherwise = chr ((ord x)-32) minus :: Char -> Char minus x |(ord x)<65 = x |(ord x)>90 = x |otherwise = chr ((ord x)+32) -- 14.- PASO DE PALABRAS A MAYSCULAS Y A MINSCULAS. mayuscula :: [Char] -> [Char] mayuscula [] = [] mayuscula (x:xs) = (may x: mayuscula xs) minuscula :: [Char] -> [Char] minuscula [] = [] minuscula (x:xs) = (minus x: minuscula xs) -- 15.- PRECEDENCIA LEXICOGRAFICA. precede :: [Char] -> [Char] -> Bool precede cadena1 cadena2 = precede2 (mayuscula cadena1) (mayuscula cadena2) where precede2 :: [Char] -> [Char] -> Bool precede2 ys [] = False precede2 [] ys = True precede2 (x:xs) (y:ys) | (ord x) > (ord y) = False | (ord x) < (ord y) = True | otherwise = precede2 xs ys -- 16.- FUNCION QUE DEVUELVE LA POSICIN DE UN CARACTER DADO EN UNA CADENA Y OTRA QUE -DEVUELVA EL CARACTER QUE EST EN UNA POSICIN DADA DE UNA CADENA. carPos :: Int -> [Char] -> Char carPos 0 (x:xs) = x carPos _ [] = error "Posicion no valida" carPos (n+1) (x:xs) = carPos n xs

3
posCar :: Char -> [Char] -> Int posCar x [] = error "El caracter no esta en la cadena" posCar x (y:ys) |x==y = 0 |otherwise = 1 + posCar x ys -- 17.- FUNCIN QUE DEVUELVE LA POSICIN DE LA PRIMERA APARICIN DEL CARACTER DE UNA CADENA EN LA OTRA. posSubCad :: [Char] -> [Char] -> Int posSubCad [] _ = error "No hay coincidencias" posSubCad (x:xs) ys | esta x ys = posCar x ys | otherwise = posSubCad xs ys esta x [] = False esta x (y:ys) | x==y = True | otherwise = esta x ys -- 18.- FUNCIN QUE AADE UN CARACTER A LA DERECHA DE UNA CADENA. adjCar :: Char -> [Char] -> [Char] adjCar x xs = xs ++ [x] -- 19.- FUNCIN INVERSA PARA INVERTIR CADENAS DE CARACTERES. inversa :: [Char] -> [Char] inversa [] = [] inversa (x:xs) = (inversa xs) ++ [x] -- 20.- FUNCIN CAPICUA QUE DETERMINE SI UNA CADENA ES SIMETRICA. capicua :: [Char] -> Bool capicua xs = inversa xs == xs -- 21.- FUNCIN PARA PERMUTAR LOS ELEMENTOS DE UNA CADENA SEGN LA DISPOSICIN DE LOS ELEMENTOS DE OTRAS DOS. -- EJEMPLO: permutada "AMOR" "abcd" "dabc" = "RAMO" permutada :: [Char] -> [Char] -> [Char] -> [Char] permutada _ _ [] = [] permutada xs ys (z:zs) = (u:us) where u = carPos (posCar z ys) xs us = permutada xs ys zs -- 22.- CLCULO DEL n-simo trmino de la sucesin de Fibonacci. fib :: Int -> Int fib 0 = 1 fib 1 = 1 fib (n+2) = fib (n+1) + fib n -- 23.- CLCULO DE LA RAIZ CUADRADA DE UN NMERO REAL r APLICANDO EL ALGORITMO DE NEWTON-RAPHSON. raiz :: Float -> Float raiz r = raiz2 r 0 raiz2 :: Float -> Int -> Float raiz2 r i | ((suc r i) - (suc r (i+1))) == 0.0 = suc r i | otherwise = raiz2 r (i+1) suc r 0 = r/2.0 suc r (i+1) = (1.0/2.0) * ( anterior + (r / anterior ) )

4
where anterior = suc r i -- 24.- TIPO DE DATOS TEMPERATURA Y FUNCIN PARA EL PASO DE GRADOS CEL. A FAH. Y VICEVERSA. data Temperatura = C Float | F Float conversion :: Temperatura -> Temperatura conversion (F x) = C (((x-32.0) * 5.0) / 9.0) conversion (C x) = F ((5.0*x)/9.0 + 32.0)

-- 25.- TIPO DE DATOS RACIONAL CON REPRESENTACION BINOMICA (numerador, denominador). FUNCION raNormal -- QUE SIMPLIFIQUE LA REPRESENTACIN DE UN RACIONAL. OPERACIONES: SUMA,RESTA,PRODUCTO Y DIVISION -CON OPERADORES INFIJO Y CUYO RESULTADO ESTE SIMPLIFICADO POR LA FUNCION raNormal. type Racional = (Int,Int) raNormal :: Racional -> Racional raNormal (num,den) = (a,b) where a = num / mcd num den b = den / mcd num den mcd :: Int -> Int -> Int mcd x y |x==y = x |x<y = mcd x (y-x) |otherwise = mcd (x-y) y (num1,den1) +: (num2,den2) = raNormal (a,b) where a = (num1 * den2) + (num2 * den1) b = den1 * den2 (num1,den1) -: (num2,den2) = raNormal (a,b) where a = (num1 * den2) - (num2 * den1) b = den1 * den2 (num1,den1) *: (num2,den2) = raNormal (a,b) where a = (num1 * num2) b = (den1 * den2) (num1,den1) /: (num2,den2) = raNormal (a,b) where a = (num1 * den2) b = (den1 * num2)

-- 26.- TIPO DE DATOS REAL CON REPRESENTACION (MANTISA, EXPONENTE) Y UNA FUNCION rNormal QUE LOS SIMPLIFIQUE -AJUSTANDOSE A LA SIGUIENTE RESTRICCION: 3276 =< m =< 32768 type Real = (Float,Int) rNormal :: Real -> Real rNormal (m,e) | m<3276.0 = rNormal (m*10.0,e-1) | m>32760.0 = rNormal (m/10.0,e+1) | otherwise = (m,e) (m1,e1) +*: (m2,e2) = rNormal (suma (m1,e1) (m2,e2))

5
suma :: Real -> Real -> Real suma (m1,e1) (m2,e2) | e1>e2 = suma (m1*10.0,e1-1) (m2,e2) | e1<e2 = suma (m1,e1) (m2*10.0,e2+1) | otherwise = (m1+m2,e1) (m1,e1) -*: (m2,e2) = rNormal (resta (m1,e1) (m2,e2)) resta :: Real -> Real -> Real resta (m1,e1) (m2,e2) | e1>e2 = resta (m1*10.0,e1-1) (m2,e2) | e1<e2 = resta (m1,e1) (m2*10.0,e2+1) | otherwise = (m1-m2,e1) (m1,e1) **: (m2,e2) = rNormal (m1*m2,e1+e2) (m1,e1) /*: (m2,e2) = rNormal (m1/m2,e1-e2)

-- 27.- DEFINIR EL TIPO COMPLEJO CON REPRESENTACIONES POLAR Y BINOMICA Y ESCRIBIR LAS OPERACIONES -CORRESPONDIENTES USANDO OPERADORES INFIJOS. data Complejo = Rect Float Float | Pol Float Float sumac :: Complejo -> Complejo -> Complejo sumac (Rect real1 imag1) (Rect real2 imag2) = Rect (real1+real2) (imag1+imag2) sumac (Pol mod1 arg1) (Pol mod2 arg2) = Pol (mod1+mod2) (arg1+arg2) restac :: Complejo -> Complejo -> Complejo restac (Rect real1 imag1) (Rect real2 imag2) = Rect (real1-real2) (imag1-imag2) restac (Pol mod1 arg1) (Pol mod2 arg2) = Pol (mod1-mod2) (arg1-arg2) productoc :: Complejo -> Complejo -> Complejo productoc (Rect real1 imag1) (Rect real2 imag2) = Rect ((real1*real2)-(imag1*imag2)) ((real1*imag2)+(imag1*real2)) productoc (Pol mod1 arg1) (Pol mod2 arg2) = Pol (mod1*mod2) (arg1-arg2) cocientec (Rect real1 imag1) (Rect real2 imag2) = Rect ((a*c+b*d)/(c*c+d*d)) ((b*c-a*d)/(c*c+d*d)) where a = real1 b = imag1 c = real2 d = imag2 cocientec (Pol mod1 arg1) (Pol mod2 arg2) = Pol (mod1/mod2) (arg1-arg2)

-- 28.- HACER INSTANCIAS DE LA CLASE NUM A LOS TIPOS RACIONAL, REAL Y COMPLEJO type Racional = (Int,Int) raNormal :: Racional -> Racional raNormal (num,den) = (a,b) where a = num / mcd num den b = den / mcd num den mcd :: Int -> Int -> Int mcd x y |x==y = x |x<y = mcd x (y-x) |otherwise = mcd (x-y) y instance Num Racional where (num1,den1) + (num2,den2) = raNormal (a,b) where a = (num1 * den2) + (num2 * den1) b = den1 * den2

6
(num1,den1) - (num2,den2) = raNormal (a,b) where a = (num1 * den2) - (num2 * den1) b = den1 * den2 (num1,den1) * (num2,den2) = raNormal (a,b) where a = (num1 * num2) b = (den1 * den2) (num1,den1) / (num2,den2) = raNormal (a,b) where a = (num1 * den2) b = (den1 * num2) type Real = (Float,Int) rNormal :: Real -> Real rNormal (m,e) | m<3276.0 = rNormal (m*10.0,e-1) | m>32760.0 = rNormal (m/10.0,e+1) | otherwise = (m,e) instance Num Real where (m1,e1) + (m2,e2) = rNormal (suma (m1,e1) (m2,e2)) where suma (m1,e1) (m2,e2) | e1>e2 = suma (m1*10.0,e1-1) (m2,e2) | e1<e2 = suma (m1,e1) (m2*10.0,e2+1) | otherwise = (m1+m2,e1) (m1,e1) - (m2,e2) = rNormal (resta (m1,e1) (m2,e2)) where resta (m1,e1) (m2,e2) | e1>e2 = resta (m1*10.0,e1-1) (m2,e2) | e1<e2 = resta (m1,e1) (m2*10.0,e2+1) | otherwise = (m1-m2,e1) (m1,e1) * (m2,e2) = rNormal (m1*m2,e1+e2) (m1,e1) / (m2,e2) = rNormal (m1/m2,e1-e2)

data Complejo = Rect Float Float | Pol Float Float instance Num Complejo where (Rect real1 imag1) + (Rect real2 imag2) = Rect (real1+real2) (imag1+imag2) (Pol mod1 arg1) + (Pol mod2 arg2) = Pol (mod1+mod2) (arg1+arg2) (Rect real1 imag1) - (Rect real2 imag2) = Rect (real1-real2) (imag1-imag2) (Pol mod1 arg1) - (Pol mod2 arg2) = Pol (mod1-mod2) (arg1-arg2) (Rect real1 imag1) * (Rect real2 imag2) = Rect ((real1*real2)-(imag1*imag2)) ((real1*imag2)+(imag1*real2)) (Pol mod1 arg1) * (Pol mod2 arg2) = Pol (mod1*mod2) (arg1-arg2) (Rect real1 imag1) / (Rect real2 imag2) = Rect ((a*c+b*d)/(c*c+d*d)) ((b*c-a*d)/(c*c+d*d)) where a = real1 b = imag1 c = real2 d = imag2 (Pol mod1 arg1) / (Pol mod2 arg2) = Pol (mod1/mod2) (arg1-arg2) -- 30.- LONGITUD, ENCADENADO, INVERSION, PALINDROMO Y LISTA ORDENADA TANTO CRECIENTE COMO DECRECIENTE -DE DOS SECUENCIAS DEL SIGUIENTE TIPO: data Seq a = Mo a | a :< Seq a

7
data Seq a = Mo a | a :< Seq a lonSeq :: Seq a -> Int lonSeq (Mo x) = 1 lonSeq (x :< xs) = 1 + lonSeq xs catSeq :: Seq a -> Seq a -> Seq a catSeq (Mo x) ys = x :< ys catSeq (x :< xs) ys = x :< (catSeq xs ys) revSeq :: Seq a -> Seq a revSeq (Mo x) = (Mo x) revSeq (x :< xs) = catSeq (revSeq xs) (Mo x) palSeq :: Seq a -> Seq a palSeq (Mo x) = (Mo x) palSeq xs = catSeq xs (revSeq xs) seqToList :: Seq a -> [a] seqToList (Mo x) = [x] seqToList (x :< xs) = x : seqToList xs seqInvList :: Seq a -> [a] seqInvList (Mo x) = [x] seqInvList (x :< xs) = seqInvList xs ++ [x]

-- 33.- DADO EL SIGUIENTE TIPO, ESCRIBIR UNA FUNCION QUE CALCULE EL VALOR DE CUALQUIERA DE ESTOS ARBOLES. data Exp = Num Int|Op Exp Char Exp valor :: Exp -> Int valor (Num x) = x valor (Op izq sig der) | sig=='+' = (valor izq) + (valor der) | sig=='-' = (valor izq) - (valor der) | sig=='*' = (valor izq) * (valor der) | sig=='/' = (valor izq) / (valor der) | otherwise = error "Error" -- 34.- DADO EL SIGUIENTE TIPO DE ARBOL, CALCULAR EL NUMERO DE HOJAS, NODOS, CAMINOS E IMAGEN ESPECTRAL. data Tree a = Leaf a | Node (Tree a) (Tree a) leaf :: Tree a -> Int leaf (Leaf x) = 1 leaf (Node izq der) = (leaf izq) + (leaf der) node :: Tree a -> Int node (Leaf x) = 0 node (Node izq der) = 1 + (node izq) + (node der) maxpath :: Tree a -> Int maxpath (Leaf _) = 0 maxpath (Node izq der) = 1 + max (maxpath izq) (maxpath der) minpath :: Tree a -> Int minpath (Leaf _) = 0 minpath (Node izq der) = 1 + min (minpath izq) (minpath der)

8
twist :: Tree a -> Tree a twist (Leaf x) = Leaf x twist (Node izq der) = Node (twist der) (twist izq)

-- 35.- DADO EL SIGUIENTE TIPO DE ARBOL, CALCULAR SI ESTA ORDENADO, SI ESTA EQUILIBRADO EN ALTURA, EN PESO, -- INSERTAR EN EL ARBOL ORDENADO Y ELIMINAR DEL MISMO. data Arbol a = V | Nodo (Arbol a) a (Arbol a) es_ord :: (Ord a) => Arbol a -> Bool es_ord V = True es_ord (Nodo V x V) = True es_ord (Nodo i x d) = (x >= (raiz i)) && (x <= (raiz d)) && (es_ord i) && (es_ord d) where raiz :: Arbol a -> a raiz (Nodo i x d) = x es_Heq :: Arbol a -> Bool es_Heq V = True es_Heq (Nodo i x d) = (camino_max(i) == camino_max(d)) && (es_Heq i) && (es_Heq d) where camino_max :: Arbol a -> Int camino_max V = 0 camino_max (Nodo i x d) = 1 + (max (camino_max i) (camino_max d)) insertar :: (Ord a) => a -> Arbol a -> Arbol a insertar elem V = Nodo V elem V insertar elem (Nodo i x d) | elem<x = Nodo (insertar elem i) x d | elem>x = Nodo i x (insertar elem d) |otherwise = error "No es posible repetir elementos" --NOTA: En los rboles binarios de bsqueda no se deben repetir los elementos. eliminar :: (Ord a) => a -> Arbol a -> Arbol a eliminar elem V = V eliminar elem (Nodo V x V) | elem==x = V | otherwise = Nodo V x V eliminar elem (Nodo i x d) | elem<x = Nodo (eliminar elem i) x d | elem>x = Nodo i x (eliminar elem d) |otherwise = (Nodo i (menor d) (eliminar (menor d) d)) menor :: (Ord a) => Arbol a -> a menor (Nodo V x _) = x menor (Nodo i x d) = menor i

-- 36.- ARBOLES N-ARIOS NO VACIOS: CALCULAR EL NUMERO DE HOJAS, DE NODOS Y CAMINOS MAXIMO Y MINIMO data ArbolG a = NodoG a [ArbolG a] leafG :: ArbolG a -> Int leafG (NodoG x []) = 1 leafG (NodoG x (y:ys)) = leafG y + leafG2 ys leafG2 [] = 0 leafG2 (y:ys) = (leafG y) + leafG2 ys nodeG :: ArbolG a -> Int nodeG (NodoG x []) = 0 nodeG (NodoG x (y:ys)) = nodeG y + nodeG2 ys nodeG2 [] = 1

9
nodeG2 (y:ys) = (nodeG y) + nodeG2 ys minpathG :: ArbolG a -> Int minpathG (NodoG x []) = 0 minpathG (NodoG x (y:ys)) = 1 + min (minpathG y) (minpathG (NodoG x ys)) maxpathG :: ArbolG a -> Int maxpathG (NodoG x []) = 0 maxpathG (NodoG x (y:ys)) = 1 + max (maxpathG y) (maxpathG (NodoG x ys)) -- 38.- FUNCION aplicaSeq PARA APLICAR UNA FUNCION A TODOS LOS ELEMENTOS DE UNA SECUENCIA (TIPO EJERCICIO 30) data (Seq a) = Mo a | a :< (Seq a) aplicaSeq :: (a -> b) -> (Seq a) -> (Seq b) aplicaSeq f (Mo x) = Mo (f x) aplicaSeq f (x :< xs) = (f x) :< (aplicaSeq f xs) -- 39.- DEFINIR UNA FUNCION filtrar Y UNA rechazar CONTRARIA A ESTA. filtrar :: (a -> Bool) -> [a] -> [a] filtrar p [] = [] filtrar p (x:xs) | p x = x: filtrar p xs | otherwise = filtrar p xs rechazar :: (a -> Bool) -> [a] -> [a] rechazar p [] = [] rechazar p (x:xs) | p x = rechazar p xs | otherwise = x: rechazar p xs -- 40.- DEFINIR UNA FUNCION QUE OPERE ENTRE LOS ELEMENTOS DE DOS LISTAS DOS A DOS. -EJEMPLO: parList (+) [3,4] [2,2,1] = [5,6] parList :: (a -> b -> c) -> [a] -> [b] -> [c] parList f [] _ = [] parList f _ [] = [] parList f (x:xs) (y:ys) = (f x y) : parList f xs ys

-- 41.- DEFINIR UNA FUNCION mapBtree PARA CONSTRUIR UN ARBOL DEL TIPO DEL EJERCICIO 35, CON LA MISMA FORMA -- QUE APARECE EN EL SEGUNDO ARGUMENTO, PERO CON LOS VALORES DEL TIPO a CAMBIADOS POR SUS TRANSFORMADOS -- POR LA FUNCION QUE APARECE COMO PRIMER ARGUMENTO. data (BTree a) = Vac | Nod (BTree a) a (BTree a) mapBtree :: (a -> b) -> (BTree a) -> (BTree b) mapBtree f Vac = Vac mapBtree f (Nod i x d) = Nod (mapBtree f i) (f x) (mapBtree f d) -IDEM A LA ANTERIOR PERO SOBRE ARBOLES DE HOJAS, EJERCICIO 34.

data (HTree a) = Leaf a | HNod (HTree a) (HTree a) mapLtree :: (a -> b) -> (HTree a) -> (HTree b) mapLtree f (Leaf x) = Leaf (f x) mapLtree f (HNod i d) = HNod (mapLtree f i) (mapLtree f d)

10
-- 42.- IDEM AL EJERCICIO 40 PERO OPERANDO SOBRE ARBOLES DE HOJAS. data (Arbol a) = Vacio | Nodo a (Arbol a) (Arbol a) parLtree :: (a -> b -> c) -> Arbol a -> Arbol b -> Arbol c parLtree f Vacio _ = Vacio parLtree f _ Vacio = Vacio parLtree f (Nodo x i d) (Nodo x2 i2 d2) = Nodo (f x x2) (parLtree f i i2) (parLtree f d d2) -- 43.- FUNCION compress QUE APLICADA A f Y A UNA LISTA [a1,a2,...,an) PRODUZCA f a1 (f a2 (...(f an-1 an)...)). compress :: (a -> a -> a) -> [a] -> a compress f [x] = x compress f [x,y] = (f x y) compress f (x:xs) = f x (compress f xs)

-FUNCION condense QUE APLICADA A f Y A g Y A UNA LISTA [a1,a2,...,an] PRODUZCA COMO RESULTADO EL VALOR -- f a1 (f a2 (... (f an-1 (g an))...)) condense :: (a -> b -> b) -> (a -> b) -> [a] -> b condense f g [x] = g x condense f g [x,y] = f x (g y) condense f g (x:xs) = f x (condense f g xs)

-- CONSTRUIR UNA FUNCION conSeq Y OTRA conTree QUE SE COMPORTE IGUAL QUE condense PERO CON LOS -- ELEMENTOS DE LOS TIPOS Seq a Y ArbolH a. data Seq a = Mo a | a :< Seq a data ArbolH a = H a | N (ArbolH a) (ArbolH a) conSeq :: (a -> b -> b) -> (a -> b) -> Seq a -> b conSeq f g (Mo x) = g x conSeq f g (x :< Mo y) = f x (g y) conSeq f g (x :< xs) = f x (conSeq f g xs)

conTree :: (a -> a -> a) -> (b -> a) -> ArbolH b -> a conTree f g (H a) = g a conTree f g (N (H x) (H y)) = f (g x) (g y) conTree f g (N i d) = f (conTree f g i) (conTree f g d) -- 44.- CON AYUDA DE LA FUNCION conSeq CONSTRUIR: -a) UNA FUNCION QUE TRANSFORME SECUENCIAS EN LISTAS. alista :: Seq a -> [a] alista (Mo x) = [x] alista (x:<xs) = conSeq (:) alista (x:<xs) -- 48.- DEFINIR UNA FUNCION listasuc QUE GENERE LA LISTA INFINITA DE LOS NUMEROS SIGUIENTES A UNO DADO. listasuc :: (Enum a) => a -> [a] listasuc n = [n..]

11
-- CON LA FUNCION ANTERIOR Y LA FUNCION filtrar CONSTRUIR UNA LISTA CON LOS 10 PRIMEROS MULTIPLOS DE 7. multiplos = take 10 [m |m <- listasuc 1, m `mod` 7 == 0] -- 49.- DEFINIR UNA FUNCION QUE CONSTRUYA UNA LISTA CON LOS 100 PRIMEROS NMEROS PRIMOS. primos :: [Int] primos = map head (iterate criba [2..]) where criba :: [Int] -> [Int] criba (p:xs) = [x | x <- xs, x `rem` p /= 0] -ESCRIBIR UNA EXPRESION PARA CALCULAR EL MENOR PRIMO MAYOR QUE 10000.

menor_primo :: [Int] menor_primo = take 1 [x | x <- primos, x > 10000] -- 50.- DEFINIR UNA FUNCION rep QUE GENERE LA LISTA INFINITA RESULTANTE DE LA APLICACIN SUCESIVA -DE UNA FUNCION DE UN ARGUMENTO A UN CIERTO VALOR, e.d. TAL QUE rep f x = [x, f x, f (f x), ... ]. rep :: (a -> a) -> a -> [a] rep f x = x: map f (rep f x) -CON AYUDA DE ESTA FUNCIN IMPLEMENTAR LAS LISTAS DE: LOS MULTIPLOS DE 5, LAS POTENCIAS DE 2, -LA LISTA [True, False, True, False, ...] Y LA LISTA ['*', '**', '***', '****', ...]. mul5 :: [Int] mul5 = rep (+5) 0 pot2 :: [Int] pot2 = rep (*2) 1 bool :: [Bool] bool = rep (not) True aster :: [String] aster = rep ('*':) "*" -- 51.- ESCRIBIR UNA FUNCION EFICIENTE PARA GENERAR LA LISTA INFINITA DE LOS NMEROS FACTORIALES. listfact :: [Int] listfact = map fact [1..] where fact :: Int -> Int fact 0 = 1 fact (n+1) = (n+1) * fact n

listfib :: [Int] listfib = 1: map fib [1..] where fib :: Int -> Int fib 0 = 1 fib 1 = 1 fib (n+2) = fib (n+1) + fib n -- 52.- ESCRIBIR UNA FUNCION QUE GENERE LA LISTA DE NUMEROS PERFECTOS (SON IGUAL A LA SUMA DE SUS DIVISORES).

12
listaperfec :: [Int] listaperfec = [x | x <- [2..], perfecto x] where perfecto n = sum(divisores n) == n where divisores n = [x | x <- [1..(n-1)], n `mod` x == 0] -- 53.- ESCRIBIR UNA FUNCION QUE CALCULE LA LISTA DE FACTORIALES TENIENDO EN CUENTA DE QUE ES IGUAL AL -- PRODUCTO DE LAS SIGUIENTES COLUMNAS: 1 2 3 4 5 6 7 ... -1 2 3 4 5 6 ... -1 2 3 4 5 ... listfact2 = fact0 where fact0 = 1: fact1 fact1 = zipWith (*) [1..] fact0

-- 54.- ESCRIBIR EXPRESIONES PARA GENERAR LAS LISTAS: [[1,4,9,...],[1,8,27,...],[1,16,81,...],...] -- Y [(1,1)],[(2,1),(1,2)],[(3,1),(2,2),(1,3)],...] lista1 = iterate f [1..] where f xs = zipWith (*) xs [1..]