Diferencias

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

--- introalg:rincon [2006/06/05 20:54] – 200.16.31.2
+++ introalg:rincon [2018/08/10 03:03] (actual) – editor externo 127.0.0.1
@@ Línea 92: / Línea 92: @@
 ===== Ejercicios capítulo 8 del Extracto del Cálculo de Programas =====
 ==== Soluciones de Ejercicio 8.7 (edad) ====
@@ Línea 128: / Línea 129: @@
                            | (m > m' || (m == m' && d > d')) = y' - y - 1
+(José Neder) Este es mas lindo a la vista:
+edad :: (Int, Int, Int) -> (Int, Int, Int) -> Int
+edad (x,y,z) (o,p,q)	| y<p||(y==p&&x<o) = q-z
+			| otherwise = q-z-1
 ==== Soluciones de Ejercicio 8.8 (área del prisma rectangular) ====
@@ Línea 238: / Línea 244: @@
           | (unmil x) == 7 || (centena x) == 7 || (decena x) == 7 || (unidad x) ==7  =  True
           | otherwise  = False
 ==== Ejercicio 7 ====
@@ Línea 267: / Línea 274: @@
 >> (PabloZ) Hay que validar la información y en caso que sea un valor no valido hay que darle al usuario un mensaje de error que pueda entender.
   cabeza :: [a] -> a
-  cabeza a | length a == 0 = error "La lista no puede estar vacia."
+  cabeza [] = error "La lista no puede estar vacia."
   cabeza (x:xs) = x
@@ Línea 388: / Línea 395: @@
   int2Float :: Int -> Float
-  int2Float n = fromInteger (toInteger n)
+  int2Float = fromIntegral
 Entonces, podemos usar, cada vez que necesitemos la longitud de una lista (pero como un Float):
@@ Línea 480: / Línea 487: @@
 José Neder
 ==== Ejercicio 16 ====
@@ Línea 500: / Línea 510: @@
 >>> De peluche, mejorale la "indentación" asi quedan bien encolumnadas las guardas y las definiciones
+  desdehasta :: Int -> Int -> [Int]
+  desdehasta a b |a<b = [a..b]
+                 |a==b = [a]
+                 |a>b = reversa [b..a]
+> Tambien lo hice yo desde esta forma. (PATRICK R.)
+  desde :: Int -> Int -> [Int]
+  desde x y
+	|x > y = x:desde (x-1) y
+	|x < y = x:desde (x+1) y
+	|otherwise = [y]
 ==== Ejercicio 17 ====
@@ Línea 554: / Línea 576: @@
       ceroOUno x = x==0 || x==1
 > no es necesario dividir en el caso base y el inductivo, esto ya lo hace ''paraTodo''.
+  listabin :: [Int] -> Bool
+  listabin [] = False
+  listabin [x] |x==1 || x==0 = True
+               |otherwise = False
+  listabin (x:xs) |(x==1 || x==0) && listabin xs = True
+                  |otherwise = False
  ======
@@ Línea 725: / Línea 754: @@
 Ahora tambien sabemos que si no tiene divisores hasta la raiz, es primo por lo que defini esta otra, un poco mas complicada, gracias a la funcion definida por "" y utilizando dos funciones de Haskell (//sqrt// y //round//):
-  int2Float :: Int -> Float
-  int2Float n = fromInteger (toInteger n)
   primo5 :: Int -> Bool
   primo5 1 = False
-  primo5 x = (filtro (multiplo x) (desdeHasta 1 (round (sqrt (int2Float x)))))==[1]
+  primo5 x = (filtro (multiplo x) (desdeHasta 1 (round (sqrt (fromIntegral x)))))==[1]
 -----
@@ Línea 760: / Línea 786: @@
   int2float :: Int -> Float
-  int2float n = fromInteger (toInteger n)
+  int2float = fromIntegral
   float2int :: Float -> Int
-  float2int n = fromInteger (toInteger (round n))
+  float2int = round
@@ Línea 1131: / Línea 1157: @@
 dosalan3 :: Float -> Float
 dosalan3 n = 2 //aca van 2 estellitas// n
@@ Línea 1243: / Línea 1271: @@
 De nuevo, tenemos **lo mejor de dos mundos**, claridad y velocidad, el ingrediente clave fue la utilización de definiciones locales que hacen que el cómputo del triángulo anterior y de la fila anterior solo se hagan 1 vez y se //comparta// en la fila
 superior.
-harian el favor de colocar en la compu con el proyector que da al pisarron, por fa agranden la letra que no se ve nada.
 >(José Neder)Utilizando la idea de definirlo con **definiciones locales** redefino la funcion asi:
-  p' :: [Int] -> [Int]
+  p3' :: [Int] -> [Int]
-  p' [x] = [x]
+  p3' [x] = [x]
-  p' (x:y:ys) = (x+y):p' (y:ys)
+  p3' (x:y:ys) = x+y:p3' (y:ys)
-  p :: [Int] -> [Int]
+  p3 :: [Int] -> [Int]
-  p (x:xs) = x:p' (x:xs)
+  p3 (x:xs) = x:p3'(x:xs)
-  tripascal4 :: Int -> [[Int]]
+  tripascal7 :: Int -> [[Int]]
-  tripascal4 n = foldl listpasn4 [] [0..n]
+  tripascal7 0 = [[1]]
-			where	listpasn4 :: [[Int]] -> Int -> [[Int]]
+  tripascal7 n = p3 x:(x:xs)
-				listpasn4 [] n = [[1]]
+			where	(x:xs) = tripascal7 (n-1)
-				listpasn4 (x:xs) n = p x:(x:xs)
-  Main> tripascal4 9
+  Practico8> tripascal7 9
   [[1,9,36,84,126,126,84,36,9,1],[1,8,28,56,70,56,28,8,1],[1,7,21,35,35,21,7,1],[1,6,15,20,15,6,1],[1,5,10,10,5,1],[1,4,6,4,1],[1,3,3,1],[1,2,1],[1,1],[1]]
-  (988 reductions, 1660 cells)
+  (807 reductions, 1444 cells)
+>(José Neder) aca la volvi a hacer de la manera que yo lo habia hecho y es un poquito mas rapida
+  foldnr :: (a -> a) -> a -> Int -> a
+  foldnr a x 0 = a x
+  foldnr a x n = a (foldnr a x (n-1))
+  p2' :: [Int] -> [Int]
+  p2' [x] = [x]
+  p2' (x:y:ys) = x+y:p2' (y:ys)
+  p2 :: [[Int]] -> [[Int]]
+  p2 [] = [[1]]
+  p2 ((x:xs):ys) = (x:p2' (x:xs)):(x:xs):ys
+  tripascal6 :: Int -> [[Int]]
+  tripascal6 n = foldnr p2 [] n
+  Practico8> tripascal6 9
+  [[1,9,36,84,126,126,84,36,9,1],[1,8,28,56,70,56,28,8,1],[1,7,21,35,35,21,7,1],[1,6,15,20,15,6,1],[1,5,10,10,5,1],[1,4,6,4,1],[1,3,3,1],[1,2,1],[1,1],[1]]
+  (788 reductions, 1434 cells)
 ===== Clase 4 =====
@@ Línea 1335: / Línea 1383: @@
 			where	buscparmin :: Ord b => [(a,b)] -> (a,b) -> [(a,b)]
 				buscparmin [] x = [x]
-				buscparmin ((a,b):xs) (c,d)	| d<=b = (c,d):((a,b):xs)
+				buscparmin ((a,b):xs) (c,d)	| d>=b = (c,d):((a,b):xs)
 								| otherwise = (a,b):buscparmin xs (c,d)
+he aqui una implementacion de lo aprendido pero sobre otro lenguaje en este caso c:
+FUNCIÓN FACTORIAL
+# include <stdio.h>
+long factorial(long);
+main()
+{
+  int i;
+ printf(“Digite un entero: “);
+ scanf(“%ld”, &n);
+ for(i = 1;i <= n; i ++)
+ printf(“%2d! = %ld\n”,i ,factorial(i));
+  return 0;
+}
+/* Definición recursiva de la función factorial*/
+long factorial(long number)
+{
+  if (number <= 1)
+       return 1;
+   else
+        return (number * factorial (number-1));
+}
+y disculpen por meterme hablando de otro tema, pero aquellos que creen saber programar en c seguramente ahora lo veran de otra forma