tag:blogger.com,1999:blog-27490288970236247942024-03-13T12:31:22.231-07:00Blog de un opositor/aBienvenidos/as al proceloso mar de las Oposiciones. Aquí hay fuentes de información, enlaces a páginas, libros y reflexiones sobre el duro trabajo del opositor/a (a Informática). Además, un podcast de Informática y 7.000 vídeos en Youtube.Anonymoushttp://www.blogger.com/profile/10226435252364434873noreply@blogger.comBlogger150125tag:blogger.com,1999:blog-2749028897023624794.post-87436449946909167052012-08-05T10:03:00.003-07:002012-08-05T10:03:27.616-07:00Lista de repeticiones de una cadena dentro de otra<div dir="ltr" style="text-align: left;" trbidi="on">
import List<br /><br />
esPrefijoDe :: [Char] -> [Char] -> Bool<br />esPrefijoDe [] _ = True<br />esPrefijoDe _ [] = False<br />esPrefijoDe (x:xs) (y:ys) | x/=y = False<br /> | otherwise = esPrefijoDe xs ys<br /><br />posicionsub :: [Char] -> [Char] -> Int<br />posicionsub _ [] = -1<br />posicionsub (x:xs) (y:ys) | esPrefijoDe (x:xs) (y:ys) = 1<br /> | otherwise = 1 + posicionsub (x:xs) ys<br /><br />sumador :: [Int] -> [Int]<br />sumador [] = []<br />sumador [x] = [x]<br />sumador (x:y:[]) = [x] ++ [x+y]<br />sumador (x:y:xs) = [x] ++ sumador ([x+y] ++ xs)<br /><br />busquedas3 :: [Char] -> [Char] -> [Int]<br />busquedas3 _ [] = []<br />busquedas3 xs (y:ys) | pos+1<length(ys)+1 = [pos] ++ busquedas3 xs (drop (pos-1) ys)<br /> | otherwise = busquedas3 xs ys<br /> where pos = posicionsub xs (y:ys)<br /><br />busquedas4 :: [Char] -> [Char] -> [Int]<br />busquedas4 xs ys = sumador(busquedas3 xs ys)</div>Anonymoushttp://www.blogger.com/profile/10226435252364434873noreply@blogger.com0tag:blogger.com,1999:blog-2749028897023624794.post-25115588705715694302012-08-05T04:58:00.000-07:002012-08-05T04:58:11.119-07:00Combinaciones sin repetición en Haskell<div dir="ltr" style="text-align: left;" trbidi="on">
import List<br /><br />comb :: Int -> [a] -> [[a]]<br />comb 0 _ = [[]]<br />comb _ [] = []<br />comb (n+1) (x:xs) = [x:ys | ys <-comb n xs] ++ comb (n+1) xs</div>Anonymoushttp://www.blogger.com/profile/10226435252364434873noreply@blogger.com0tag:blogger.com,1999:blog-2749028897023624794.post-35928508044398724872012-07-25T15:08:00.003-07:002012-07-25T15:08:55.527-07:00Relación de ejercicios argentina en Haskell<div dir="ltr" style="text-align: left;" trbidi="on">
<a href="https://dl.dropbox.com/u/30592764/haskell/practico2.pdf">https://dl.dropbox.com/u/30592764/haskell/practico2.pdf</a><br />
El 8 está chulo, muchos ejercicios cortitos.</div>Anonymoushttp://www.blogger.com/profile/10226435252364434873noreply@blogger.com0tag:blogger.com,1999:blog-2749028897023624794.post-76170268844478157642012-07-25T15:03:00.002-07:002012-07-25T15:03:22.510-07:00Técnicas de programación recursiva en Haskell<div dir="ltr" style="text-align: left;" trbidi="on">
<h2>
<a href="http://www.blogger.com/blogger.g?blogID=2749028897023624794" name="SEC_TProgRecur">4. Técnicas de programación Recursiva</a></h2>
<div class="text">
En esta sección se indicarán varios patrones de tratamiento de estructuras recursivas.
Estos patrones se aplicarán principalmente a listas, pero muchos de ellos pueden generalizarse
a otras estructuras como árboles, rosales, etc.</div>
<h3>
<a href="http://www.blogger.com/blogger.g?blogID=2749028897023624794" name="SUBSEC_AplicarF">4.1. Aplicar una función a cada elemento</a></h3>
<div class="example">
<a href="http://www.blogger.com/blogger.g?blogID=2749028897023624794" name="EX_aplica"></a>Ejemplo (<em>aplica</em>)
<code><pre>> aplica :: (a -> b) -> [a] -> [b]
> aplica f [] = []
> aplica f (x:xs) = f x : aplica f xs
</pre>
</code></div>
<div class="note">
<em>Nota: </em>La función <code>aplica</code> está predefinida como la función
<code>map</code></div>
<h3>
<a href="http://www.blogger.com/blogger.g?blogID=2749028897023624794" name="SUBSEC_fold">4.2. Recorrer y transformar una estructura en un valor</a></h3>
<div class="text">
Obsérvese la definición de las siguientes funciones</div>
<div class="example">
<a href="http://www.blogger.com/blogger.g?blogID=2749028897023624794" name="EX_sumaLs"></a>Ejemplo (<em>sumaLs</em>)
<code><pre>> sumaLs :: Num n => [n] -> n
> sumaLs [] = 0
> sumaLs (x:xs) = x + sumaLs xs
</pre>
</code></div>
<div class="example">
<a href="http://www.blogger.com/blogger.g?blogID=2749028897023624794" name="EX_prodLs"></a>Ejemplo (<em>prodLs</em>)
<code><pre>> prodLs :: Num n => [n] -> n
> prodLs [] = 1
> prodLs (x:xs) = x * prodLs xs
</pre>
</code></div>
<div class="example">
<a href="http://www.blogger.com/blogger.g?blogID=2749028897023624794" name="EX_longLs"></a>Ejemplo (<em>longLs</em>)
<code><pre>> longLs :: Num n => [a] -> n
> longLs [] = 0
> longLs (x:xs) = 1 + longLs xs
</pre>
</code></div>
<div class="text">
En la definición de las siguientes funciones, puede observarse que se utiliza
siempre un mismo patrón. Un caso básico cuando la lista está vacía, cuyo valor es
<code>0</code>, <code>1</code> y <code>0</code>;
y un caso recursivo en el cual se realiza una operación combinando el elemento <code>x</code> con
el resultado de la llamada recursiva. La operación, en el primer caso es <code>\x r -> x + r</code>,
en el segundo caso es <code>\x r -> x * r</code> y en el último caso es <code>\x r -> 1 + r</code>. </div>
<div class="text">
El patrón descrito podría generalizarse en una función <code>foldRight</code> que tome como parámetros
el valor <code>e</code> a devolver en el caso básico y la operación <code>op</code> a realizar en el caso recursivo.
</div>
<div class="example">
<a href="http://www.blogger.com/blogger.g?blogID=2749028897023624794" name="EX_foldRight"></a>Ejemplo (<em>foldRight</em>)
<code><pre>> foldRight :: (a -> b -> b) -> b -> [a] -> b
> foldRight op e [] = e
> foldRight op e (x:xs) = x `op` foldRight op e xs
</pre>
</code><pre class="test">?-foldRight (+) 0 [2,3,4]9</pre>
</div>
<div class="note">
<em>Nota: </em>La función <code>foldRight</code> está predefinida como la función <code>foldr</code></div>
<div class="text">
A partir de la función <code>foldr</code>, pueden redefinirse las funciones
<code>sumaLs</code>,<code>prodLs</code> y <code>longLs</code>.</div>
<div class="example">
<a href="http://www.blogger.com/blogger.g?blogID=2749028897023624794" name="EX_sumaLs'"></a>Ejemplo (<em>sumaLs'</em>)
<code><pre>> sumaLs' = foldr (+) 0
</pre>
</code></div>
<div class="example">
<a href="http://www.blogger.com/blogger.g?blogID=2749028897023624794" name="EX_prodLs'"></a>Ejemplo (<em>prodLs'</em>)
<code><pre>> prodLs' = foldr (*) 1
</pre>
</code></div>
<div class="example">
<a href="http://www.blogger.com/blogger.g?blogID=2749028897023624794" name="EX_longLs'"></a>Ejemplo (<em>longLs'</em>)
<code><pre>> longLs' = foldr (\x r -> 1 + r) 0
</pre>
</code></div>
<div class="text">
Además de las funciones anteriores, existen numerosas funciones que trabajan sobre listas y
que pueden definirse a partir de la función <code>foldr</code></div>
<div class="example">
<a href="http://www.blogger.com/blogger.g?blogID=2749028897023624794" name="EX_andLs"></a>Ejemplo (<em>andLs</em>)
<code><pre>> andLs :: [Bool] -> Bool
> andLs = foldr (&&) True
</pre>
</code></div>
<div class="note">
<em>Nota: </em>La función <code>andLs</code> está predefinida como la función <code>and</code></div>
<div class="example">
<a href="http://www.blogger.com/blogger.g?blogID=2749028897023624794" name="EX_orLs"></a>Ejemplo (<em>orLs</em>)
<code><pre>> orLs :: [Bool] -> Bool
> orLs = foldr (||) False
</pre>
</code></div>
<div class="note">
<em>Nota: </em>La función <code>orLs</code> está predefinida como la función <code>or</code></div>
<div class="example">
<a href="http://www.blogger.com/blogger.g?blogID=2749028897023624794" name="EX_append"></a>Ejemplo (<em>append</em>)
<code><pre>> append :: [a] -> [a] -> [a]
> append xs ys = foldr (\x r -> x : r) ys xs
</pre>
</code></div>
<div class="note">
<em>Nota: </em>La función <code>append</code> está predefinida como el operador <code>(++)</code></div>
<div class="example">
<a href="http://www.blogger.com/blogger.g?blogID=2749028897023624794" name="EX_vuelta"></a>Ejemplo (<em>vuelta</em>)
<code><pre>> vuelta :: [a] -> [a]
> vuelta = foldr (\x r -> r ++ [x]) []
</pre>
</code></div>
<div class="note">
<em>Nota: </em>La función <code>vuelta</code> está predefinida como la función <code>reverse</code></div>
<div class="example">
<a href="http://www.blogger.com/blogger.g?blogID=2749028897023624794" name="EX_tomaMientras"></a>Ejemplo (<em>tomaMientras</em>)
<code><pre>> tomaMientras :: (a -> Bool) -> [a] -> [a]
> tomaMientras f = foldr (\x r -> if f x then x:r else []) []
</pre>
</code><pre class="test">?-tomaMientras (>3) [6,5,2,4,1] [6,5]</pre>
</div>
<div class="note">
<em>Nota: </em>La función <code>tomaMientras</code> está predefinida como la función
<code>takeWhile</code></div>
<div class="example">
<a href="http://www.blogger.com/blogger.g?blogID=2749028897023624794" name="EX_filtra"></a>Ejemplo (<em>filtra</em>)
<code><pre>> filtra :: (a -> Bool) -> [a] -> [a]
> filtra f = foldr (\x r -> if f x then x:r else r) []
</pre>
</code><pre class="test">?-filtra (>3) [6,5,2,4,1] [6,5,4]</pre>
</div>
<div class="note">
<em>Nota: </em>La función <code>filtra</code> está predefinida como la función
<code>filter</code></div>
<h3>
<a href="http://www.blogger.com/blogger.g?blogID=2749028897023624794" name="SUBSEC_zip">4.3. Combinar dos estructuras</a></h3>
<div class="example">
<a href="http://www.blogger.com/blogger.g?blogID=2749028897023624794" name="EX_comb"></a>Ejemplo (<em>comb</em>)
<code><pre>> comb :: [a] -> [b] -> [(a,b)]
> comb xs [] = []
> comb [] ys = []
> comb (x:xs) (y:ys) = (x,y):comb xs ys
</pre>
</code><pre class="test">?-comb [2,3,4] "hola"[(2,'h'),(3,'o'),(4,'l')]</pre>
</div>
<div class="note">
<em>Nota: </em>La función <code>comb</code> está predefinida como la función <code>zip</code></div>
<h3>
<a href="http://www.blogger.com/blogger.g?blogID=2749028897023624794" name="SUBSEC_comprehension">4.4. Listas intensionales</a></h3>
<div class="text">
El lenguaje Haskell admite una notación que facilita la definición de listas. Esta notación es
similar a las definiciones matemáticas intensionales</div>
<div class="example">
<a href="http://www.blogger.com/blogger.g?blogID=2749028897023624794" name="EX_cpares20"></a>Ejemplo (<em>cpares20</em>)
<div class="text">
La función <code>cpares20</code> calcula los cuadrados de los números pares entre 1 y 20</div>
<code><pre>> cpares20 :: [Integer]
> cpares20 = [x ^ 2 | x <- [1..20], x `mod` 2 == 0]
</pre>
</code><pre class="test">?-cpares20[4,16,36,64,100,144,196,256,324,400]</pre>
</div>
<div class="example">
<a href="http://www.blogger.com/blogger.g?blogID=2749028897023624794" name="EX_divisores"></a>Ejemplo (<em>divisores</em>)
<div class="text">
La función <code>divisores</code> calcula los divisores de un número</div>
<code><pre>> divisores :: Integer -> [Integer]
> divisores n = [d | d <- [1..n], n `mod` d == 0]
</pre>
</code><pre class="test">?-divisores 24[1,2,3,4,6,8,12,24]</pre>
</div>
<h3>
<a href="http://www.blogger.com/blogger.g?blogID=2749028897023624794" name="SUBSEC_recorrer2">4.5. Otras posibilidades de recorrer y transformar una lista en un valor</a></h3>
<div class="text">
La función <code>foldr</code> actúa de la siguiente forma: </div>
<code><pre>foldr op e [x1,x2,x3] = x1 `op` (x2 `op` (x3 `op` e))
</pre>
</code><div class="text">
Como puede observarse, la operación se asocia hacia la derecha. El nombre <code>foldr</code>
viene de fold-right, a la derecha.
</div>
<div class="text">
Es posible definir una función fold-left que se denominará <code>foldl</code> y realiza la asociación
a la izquierda.
</div>
<code><pre>foldl op e [x1,x2,x3] = ((e `op` x1) `op` x2) `op` x3
</pre>
</code><div class="example">
<a href="http://www.blogger.com/blogger.g?blogID=2749028897023624794" name="EX_foldLeft"></a>Ejemplo (<em>foldLeft</em>)
<code><pre>> foldLeft :: (b -> a -> b) -> b -> [a] -> b
> foldLeft op e [] = e
> foldLeft op e (x:xs) = foldLeft op (e `op` x) xs
</pre>
</code><pre class="test">?-foldLeft (+) 0 [1,3,4]8</pre>
</div>
<div class="note">
<em>Nota: </em>La función <code>foldLeft</code> está predefinida en Haskell como <code>foldl</code></div>
<div class="text">
Cuando la operación <code>op</code> es asociativa y <code>e</code> es el elemento neutro de <code>op</code>,
se cunple que:</div>
<code><pre>foldr op e = foldl op e
</pre>
</code><div class="text">
En general, <code>foldr</code> es más eficiente que <code>foldl</code>.
Sin embargo, <code>foldl</code> puede ser útil en cierto tipo de definiciones</div>
<div class="example">
<a href="http://www.blogger.com/blogger.g?blogID=2749028897023624794" name="EX_ls2n"></a>Ejemplo (<em>ls2n</em>)
<div class="text">
La función <code>ls2n</code> convierte una lista de dígitos en un número decimal</div>
<code><pre>> ls2n :: [Integer] -> Integer
> ls2n = foldl (\r a -> r * 10 + a) 0
</pre>
</code><pre class="test">?-ls2n [1,3,4]134</pre>
</div>
<div class="text">
Si las listas no están vacías, puede ser necesario aplicar la operación sobre los elementos sin
utilizar un elemento básico. Los operadores <code>foldr1</code> y <code>foldl1</code> actúan de
la siguiente forma:</div>
<code><pre>foldr1 op [x1,x2,x3] = x1 `op` (x2 `op` x3)
foldl1 op [x1,x2,x3] = (x1 `op` x2) `op` x3
</pre>
</code><div class="example">
<a href="http://www.blogger.com/blogger.g?blogID=2749028897023624794" name="EX_maxLs"></a>Ejemplo (<em>maxLs</em>)
<div class="text">
La función <code>maxLs</code> devuelve el valor máximo de una lista de enteros</div>
<code><pre>> maxLs :: [Integer] -> Integer
> maxLs = foldr1 max
</pre>
</code><pre class="test">?-maxLs [-1,-3,-4]-1</pre>
</div>
<h3>
<a href="http://www.blogger.com/blogger.g?blogID=2749028897023624794" name="SUBSEC_scan">4.6. Recorrer y transformar una estructura generando resultados parciales</a></h3>
<div class="text">
Los operadores predefinidos <code>scanr</code>, <code>scanl</code>, <code>scanr1</code> y <code>scanl1</code>
recorren la lista generando resultados parciales de la siguiente forma: </div>
<code><pre>scanr op e [x1,x2,x3] =
[x1 `op` (x2 `op` (x3 `op` e)), x2 `op` (x3 `op` e), x3 `op` e, e]
scanl op e [x1,x2,x3] =
[e, e `op` x1, (e `op` x1) `op` x2, ((e `op` x1) `op` x2) `op` x3]
scanr1 op e [x1,x2,x3] =
[x1 `op` (x2 `op` x3), x2 `op` x3, x3]
scanl1 op e [x1,x2,x3] =
[x1, x1 `op` x2, (x1 `op` x2) `op` x3]
</pre>
</code><div class="example">
<a href="http://www.blogger.com/blogger.g?blogID=2749028897023624794" name="EX_ruffini"></a>Ejemplo (<em>ruffini</em>)
<div class="text">
La función <code>ruffini</code> aplica la regla de ruffini</div>
<code><pre>> ruffini :: Float -> [Float] -> [Float]
> ruffini a = scanl1 (\r x -> r * a + x)
</pre>
</code><pre class="test">?-ruffini 3 [2,4,3][2,10,33]</pre>
</div>
<h3>
<a href="http://www.blogger.com/blogger.g?blogID=2749028897023624794" name="SUBSEC_unfold">4.7. Generar una estructura</a></h3>
<div class="text">
La generación de una lista a partir de un valor puede capturarse mediante
la siguiente función</div>
<div class="example">
<a href="http://www.blogger.com/blogger.g?blogID=2749028897023624794" name="EX_unfold"></a>Ejemplo (<em>unfold</em>)
<div class="text">
La función <code>unfold</code> realiza el proceso inverso a la función <code>foldr</code></div>
<code><pre>> unfold :: (a -> Bool) -> (a -> b) -> (a -> a) -> a -> [b]
> unfold p f g x = if p x then []
> else f x : unfold p f g (g x)
</pre>
</code></div>
<div class="example">
<a href="http://www.blogger.com/blogger.g?blogID=2749028897023624794" name="EX_d2b"></a>Ejemplo (<em>d2b</em>)
<div class="text">
La función <code>d2b</code> convierte un número decimal en su representación binaria</div>
<code><pre>> d2b :: Integer -> [Integer]
> d2b = reverse . unfold (==0) (`mod` 2) (`div` 2)
</pre>
</code><pre class="test">?-d2b 13[1,1,0,1]</pre>
</div>
<div class="example">
<a href="http://www.blogger.com/blogger.g?blogID=2749028897023624794" name="EX_pals"></a>Ejemplo (<em>pals</em>)
<div class="text">
La función <code>pals</code> convierte devuelve la lista de palabras que forman una cadena de caracteres
</div>
<code><pre>> pals :: String -> [String]
> pals = palsAux . quitaEsp
> where palsAux = unfold (=="") tomaPal quitaPal
> tomaPal = takeWhile (not . esp)
> quitaPal = quitaEsp . dropWhile (not . esp)
> quitaEsp = dropWhile esp
> esp x = x == ' ' || x == '\n'
</pre>
</code><pre class="test">?-pals "mi perro es listo"["mi","perro","es","listo"]</pre>
</div>
<h3>
<a href="http://www.blogger.com/blogger.g?blogID=2749028897023624794" name="SUBSEC_OtrasEstruc">4.8. Otras estructuras recursivas</a></h3>
<div class="text">
Los combinadores definidos en las secciones anteriores pueden
generalizarse para otras estructuras recursivas.
</div>
<div class="example">
<a href="http://www.blogger.com/blogger.g?blogID=2749028897023624794" name="EX_foldA"></a>Ejemplo (<em>foldA</em>)
<div class="text">
La función <code>foldA</code> recorre y transforma un árbol en un valor
</div>
<code><pre>> foldA :: (a -> b -> b -> b) -> b -> Arbol a -> b
> foldA f e Hoja = e
> foldA f e (Rama x i d) = f x (foldA f e i) (foldA f e d)
</pre>
</code><div class="text">
La función <code>sumaArbol</code> calcula la suma de los nodos de un árbol</div>
<code><pre>> sumaArbol :: Num n => Arbol n -> n
> sumaArbol = foldA (\x i d -> x + i + d) 0
</pre>
</code><pre class="test">?-sumaArbol a114</pre>
<div class="text">
La función <code>nodosArbol</code> devuelve la lista de nodos de un árbol</div>
<code><pre>> nodosArbol :: Arbol a -> [a]
> nodosArbol = foldA (\x i d -> [x] ++ i ++ d) []
</pre>
</code><pre class="test">?-nodosArbol a1[3,4,5,2]</pre>
</div>
<div class="example">
<a href="http://www.blogger.com/blogger.g?blogID=2749028897023624794" name="EX_foldRosal"></a>Ejemplo (<em>foldRosal</em>)
<div class="text">
La función <code>foldRosal</code> recorre y transforma un rosal en un valor
</div>
<code><pre>> foldRosal :: (a -> [b] -> b) -> b -> Rosal a -> b
> foldRosal f e Vacio = e
> foldRosal f e (Nodo x ls) = f x (map (foldRosal f e) ls)
</pre>
</code><div class="text">
La función <code>sumaRosal</code> calcula la suma de los nodos de un rosal</div>
<code><pre>> sumaRosal :: Num n => Rosal n -> n
> sumaRosal = foldRosal (\x ls -> x + sum ls) 0
</pre>
</code><div class="text">
La función <code>nodosRosal</code> devuelve la lista de nodos de un rosal</div>
<code><pre>> nodosRosal :: Rosal a -> [a]
> nodosRosal = foldRosal (\x ls -> [x] ++ concat ls) []
</pre>
</code></div>
<div class="note">
<em>Nota: </em>
Sería deseable definir una función <code>fold</code> genérica que recorriese y transformase
todo tipo de estructuras recursivas. Aunque Haskell no permite este tipo de definiciones,
existe una extensión del lenguaje denominada <em>Generic Haskell</em> que permite
definir funciones genéricas, también denominadas politípicas.
</div>
<h3>
<a href="http://www.blogger.com/blogger.g?blogID=2749028897023624794" name="SUBSEC_CombRecursivos">4.9. Combinadores recursivos básicos</a></h3>
<div class="text">
Muchas estructuras recursivas básicas que en otros lenguajes están predefinidas, pueden
ser definidas por el usuario</div>
<div class="example">
<a href="http://www.blogger.com/blogger.g?blogID=2749028897023624794" name="EX_hasta"></a>Ejemplo (<em>hasta</em>)
<div class="text">
La función <code>hasta</code> captura un patrón recursivo básico
</div>
<code><pre>> hasta :: (a -> Bool) -> (a -> a) -> a -> a
> hasta p f x = if p x then x
> else hasta p f (f x)
</pre>
</code></div>
</div>Anonymoushttp://www.blogger.com/profile/10226435252364434873noreply@blogger.com3tag:blogger.com,1999:blog-2749028897023624794.post-16169273887720496312012-07-25T15:00:00.001-07:002012-07-25T15:06:52.502-07:00PDF con funciones recursivas básicas en Haskell<div dir="ltr" style="text-align: left;" trbidi="on">
<a href="http://www.slideshare.net/JoseAAlonso/definiciones-por-recursin-en-haskell">http://www.slideshare.net/JoseAAlonso/definiciones-por-recursin-en-haskell</a></div>Anonymoushttp://www.blogger.com/profile/10226435252364434873noreply@blogger.com0tag:blogger.com,1999:blog-2749028897023624794.post-38044554078040038552012-07-25T14:54:00.000-07:002012-07-25T14:54:38.762-07:00Lista de divisores en Haskell recursiva<div dir="ltr" style="text-align: left;" trbidi="on">
divisores:: Int -> [Int]<br />
divisores n = divisoresDesde n 1<br />
divisoresDesde:: Int -> Int -> [Int]<br />
divisoresDesde n m<br />
|n == m = [n]<br />
|n > m && (n `mod` m == 0) = m:(divisoresDesde n (m+1))<br />
|n > m && (n `mod` m /= 0) = divisoresDesde n (m+1)<br />
Segundo Cuatrimestre</div>Anonymoushttp://www.blogger.com/profile/10226435252364434873noreply@blogger.com0tag:blogger.com,1999:blog-2749028897023624794.post-46619733398354841662012-07-25T14:53:00.000-07:002012-07-25T14:53:33.005-07:00Máximo de una lista en Haskell recursivo<div dir="ltr" style="text-align: left;" trbidi="on">
maximo:: Int -> [Int] -> Int<br />
maximo [] = error"No hay maximo"<br />
maximo [x] = x<br />
maximo (x:xs)<br />
| x < maximo xs = maximo xs<br />
| x >= maximo xs = x</div>Anonymoushttp://www.blogger.com/profile/10226435252364434873noreply@blogger.com0tag:blogger.com,1999:blog-2749028897023624794.post-10668971940352289022012-07-25T14:51:00.001-07:002012-07-25T14:52:45.692-07:00Longitud de una lista en Haskell recursiva<div dir="ltr" style="text-align: left;" trbidi="on">
longitud:: [a] -> Int<br />longitud [] = 0<br />longitud (x:xs) = 1 + longitud xs </div>Anonymoushttp://www.blogger.com/profile/10226435252364434873noreply@blogger.com0tag:blogger.com,1999:blog-2749028897023624794.post-81532805119087305842012-07-25T14:49:00.001-07:002012-07-25T14:49:40.989-07:00Introducción a Haskell<div dir="ltr" style="text-align: left;" trbidi="on">
Haskell (/ˈhæskəl/) es un lenguaje de programación estandarizado
multi-propósito puramente funcional con semánticas no estrictas y fuerte
tipificación estática. Su nombre se debe al lógico estadounidense <a href="http://es.wikipedia.org/wiki/Haskell_Curry" title="Haskell Curry">Haskell Curry</a>.
En Haskell, "una función es un ciudadano de primera clase" del lenguaje
de programación. Como lenguaje de programación funcional, el
constructor de controles primario es la función. El lenguaje tiene sus
orígenes en las observaciones de Haskell Curry y sus descendientes
intelectuales.<br />
Las características más interesantes de Haskell incluyen el soporte para <a href="http://es.wikipedia.org/wiki/Tipo_de_dato" title="Tipo de dato">tipos de datos</a> y funciones <a href="http://es.wikipedia.org/wiki/Recursi%C3%B3n" title="Recursión">recursivas</a>, listas, <a class="mw-redirect" href="http://es.wikipedia.org/wiki/Tuplas" title="Tuplas">tuplas</a>, guardas y <a class="new" href="http://es.wikipedia.org/w/index.php?title=Calce_de_patrones&action=edit&redlink=1" title="Calce de patrones (aún no redactado)">calce de patrones</a>. La combinación de las mismas pueden resultar en algunas funciones casi triviales cuya versión en <a class="mw-redirect" href="http://es.wikipedia.org/wiki/Lenguajes_imperativos" title="Lenguajes imperativos">lenguajes imperativos</a> pueden llegar a resultar extremadamente tediosas de programar. Haskell es, desde 2002, uno de los <a class="mw-redirect" href="http://es.wikipedia.org/wiki/Lenguajes_funcionales" title="Lenguajes funcionales">lenguajes funcionales</a> sobre los que más se ha investigado. Se han desarrollado muchas variantes:<br />
<ul>
<li><a class="mw-redirect" href="http://es.wikipedia.org/wiki/Programaci%C3%B3n_paralela" title="Programación paralela">Versiones paralelas</a> del <a class="mw-redirect" href="http://es.wikipedia.org/wiki/MIT" title="MIT">MIT</a> y <a class="extiw" href="http://en.wikipedia.org/wiki/en:Glasgow_University" title="w:en:Glasgow University">Glasgow</a>, ambas denominadas <i>Parallel Haskell</i>.</li>
<li>Más versiones paralelas y distribuidas de Haskell llamadas <i>Distributed Haskell</i> (anteriormente <i>Goffin</i>) y Eden</li>
<li>Una versión con ejecución especulativa: <i>Eager Haskell</i></li>
<li>Varias versiones <a href="http://es.wikipedia.org/wiki/Programaci%C3%B3n_orientada_a_objetos" title="Programación orientada a objetos">orientadas a objetos</a>: <i>Haskell++</i>, <i>O'Haskell</i> y <i>Mondrian</i>.</li>
<li>Una versión educativa llamada Gofer desarrollada por Mark Jones que fue suplantada por <a href="http://es.wikipedia.org/wiki/Hugs" title="Hugs">Hugs</a> (ver abajo).</li>
</ul>
</div>Anonymoushttp://www.blogger.com/profile/10226435252364434873noreply@blogger.com0tag:blogger.com,1999:blog-2749028897023624794.post-15474411720409049952012-07-07T04:47:00.000-07:002012-07-07T04:47:31.033-07:00Ejercicios de redes: packet tracer<div dir="ltr" style="text-align: left;" trbidi="on">
<a href="https://sites.google.com/site/jramon208/inicio/redes/ejerciciospackettracer">https://sites.google.com/site/jramon208/inicio/redes/ejerciciospackettracer</a><br />
<a href="http://ejerciciospackettracer.wordpress.com/">http://ejerciciospackettracer.wordpress.com/</a><br />
<br /></div>Anonymoushttp://www.blogger.com/profile/10226435252364434873noreply@blogger.com1tag:blogger.com,1999:blog-2749028897023624794.post-76912425842359374342012-06-22T09:57:00.003-07:002012-06-22T09:57:43.094-07:00Vídeo de redes<div dir="ltr" style="text-align: left;" trbidi="on">
<div class="separator" style="clear: both; text-align: center;">
<iframe allowfullscreen='allowfullscreen' webkitallowfullscreen='webkitallowfullscreen' mozallowfullscreen='mozallowfullscreen' width='320' height='266' src='https://www.youtube.com/embed/N47MBLGsE0U?feature=player_embedded' frameborder='0'></iframe></div>
<br /></div>Anonymoushttp://www.blogger.com/profile/10226435252364434873noreply@blogger.com1tag:blogger.com,1999:blog-2749028897023624794.post-91974872442486779712012-05-05T02:41:00.000-07:002012-05-05T02:41:47.261-07:00Ejercicios de redes del IES Gonzalo Nazareno: buenísimos<div dir="ltr" style="text-align: left;" trbidi="on">
<a href="http://informatica.gonzalonazareno.org/plataforma/mod/resource/view.php?id=5536">http://informatica.gonzalonazareno.org/plataforma/mod/resource/view.php?id=5536</a></div>Anonymoushttp://www.blogger.com/profile/10226435252364434873noreply@blogger.com0tag:blogger.com,1999:blog-2749028897023624794.post-54213611579710308572012-05-05T02:33:00.002-07:002012-05-05T02:33:54.598-07:00Ejercicios de redes: libro muy bueno<div dir="ltr" style="text-align: left;" trbidi="on">
<a href="http://www.argitalpenak.ehu.es/p291-content/eu/contenidos/libro/se_cytpdf/eu_cytpdf/adjuntos/Redes%20y%20ST%20Ej%20Resueltos.pdf">http://www.argitalpenak.ehu.es/p291-content/eu/contenidos/libro/se_cytpdf/eu_cytpdf/adjuntos/Redes%20y%20ST%20Ej%20Resueltos.pdf</a></div>Anonymoushttp://www.blogger.com/profile/10226435252364434873noreply@blogger.com0tag:blogger.com,1999:blog-2749028897023624794.post-16810787374312087622012-04-21T10:10:00.002-07:002012-04-21T10:10:14.196-07:00shell script objeto más antiguo de un directorio<div dir="ltr" style="text-align: left;" trbidi="on">
<a href="http://www.daniweb.com/software-development/shell-scripting/threads/288013/sort-oldest-5-files-in-a-directory-tree-recursively-based-on-timestamp-linux">http://www.daniweb.com/software-development/shell-scripting/threads/288013/sort-oldest-5-files-in-a-directory-tree-recursively-based-on-timestamp-linux</a></div>Anonymoushttp://www.blogger.com/profile/10226435252364434873noreply@blogger.com0tag:blogger.com,1999:blog-2749028897023624794.post-5585441830898211872012-04-21T04:37:00.000-07:002012-04-21T04:37:06.301-07:00lsof shell script: un comando muy útil e interesante<div dir="ltr" style="text-align: left;" trbidi="on">
<a href="http://www.akadia.com/services/lsof_quickstart.txt">http://www.akadia.com/services/lsof_quickstart.txt</a></div>Anonymoushttp://www.blogger.com/profile/10226435252364434873noreply@blogger.com0tag:blogger.com,1999:blog-2749028897023624794.post-73873239354410359182012-04-21T01:30:00.002-07:002012-04-21T01:30:11.130-07:00if en shell script<div dir="ltr" style="text-align: left;" trbidi="on">
<a href="http://tldp.org/LDP/Bash-Beginners-Guide/html/sect_07_01.html">http://tldp.org/LDP/Bash-Beginners-Guide/html/sect_07_01.html</a></div>Anonymoushttp://www.blogger.com/profile/10226435252364434873noreply@blogger.com0tag:blogger.com,1999:blog-2749028897023624794.post-83126148646905343102012-03-19T11:14:00.003-07:002012-03-19T11:14:54.291-07:00Introducción a los lenguajes de programación<div dir="ltr" style="text-align: left;" trbidi="on">
<a href="http://dis.um.es/%7Elopezquesada/documentos/IES_1011/LMSGI/curso/UT2/UT2.pdf">http://dis.um.es/~lopezquesada/documentos/IES_1011/LMSGI/curso/UT2/UT2.pdf</a></div>Anonymoushttp://www.blogger.com/profile/10226435252364434873noreply@blogger.com0tag:blogger.com,1999:blog-2749028897023624794.post-51644703356915267812012-03-13T12:53:00.000-07:002012-03-13T12:53:57.244-07:00Málaga ciudad inteligente<div dir="ltr" style="text-align: left;" trbidi="on">
<a href="http://www.elmundo.es/elmundo/2011/09/28/suvivienda/1317231499.html">http://www.elmundo.es/elmundo/2011/09/28/suvivienda/1317231499.html</a><br />
<a href="http://www.diariosur.es/20110928/local/malaga/malaga-encabeza-ranking-ciudades-201109281411.html">http://www.diariosur.es/20110928/local/malaga/malaga-encabeza-ranking-ciudades-201109281411.html</a></div>Anonymoushttp://www.blogger.com/profile/10226435252364434873noreply@blogger.com0tag:blogger.com,1999:blog-2749028897023624794.post-3624611869717153902012-03-13T12:40:00.002-07:002012-03-13T12:40:37.520-07:00Noticia Smarter Planet<div dir="ltr" style="text-align: left;" trbidi="on">
<a href="http://www.publico.es/ciencias/291505/la-ciudad-empieza-a-hablar">http://www.publico.es/ciencias/291505/la-ciudad-empieza-a-hablar</a></div>Anonymoushttp://www.blogger.com/profile/10226435252364434873noreply@blogger.com0tag:blogger.com,1999:blog-2749028897023624794.post-11256701271057362502012-02-26T05:19:00.001-08:002012-02-26T05:21:14.079-08:00Diseño de bases de datos Modelo Entidad Relación Ejercicio 2 Empleados y...<div dir="ltr" style="text-align: left;" trbidi="on">
<iframe allowfullscreen="" frameborder="0" height="270" src="http://www.youtube.com/embed/CoKU34f7zFo?fs=1" width="480"></iframe></div>Anonymoushttp://www.blogger.com/profile/10226435252364434873noreply@blogger.com0tag:blogger.com,1999:blog-2749028897023624794.post-43440576268079318752012-02-26T05:19:00.000-08:002012-02-26T05:23:04.150-08:00Software para crear diagramas del modelo Entidad Relación y capturar pan...<div dir="ltr" style="text-align: left;" trbidi="on">
<iframe allowfullscreen="" frameborder="0" height="270" src="http://www.youtube.com/embed/_fx4Bo3FTkw?fs=1" width="480"></iframe></div>Anonymoushttp://www.blogger.com/profile/10226435252364434873noreply@blogger.com0tag:blogger.com,1999:blog-2749028897023624794.post-9156066499034826472012-02-26T05:18:00.001-08:002012-02-26T05:23:16.737-08:00Diseño de bases de datos Modelo Entidad Relación Ejercicio 4 Clientes y ...<div dir="ltr" style="text-align: left;" trbidi="on">
<iframe allowfullscreen="" frameborder="0" height="270" src="http://www.youtube.com/embed/9UtMyxj1y2I?fs=1" width="480"></iframe></div>Anonymoushttp://www.blogger.com/profile/10226435252364434873noreply@blogger.com0tag:blogger.com,1999:blog-2749028897023624794.post-89068926250797494702012-02-26T05:18:00.000-08:002012-02-26T05:23:31.995-08:00Diseño de bases de datos Modelo Entidad Relación Ejercicio 3 Futbolistas...<div dir="ltr" style="text-align: left;" trbidi="on">
<iframe allowfullscreen="" frameborder="0" height="270" src="http://www.youtube.com/embed/C7I9pGPQfxI?fs=1" width="480"></iframe></div>Anonymoushttp://www.blogger.com/profile/10226435252364434873noreply@blogger.com0tag:blogger.com,1999:blog-2749028897023624794.post-82520072359399918962012-02-26T05:17:00.002-08:002012-02-26T05:23:45.130-08:00Diseño de bases de datos Modelo Entidad Relación Ejercicio 5 Personas Co...<div dir="ltr" style="text-align: left;" trbidi="on">
<iframe allowfullscreen="" frameborder="0" height="270" src="http://www.youtube.com/embed/t6BugT2gkuc?fs=1" width="480"></iframe></div>Anonymoushttp://www.blogger.com/profile/10226435252364434873noreply@blogger.com1tag:blogger.com,1999:blog-2749028897023624794.post-20873346440690726482012-02-26T05:17:00.001-08:002012-02-26T05:24:05.582-08:00Diseño de bases de datos Modelo Entidad Relación Ejercicio 6 Personas Co...<div dir="ltr" style="text-align: left;" trbidi="on">
<iframe allowfullscreen="" frameborder="0" height="270" src="http://www.youtube.com/embed/PQB7GmIc_Eg?fs=1" width="480"></iframe></div>Anonymoushttp://www.blogger.com/profile/10226435252364434873noreply@blogger.com0