Alfabeto comenzando en un carácter
Se ha añadido el ejercicio Alfabeto comenzando en un carácter, propuesto originalmente el 12 de mayo de 2014.
Ramas de un árbol
Se ha añadido el ejercicio Ramas de un árbol propuesto el 9 de mayo de 2014.
Exercitium (Un reto diario de programación)
La programación informática, como cualquier disciplina creativa, requiere estudio y práctica constantes. Este blog publica ejercicios de programación diariamente para que los programadores, independientemente de su nivel de experiencia, puedan mantener y perfeccionar sus habilidades, explorando soluciones más allá de sus zonas de confort habituales.
Objetivo y enfoque
Estos ejercicios no constituyen un concurso. Fueron originalmente diseñados para los estudiantes de la asignatura de Informática de 1º del Grado en Matemáticas. No se otorgan puntuaciones ni se mantiene un registro de quienes los completan. La verdadera recompensa es el conocimiento adquirido y la mejora de tus habilidades como programador.
Cada ejercicio está concebido para resolverse en aproximadamente quince minutos, aunque el tiempo real puede variar desde unos pocos minutos hasta varias horas, dependiendo de la experiencia individual, la creatividad y los recursos disponibles.
Antes de consultar las soluciones propuestas, te recomendamos intentar resolver el ejercicio por tu cuenta. Una vez completado, podrás comparar tu enfoque con las soluciones sugeridas.
Múltiples soluciones y enfoques
No existe una única solución "correcta" o perfecta para ejercicios. De hecho, te animamos a explorar diferentes enfoques una vez completado un ejercicio: puedes intentarlo con un algoritmo distinto o utilizando otro lenguaje de programación. También puedes compartir y discutir tus soluciones en Mastodon o en Bluesky.
La mayoría de las soluciones propuestas están implementadas en Haskell. Sin embargo, estos ejercicios son una excelente oportunidad para:
- Perfeccionar tus habilidades en tu lenguaje de programación habitual
- Aprender un nuevo lenguaje de programación
- Comparar implementaciones en diferentes lenguajes
Recursos adicionales
Si eres estudiante principiante, especialmente si estás aprendiendo Haskell como primer lenguaje, te recomendamos consultar Programación funcional con Haskell. Este material ha sido la base del primer curso de informática en el Grado en Matemáticas de la Universidad de Sevilla durante muchos años.
Todas las soluciones están disponibles en GitHub como un proyecto con Stack, lo que evita problemas de compatibilidad entre diferentes versiones de las bibliotecas utilizadas.
Puedes suscribirte al canal RSS de este blog en https://jaalonso.github.io/exercitium/rss.xml.
Lista cuadrada
Definir la función
listaCuadrada :: Int -> a -> [a] -> [[a]]
tal que (listaCuadrada n x xs) es una lista de n listas de longitud n formadas con los elementos de xs completada con x, si no xs no tiene suficientes elementos. Por ejemplo,
listaCuadrada 3 7 [0,3,5,2,4] == [[0,3,5],[2,4,7],[7,7,7]] listaCuadrada 3 7 [0..] == [[0,1,2],[3,4,5],[6,7,8]] listaCuadrada 2 'p' "eva" == ["ev","ap"] listaCuadrada 2 'p' ['a'..] == ["ab","cd"]
Nota: Escribir las soluciones en Haskell, en Python y en Common Lisp.
Máximos locales
Un máximo local de una lista es un elemento de la lista que es que su predecesor y que su sucesor en la lista. Por ejemplo, 5 es un máximo local de [3,2,5,3,7,7,1,6,2] ya que es mayor que 2 (su predecesor) y que 3 (su sucesor).
Definir la función
maximosLocales :: Ord a => [a] -> [a]
tal que (maximosLocales xs) es la lista de los máximos locales de la lista xs. Por ejemplo,
maximosLocales [3,2,5,3,7,7,1,6,2] == [5,6] maximosLocales [1..100] == [] maximosLocales "adbpmqexyz" == "dpq"
Nota: Escribir las soluciones en Haskell, en Python y en Common Lisp.
Matrices de Toepliz
Una matriz de Toeplitz es una matriz cuadrada que es constante a lo largo de las diagonales paralelas a la diagonal principal. Por ejemplo,
|2 5 1 6| |2 5 1 6| |4 2 5 1| |4 2 6 1| |7 4 2 5| |7 4 2 5| |9 7 4 2| |9 7 4 2|
la primera es una matriz de Toeplitz y la segunda no lo es.
Las anteriores matrices se pueden definir por
ej1, ej2 :: Array (Int,Int) Int ej1 = listArray ((1,1),(4,4)) [2,5,1,6,4,2,5,1,7,4,2,5,9,7,4,2] ej2 = listArray ((1,1),(4,4)) [2,5,1,6,4,2,6,1,7,4,2,5,9,7,4,2]
Definir la función
esToeplitz :: Eq a => Array (Int,Int) a -> Bool
tal que (esToeplitz p) se verifica si la matriz p es de Toeplitz. Por ejemplo,
esToeplitz ej1 == True esToeplitz ej2 == False
Nota: Escribir las soluciones en Haskell, en Python y en Common Lisp.
Primos equidistantes
Definir la función
primosEquidistantes :: Integer -> [(Integer,Integer)]
tal que (primosEquidistantes k) es la lista de los pares de primos cuya diferencia es k. Por ejemplo,
take 3 (primosEquidistantes 2) == [(3,5),(5,7),(11,13)] take 3 (primosEquidistantes 4) == [(7,11),(13,17),(19,23)] take 3 (primosEquidistantes 6) == [(23,29),(31,37),(47,53)] take 3 (primosEquidistantes 8) == [(89,97),(359,367),(389,397)] primosEquidistantes 4 !! (10^5) == (18467047,18467051)
Nota: Escribir las soluciones en Haskell, en Python y en Common Lisp.
Anagramas
Una palabra es una anagrama de otra si se puede obtener permutando sus letras. Por ejemplo, "mora" y "roma" son anagramas de "amor".
Definir la función
anagramas :: String -> [String] -> [String]
tal que (anagramas x ys) es la lista de los elementos de ys que son anagramas de x. Por ejemplo,
λ> anagramas "amor" ["Roma","mola","loma","moRa", "rama"] ["Roma","moRa"] λ> anagramas "rama" ["aMar","amaRa","roMa","marr","aRma"] ["aMar","aRma"]
Nota: Escribir las soluciones en Haskell, en Python y en Common Lisp.
Diagonales principales
La lista de las diagonales principales de la matriz
1 2 3 4 5 6 7 8 9 10 11 12
es
[[9],[5,10],[1,6,11],[2,7,12],[3,8],[4]]
Definir la función
diagonalesPrincipales :: Array (Int,Int) a -> [[a]]
tal que (diagonalesPrincipales p) es la lista de las diagonales principales de p. Por ejemplo,
λ> diagonalesPrincipales (listArray ((1,1),(3,4)) [1..12]) [[9],[5,10],[1,6,11],[2,7,12],[3,8],[4]]
Nota: Escribir las soluciones en Haskell, en Python y en Common Lisp.
Posiciones de las diagonales principales
Las posiciones de una matriz con 3 filas y 4 columnas son
(1,1) (1,2) (1,3) (1,4) (2,1) (2,2) (2,3) (2,4) (3,1) (3,2) (3,3) (3,4)
Las posiciones de sus 6 diagonales principales son
[(3,1)] [(2,1),(3,2)] [(1,1),(2,2),(3,3)] [(1,2),(2,3),(3,4)] [(1,3),(2,4)] [(1,4)]
Definir la función
posicionesDiagonalesPrincipales :: Int -> Int -> [[(Int, Int)]]
tal que (posicionesdiagonalesprincipales m n) es la lista de las posiciones de las diagonales principales de una matriz con m filas y n columnas. Por ejemplo,
λ> mapM_ print (posicionesDiagonalesPrincipales 3 4) [(3,1)] [(2,1),(3,2)] [(1,1),(2,2),(3,3)] [(1,2),(2,3),(3,4)] [(1,3),(2,4)] [(1,4)] λ> mapM_ print (posicionesDiagonalesPrincipales 4 4) [(4,1)] [(3,1),(4,2)] [(2,1),(3,2),(4,3)] [(1,1),(2,2),(3,3),(4,4)] [(1,2),(2,3),(3,4)] [(1,3),(2,4)] [(1,4)] λ> mapM_ print (posicionesDiagonalesPrincipales 4 3) [(4,1)] [(3,1),(4,2)] [(2,1),(3,2),(4,3)] [(1,1),(2,2),(3,3)] [(1,2),(2,3)] [(1,3)]
Nota: Escribir las soluciones en Haskell, en Python y en Common Lisp.