Relación 1 - Historial de revisiones

Albromgon: Alternativa a la función profundidad

2016-06-16T10:54:38Z

Alternativa a la función profundidad

Rosriomar en 12:46 28 feb 2016

2016-02-28T12:46:44Z

Rosriomar en 12:23 26 feb 2016

2016-02-26T12:23:03Z

Rosriomar en 12:16 26 feb 2016

2016-02-26T12:16:13Z

Anggonmar1 en 17:09 22 feb 2016

2016-02-22T17:09:26Z

Anggonmar1 en 17:08 22 feb 2016

2016-02-22T17:08:00Z

Mjoseh en 11:38 22 feb 2016

2016-02-22T11:38:45Z

Soccuacre en 19:34 21 feb 2016

2016-02-21T19:34:12Z

Elesalqui en 18:31 21 feb 2016

2016-02-21T18:31:25Z

Angruigon2: he hecho desde el 8.1 al 11

2016-02-20T09:40:49Z

he hecho desde el 8.1 al 11

@@ Línea 518: / Línea 518: @@
   | length (preorden i) > length (preorden d) = 1 + profundidad i
   | otherwise = 1 + profundidad d
 -- ---------------------------------------------------------------------

@@ Línea 483: / Línea 483: @@
 prop_length_preorden x =
   length (preorden x) == length (postorden x)
 -- La comprobación es

@@ Línea 171: / Línea 171: @@
 cuadradosR [] = []
 cuadradoR (x:xs) = [x^2] ++ cuadradosR xs
 -- ---------------------------------------------------------------------

@@ Línea 141: / Línea 141: @@
 perfectos :: Int -> [Int]
 perfectos n = [x|x<-[1..n], sum (factores x)== x]
 -- ---------------------------------------------------------------------

@@ Línea 57: / Línea 57: @@
 rota n xs | n < length xs = (drop n xs)++(take n xs)
            |otherwise = rota ( mod n (length xs)) xs
 -- ---------------------------------------------------------------------

@@ Línea 57: / Línea 57: @@
 rota n xs | n < length xs = (drop n xs)++(take n xs)
            |otherwise = rota ( mod n (length xs)) xs
 -- ---------------------------------------------------------------------
@@ Línea 110: / Línea 114: @@
 sumaDeCuadrados :: Integer -> Integer
 sumaDeCuadrados n = sum (map (^2) [1..n])
 -- ---------------------------------------------------------------------
@@ Línea 428: / Línea 436: @@
 nNodos :: Arbol a -> Int
-nNodos = undefined
+nNodos Hoja = 0
 -- ---------------------------------------------------------------------
@@ Línea 438: / Línea 447: @@
 -- La propiedad es
 prop_nNodos_espejo :: Arbol Int -> Bool
-prop_nNodos_espejo = undefined
+prop_nNodos_espejo x =
 -- La comprobación es
 -- ---------------------------------------------------------------------
@@ Línea 461: / Línea 473: @@
 -- La propiedad es
 prop_length_preorden :: Arbol Int -> Bool
-prop_length_preorden = undefined
+prop_length_preorden x =
 -- La comprobación es
 -- ---------------------------------------------------------------------
@@ Línea 487: / Línea 502: @@
 profundidad :: Arbol a -> Int
-profundidad = undefined
+profundidad Hoja = 0
 -- ---------------------------------------------------------------------
@@ Línea 497: / Línea 515: @@
 -- La propiedad es
 prop_nNodosProfundidad :: Arbol Int -> Bool
-prop_nNodosProfundidad = undefined
+prop_nNodosProfundidad x =
 -- La comprobación es
 -- ---------------------------------------------------------------------

← Revisión anterior		Revisión del 11:38 22 feb 2016
Línea 515:		Línea 515:
	where subarbol = arbol (div n 2)		where subarbol = arbol (div n 2)

−	</~~haskell~~>	+	</source>

@@ Línea 74: / Línea 74: @@
 -- ---------------------------------------------------------------------
--- Ejercicio 4.2. Definir la funciÃ³n xor_2 que calcule la disyunciÃ³n
+-- Ejercicio 4.2. Definir la función xor_2 que calcule la disyunción
 -- excluyente a partir de la tabla de verdad y patrones. Usar 2
 -- ecuaciones, una por cada valor del primer argumento.
@@ Línea 83: / Línea 83: @@
 xor_2 False q = q
 -- ---------------------------------------------------------------------
--- Ejercicio 4.3. Definir la funciÃ³n xor_3 que calcule la disyunciÃ³n
+-- Ejercicio 4.3. Definir la función xor_3 que calcule la disyunción
--- excluyente a partir de la disyunciÃ³n (||), conjunciÃ³n (&&) y negaciÃ³n
+-- excluyente a partir de la disyunción (||), conjunción (&&) y negación
--- (not). Usar 1 ecuaciÃ³n.
+-- (not). Usar 1 ecuación.
 -- ---------------------------------------------------------------------
@@ Línea 92: / Línea 92: @@
 -- ---------------------------------------------------------------------
--- Ejercicio 4.4. Definir la funciÃ³n xor_4 que calcule la disyunciÃ³n
+-- Ejercicio 4.4. Definir la función xor_4 que calcule la disyunción
--- excluyente a partir de desigualdad (/=). Usar 1 ecuaciÃ³n.
+-- excluyente a partir de desigualdad (/=). Usar 1 ecuación.
 -- ---------------------------------------------------------------------
@@ Línea 100: / Línea 100: @@
 -- ---------------------------------------------------------------------
--- Ejercicio 5. Definir, por comprensiÃ³n, la funciÃ³n
+-- Ejercicio 5. Definir, por comprensión, la función
 --    sumaDeCuadrados :: Integer -> Integer
 -- tal que (sumaDeCuadrados n) es la suma de los cuadrados de los
--- primeros n nÃºmeros; es decir, 1^2 + 2^2 + ... + 100^2. Por ejemplo,
+-- primeros n números; es decir, 1^2 + 2^2 + ... + 100^2. Por ejemplo,
 --    sumaDeCuadrados 3    ==  14
 --    sumaDeCuadrados 100  ==  338350
@@ Línea 125: / Línea 125: @@
 -- ---------------------------------------------------------------------
 -- Ejercicio 7. Un entero positivo es perfecto si es igual a la suma de
--- sus factores, excluyendo el propio nÃºmero. Usando una lista por
+-- sus factores, excluyendo el propio número. Usando una lista por
--- comprensiÃ³n y la funciÃ³n factores (del tema), definir la funciÃ³n
+-- comprensión y la función factores (del tema), definir la función
 --    perfectos :: Int -> [Int]
--- tal que (perfectos n) es la lista de todos los nÃºmeros perfectos
+-- tal que (perfectos n) es la lista de todos los números perfectos
 -- menores que n. Por ejemplo:
 --    *Main> perfectos 500
@@ Línea 232: / Línea 232: @@
 factoriales1 = 1:[factorial x|x<-[1..]]
 factorial x = product[1..x]
 -- Usando zipWith:
@@ Línea 243: / Línea 249: @@
 factoriales3 = 1: (aux 1 [1..])
      where aux n (x:xs) = (n*x):(aux (n*x) xs)
 -- Usando scanl1:
@@ Línea 254: / Línea 265: @@
 factoriales5 = map snd aux
          where aux = iterate aux2 (1,1) where aux2 (x,y) = (x+1,x*y)
 -- Comparación de los tiempos de evaluación:

@@ Línea 230: / Línea 230: @@
 factoriales1 :: [Integer]
-factoriales1 = undefined
+factoriales1 = 1:[factorial x|x<-[1..]]
 -- Usando zipWith:
 factoriales2 :: [Integer]
-factoriales2 = undefined
+factoriales2 = 1: zipWith (*) [1..] factoriales2
 -- Por recursión:
 factoriales3 :: [Integer]
-factoriales3 = undefined
+factoriales3 = 1: (aux 1 [1..])
 -- Usando scanl1:
 factoriales4 :: [Integer]
-factoriales4 = undefined
+factoriales4 = 1:scanl1 (*) [1..]
 -- Usando iterate:
 factoriales5 :: [Integer]
-factoriales5 = undefined
+factoriales5 = map snd aux
 -- Comparación de los tiempos de evaluación:
 -- ---------------------------------------------------------------------
@@ Línea 286: / Línea 295: @@
 espejo :: Arbol a -> Arbol a
-espejo = undefined
+espejo Hoja = Hoja
 -- ---------------------------------------------------------------------
@@ Línea 294: / Línea 304: @@
 prop_espejo :: Arbol Int -> Bool
-prop_espejo = undefined
+prop_espejo x = espejo (espejo x) == x
 -- ---------------------------------------------------------------------
@@ Línea 301: / Línea 311: @@
 -- ---------------------------------------------------------------------
 {-
- Demostración por inducción en x
+-- Demostración por inducción en x
+-- Caso base: El árbol es una Hoja. Por definición de espejo, espejo Hoja = Hoja, luego espejo (espejo Hoja) = Hoja.
 -}
@@ Línea 319: / Línea 334: @@
 preorden :: Arbol a -> [a]
-preorden = undefined
+preorden Hoja = []
 -- ---------------------------------------------------------------------
@@ Línea 335: / Línea 351: @@
 postorden :: Arbol a -> [a]
-postorden = undefined
+postorden Hoja = []
 -- ---------------------------------------------------------------------
@@ Línea 344: / Línea 361: @@
 -- La propiedad es
 prop_recorrido :: Arbol Int -> Bool
-prop_recorrido = undefined
+prop_recorrido x = postorden (espejo x) == reverse (preorden x)
 -- La comprobación es

@@ Línea 147: / Línea 147: @@
 cuadradosC :: [Integer] -> [Integer]
-cuadradosC = undefined
+cuadradosC xs= [y^2| y<-xs]
 -- ---------------------------------------------------------------------
@@ Línea 158: / Línea 158: @@
 cuadradosR :: [Integer] -> [Integer]
-cuadradosR = undefined
+cuadradosR [] = []
 -- ---------------------------------------------------------------------
@@ Línea 169: / Línea 170: @@
 imparesC :: [Integer] -> [Integer]
-imparesC = undefined
+imparesC xs = [x|x<-xs, odd x]
 -- ---------------------------------------------------------------------
 -- Ejercicio 9.2. Definir, por recursión, la función
@@ Línea 180: / Línea 180: @@
 imparesR :: [Integer] -> [Integer]
-imparesR = undefined
+imparesR []= []
 -- ---------------------------------------------------------------------
@@ Línea 192: / Línea 194: @@
 sumaConsecutivos :: [Int] -> [Int]
-sumaConsecutivos = undefined
+sumaConsecutivos xs = zipWith (+) xs (tail xs)
 -- ---------------------------------------------------------------------
@@ Línea 213: / Línea 215: @@
 distancia :: Eq a => [a] -> [a] -> Int
-distancia = undefined
+distancia [] _ = 0
 -- ---------------------------------------------------------------------