introalg:taller2
Diferencias
Muestra las diferencias entre dos versiones de la página.
Ambos lados, revisión anteriorRevisión previaPróxima revisión | Revisión previa | ||
introalg:taller2 [2006/05/08 20:00] – nicolasw | introalg:taller2 [2018/08/10 03:03] (actual) – editor externo 127.0.0.1 | ||
---|---|---|---|
Línea 2: | Línea 2: | ||
===== Plan para hoy ===== | ===== Plan para hoy ===== | ||
- | * Repaso de algunas soluciones de la clase anterior | + | * Repaso de algunas soluciones de la clase anterior. |
- | * Trabajar sobre programas recursivos numéricos y con listas | + | * Sintáxis de //pattern matching//. |
- | * Sintáxis de //pattern matching// | + | * Trabajar sobre programas recursivos numéricos y con listas. |
- | * Resolución de ejercicios | + | * Resolución de ejercicios. |
===== Algunas soluciones de la clase anterior ====== | ===== Algunas soluciones de la clase anterior ====== | ||
Línea 13: | Línea 13: | ||
Notamos | Notamos | ||
* No hay una única forma de resolver un problema. | * No hay una única forma de resolver un problema. | ||
- | * Como podemos | + | * Como hacer **control de los parámetros de entrada**. |
- | * Cláusula '' | + | * Cláusula |
- | * Comentarios en el código. | + | |
- | * Uso del '' | + | * Uso del **'' |
- | * ¿Guardas | + | * ¿**Guardas |
* No se usaron **definiciones locales** para la función de cálculo de área. | * No se usaron **definiciones locales** para la función de cálculo de área. | ||
- | | + | |
+ | ** Se aprende muchísimo //leyendo detenidamente código bien escrito// | ||
===== Clase ===== | ===== Clase ===== | ||
+ | Hasta ahora vimos programas funcionales **no recursivos**, | ||
+ | |||
+ | Veamos la última función no recursiva que vamos a plantear, que sirve para presentar el mecanismo de **pattern matching**. | ||
+ | |||
+ | Ejercicio 8 | ||
+ | Definir la función cabeza: | ||
+ | |||
+ | Por ejemplo '' | ||
+ | |||
+ | El mecanismo básico para poder **destruir** una lista en partes es el //pattern matching//, que podemos pensarlo como una definición por casos, que es capaz de dividir la lista en su **cabeza** y **cola** | ||
+ | |||
+ | cabeza :: [a] -> a | ||
+ | cabeza (x:xs) = x | ||
+ | |||
+ | Podemos agregar esta definición a un script de Haskell con nombre '' | ||
+ | Evaluemos algunos casos. | ||
+ | |||
+ | Main> cabeza [1,2,3] | ||
+ | 1 | ||
+ | Main> cabeza " | ||
+ | ' | ||
+ | Main> cabeza [] | ||
+ | | ||
+ | Program error: pattern match failure: cabeza [] | ||
+ | |||
+ | De la misma forma podemos hacer la función '' | ||
+ | |||
+ | cola :: [a] -> [a] | ||
+ | cola (x:xs) = xs | ||
+ | |||
+ | También tenemos //pattern matching// numérico. \\ | ||
+ | Vemos como escribir una funcion que devuelve verdadero si y solo si el número es 0 o 1 (puede ser útil para el ejercicio 17) | ||
+ | |||
+ | ceroOuno :: Int -> Bool | ||
+ | ceroOuno 0 = True | ||
+ | ceroOuno 1 = True | ||
+ | ceroOuno x = False | ||
+ | |||
+ | |||
+ | ==== Programas Recursivos ==== | ||
+ | |||
+ | Tomemos el ejercicio 10 del Práctico 8. | ||
+ | |||
+ | Defina la función duplicar:: | ||
+ | Ejemplo: duplicar [2,4,8] = [4,8,16] | ||
+ | |||
+ | Usamos un planteamiento //inductivo o recursivo// y //pattern matching// para | ||
+ | * Definir un **caso base** (lista vacía '' | ||
+ | * Definir el **caso inductivo** (la lista tiene al menos un elemento, siendo el primero '' | ||
+ | |||
+ | duplicar :: [Int] -> [Int] | ||
+ | duplicar [] = [] -- caso base | ||
+ | duplicar (x:xs) = 2*x : xs -- caso inductivo | ||
+ | |||
+ | Probamos la definición | ||
+ | |||
+ | Main> duplicar [2,3,4] | ||
+ | [4,3,4] | ||
+ | |||
+ | ¿Donde está el error? | ||
+ | |||
+ | Simplemente olvidamos duplicar la " | ||
+ | Lo arreglamos rápidamente, | ||
+ | |||
+ | Veamos ahora el ejercicio 12. | ||
+ | |||
+ | Defina la función sumatoria: | ||
+ | |||
+ | La estrategia es la misma que en el caso anterior | ||
+ | * Definir caso base para la lista vacía. | ||
+ | * Definir el caso inductivo para la lista con al menos un elemento, suponiendo que ya esta definido para longitudes menores. | ||
+ | |||
+ | sumatoria :: [Int] -> Int | ||
+ | sumatoria [] = 0 | ||
+ | sumatoria (x:xs) = x + sumatoria xs | ||
+ | |||
+ | Vemos algunos ejemplos | ||
+ | |||
+ | Main> sumatoria [1,2,3] | ||
+ | 6 | ||
+ | Main> sumatoria (duplicar (duplicar [1,2,3])) | ||
+ | 24 | ||
+ | Main> sumatoria ((duplicar.duplicar) [1,2,3]) | ||
+ | 24 | ||
+ | |||
+ | Veamos el siguiente código y tratemos de entender que es lo que //computa// | ||
+ | |||
+ | desdeHasta :: Int -> Int -> [Int] | ||
+ | desdeHasta n m | n> | ||
+ | | n==m = [n] | ||
+ | | n< | ||
+ | |||
+ | * ¿A qué evaluaría '' | ||
+ | * ¿Y '' | ||
+ | * Finalmente que pasa exactamente con '' | ||
+ | |||
+ | Notamos que son importantes | ||
+ | * Los nombres de la función y de las variables, pues ayudan a entender su funcionalidad. | ||
+ | * La // | ||
+ | * Una buena // | ||
===== Ejercicios ===== | ===== Ejercicios ===== | ||
+ | Realizar en lo que resta de la clase | ||
+ | * (P8-E11) Definir la función // | ||
+ | * (P8-E12) Defina la función promedio // | ||
+ | * (P8-E16) (*) c) Modificar la guarda de '' |
introalg/taller2.1147118423.txt.gz · Última modificación: 2018/08/10 03:03 (editor externo)