Ciencias de la Computación FAMAF

Herramientas de usuario

Herramientas del sitio

Traza:
introalg:rincon

Diferencias

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

Enlace a la vista de comparación

introalg:rincon [2006/06/01 04:23] – 200.117.213.192introalg: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 ===== ===== Ejercicios capítulo 8 del Extracto del Cálculo de Programas =====
 +
  
 ==== Soluciones de Ejercicio 8.7 (edad) ==== ==== Soluciones de Ejercicio 8.7 (edad) ====
Línea 128: Línea 129:
                            | (m > m' || (m == m' && d > d')) = y' - y - 1                            | (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) ==== ==== 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           | (unmil x) == 7 || (centena x) == 7 || (decena x) == 7 || (unidad x) ==7  =  True
           | otherwise  = False           | otherwise  = False
 +
  
 ==== Ejercicio 7 ==== ==== 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. >> (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] -> 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   cabeza (x:xs) = x
  
Línea 388: Línea 395:
  
   int2Float :: Int -> Float   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):  Entonces, podemos usar, cada vez que necesitemos la longitud de una lista (pero como un Float): 
Línea 480: Línea 487:
  
 José Neder José Neder
 +
 +
 +
  
 ==== Ejercicio 16 ==== ==== Ejercicio 16 ====
Línea 499: Línea 509:
 >> Puede ser esa una solución?. (Pedro A.) >> Puede ser esa una solución?. (Pedro A.)
 >>> De peluche, mejorale la "indentación" asi quedan bien encolumnadas las guardas y las definiciones >>> 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 ==== ==== Ejercicio 17 ====
Línea 507: Línea 530:
  
 José Neder José Neder
-> (nwolovick) fijate que como [y]=y:[] el primer caso esta de mas, mmmhhh, pero ahora que lo miro lo hicistes para parchar un poco el caso base que es incorrecto, el caso base es ''True'' porque sabemos el teorema del //neutro de la conjunción//.+> (nwolovick) fijate que como [y]=y:[] el primer caso esta de mas, mmmhhh, pero ahora que lo miro lo hicistes para parchar un poco el caso base que es incorrecto, el caso base es ''True'' porque sabemos el teorema del //neutro de la conjunción//. (José Neder) desde mi punto de vista una lista vacia no esta compuesta solo de ceros o de unos, sino que podemos creer que no esta compuesta de nada o que esta compuesta de todo.
  
 Solucion mas elegante Solucion mas elegante
Línea 553: Línea 576:
       ceroOUno x = x==0 || x==1       ceroOUno x = x==0 || x==1
 > no es necesario dividir en el caso base y el inductivo, esto ya lo hace ''paraTodo''. > 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 670: Línea 700:
  
 Mati Tealdi... Mati Tealdi...
 +
  
  
Línea 723: 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//): 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 :: Int -> Bool
   primo5 1 = False   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 758: Línea 786:
  
   int2float :: Int -> Float   int2float :: Int -> Float
-  int2float n = fromInteger (toInteger n)+  int2float = fromIntegral
  
   float2int :: Float -> Int   float2int :: Float -> Int
-  float2int n = fromInteger (toInteger (round n))+  float2int = round
  
  
Línea 776: Línea 804:
 >(nwolovick) Propongo la siguiente optimización probar que no es multiplo de 2,3,5,7 ... sqrt(n-1), con lo que nos ahorramos todo los pares salvo el 2. Si ya no es multiplo de 2 pues no va ser de 4 ni de 6, etc. Ahi tenemos un 50% mas de velocidad. >(nwolovick) Propongo la siguiente optimización probar que no es multiplo de 2,3,5,7 ... sqrt(n-1), con lo que nos ahorramos todo los pares salvo el 2. Si ya no es multiplo de 2 pues no va ser de 4 ni de 6, etc. Ahi tenemos un 50% mas de velocidad.
  
->(José Neder) Aca esta la optimizacion que faltaba utilizando solo los primos hasta el cuadrado, casi, ya que se va hasta un poquito mas que el cuadrado a veces pero es mas rapido asi.+>(José Neder) Aca esta la optimizacion que faltaba utilizando solo los primos hasta el cuadrado.
  
   primoshasta3 :: Int -> [Int]   primoshasta3 :: Int -> [Int]
Línea 785: Línea 813:
  where primo7 :: [[Int]] -> Int -> [[Int]]  where primo7 :: [[Int]] -> Int -> [[Int]]
  primo7 [] n = [[n],[n]]  primo7 [] n = [[n],[n]]
- primo7 [xs,(y:ys)] n | todocump (multiplo n) (y:ys)==[] && y*y>n = [xs++[n],(y:ys)] + primo7 [xs,(y:ys)] n | todocump (multiplo n) ys==[] && y*y>n = [xs++[n],(y:ys)] 
- | y*y==n = [xs,(tomar (length (y:ys)) xs):(y:ys)]+ | y*y==n = [xs,tomar (length (y:ys)) xs:(y:ys)]
  | otherwise = [xs,(y:ys)]  | otherwise = [xs,(y:ys)]
  tomar :: Int -> [a] -> a  tomar :: Int -> [a] -> a
Línea 1129: Línea 1157:
 dosalan3 :: Float -> Float dosalan3 :: Float -> Float
 dosalan3 n = 2 //aca van 2 estellitas// n dosalan3 n = 2 //aca van 2 estellitas// n
 +
 +
 +
 +
  
  
Línea 1239: 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 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. 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: >(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]]   [[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 ===== 
 + 
 +>(José Neder) a frecuencia lo defini directamente con plegarI. 
 + 
 +  esta :: Eq a => a -> [a] -> Bool 
 +  esta a [] = False 
 +  esta a (x:xs) = x==a||esta a xs 
 + 
 +  frecuencia :: [Palabra] -> [(Palabra,Int)] 
 +  frecuencia xs = foldl contarpalabras [] xs 
 + where contarpalabras :: [(Palabra,Int)] -> Palabra -> [(Palabra,Int)] 
 + contarpalabras [] x = [(x,1)] 
 + contarpalabras ((a,b):xs) x | x==a = (a,b+1):xs 
 + | otherwise = (a,b):contarpalabras xs x 
 + 
 +>(José Neder) Para que identifique todos los caracteres que no son letras y no distinga entre mayusculas y minisculas, lo defino a partir de las letras: 
 + 
 +  letrasM :: String 
 +  letrasM = ['A'..'Z']++['À'..'Ö']++['Ù'..'Ý'] 
 + 
 +  letrasm :: String 
 +  letrasm = ['a'..'z']++['à'..'ö']++['ù'..'ý'] 
 + 
 +  numdea :: Eq a => a -> [a] -> Int 
 +  numdea a (x:xs) | a==x = 0 
 + | otherwise = 1+numdea a xs 
 + 
 +  tomarun :: Int -> [a] -> a 
 +  tomarun 0 (x:xs)=x 
 +  tomarun n (x:xs)=tomarun (n-1) xs 
 + 
 +  palabramin :: String -> String 
 +  palabramin []=[] 
 +  palabramin (x:xs) |esta x letrasM = tomarun (numdea x letrasM) letrasm:palabramin xs 
 + |otherwise = x:palabramin xs 
 + 
 +  tiraTodo :: String -> String 
 +  tiraTodo [] = [] 
 +  tiraTodo (x:xs) | esta x letrasm ||esta x letrasM = x:xs 
 + | otherwise = tiraTodo xs 
 + 
 +  tomaPalabra2 :: String -> String 
 +  tomaPalabra2 [] = [] 
 +  tomaPalabra2 (x:xs) | esta x letrasm ||esta x letrasM = x : tomaPalabra2 xs 
 + | otherwise      = [] 
 + 
 +  tiraPalabra2 :: String -> String 
 +  tiraPalabra2 [] = [] 
 +  tiraPalabra2 (x:xs) | esta x letrasm ||esta x letrasM = tiraPalabra2 xs 
 + | otherwise      = x:xs 
 + 
 +  partirPalabras2 :: String -> [Palabra] 
 +  partirPalabras2 st = partirPalabras2' (tiraTodo st) 
 + 
 +  partirPalabras2' :: String -> [Palabra] 
 +  partirPalabras2' [] = [] 
 +  partirPalabras2' st = (tomaPalabra2 st) : partirPalabras2' (tiraTodo (tiraPalabra2 st)) 
 + 
 +  frecuencia' :: [Palabra] -> [(Palabra,Int)] 
 +  frecuencia' xs = foldl contarpalabras [] xs 
 + where contarpalabras :: [(Palabra,Int)] -> Palabra -> [(Palabra,Int)] 
 + contarpalabras [] x = [(palabramin x,1)] 
 + contarpalabras ((a,b):xs) x | a==palabramin x = (a,b+1):xs 
 + | otherwise = (a,b):contarpalabras xs x 
 + 
 +  ordenarpar :: Ord b => [(a,b)] -> [(a,b)] 
 +  ordenarpar xs = foldl (buscparmin) [] (xs) 
 + 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) 
 + | 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... ¿¿que no se entiende??+y disculpen por meterme hablando de otro tema, pero aquellos que creen saber programar en c seguramente ahora lo veran de otra forma
introalg/rincon.1149135801.txt.gz · Última modificación: 2018/08/10 03:03 (editor externo)