Un n-grama de una sucesión es una subsucesión contigua de n elementos.
Definir la función
nGramas :: Int -> [a] -> [[a]]
tal que (nGramas k xs) es la lista de los n-gramas de xs de longitud k. Por ejemplo,
nGramas 0 "abcd" == [] nGramas 1 "abcd" == ["a","b","c","d"] nGramas 2 "abcd" == ["ab", "bc", "cd"] nGramas 3 "abcd" == ["abc", "bcd"] nGramas 4 "abcd" == ["abcd"] nGramas 5 "abcd" == []
Definir la función
enteroPositivo :: String -> Maybe Int
tal que (enteroPositivo cs) es justo el contenido de la cadena cs, si dicho contenido es un entero positivo, y Nothing en caso contrario. Por ejemplo,
enteroPositivo "235" == Just 235 enteroPositivo "-235" == Nothing enteroPositivo "23.5" == Nothing enteroPositivo "235 " == Nothing enteroPositivo "cinco" == Nothing enteroPositivo "" == Nothing
Definir la función
filtroBooleano :: [Bool] -> [a] -> [Maybe a]
tal que (filtroBooleano xs ys) es la lista de los elementos de ys tales que el elemento de xs en la misma posición es verdadero. Por ejemplo,
λ> filtroBooleano [True,False,True] "Sevilla" [Just 'S',Nothing,Just 'v'] λ> filtroBooleano (repeat True) "abc" [Just 'a',Just 'b',Just 'c'] λ> take 3 (filtroBooleano (repeat True) [1..]) [Just 1,Just 2,Just 3] λ> take 3 (filtroBooleano (repeat False) [1..]) [Nothing,Nothing,Nothing] λ> take 3 (filtroBooleano (cycle [True,False]) [1..]) [Just 1,Nothing,Just 3]
La sucesión 3n+1 generada por un número entero positivo x es sucesión generada por el siguiente algoritmo: Se empieza con el número x. Si x es par, se divide entre 2. Si x es impar, se multiplica por 3 y se le suma 1. El proceso se repite con el número obtenido hasta que se alcanza el valor 1. Por ejemplo, la sucesión de números generadas cuando se empieza en 22 es
22 11 34 17 52 26 13 40 20 10 5 16 8 4 2 1
Se ha conjeturado (aunque no demostrado) que este algoritmo siempre alcanza el 1 empezando en cualquier entero positivo.
Definir la función
mayorLongitud :: Integer -> Integer -> Integer
tal que (mayorLongitud i j) es el máximo de las longitudes de las sucesiones 3n+1 para todos los números comprendidos entre i y j, ambos inclusives. Por ejemplo,
mayorLongitud 1 10 == 20 mayorLongitud 100 200 == 125 mayorLongitud 201 210 == 89 mayorLongitud 900 1000 == 174
El buscaminas es un juego cuyo objetivo es despejar un campo de minas sin detonar ninguna.
El campo de minas se representa mediante un cuadrado con NxN casillas. Algunas casillas tienen un número, este número indica las minas que hay en todas las casillas vecinas. Cada casilla tiene como máximo 8 vecinas. Por ejemplo, el campo 4x4 de la izquierda contiene dos minas, cada una representada por el número 9, y a la derecha se muestra el campo obtenido anotando las minas vecinas de cada casilla
9 0 0 0 9 1 0 0 0 0 0 0 2 2 1 0 0 9 0 0 1 9 1 0 0 0 0 0 1 1 1 0
de la misma forma, la anotación del siguiente a la izquierda es el de la derecha
9 9 0 0 0 9 9 1 0 0 0 0 0 0 0 3 3 2 0 0 0 9 0 0 0 1 9 1 0 0
Utilizando la librería Data.Matrix, los campos de minas se representan mediante matrices:
type Campo = Matrix Int
Por ejemplo, los anteriores campos de la izquierda se definen por
ejCampo1, ejCampo2 :: Campo ejCampo1 = fromLists [[9,0,0,0], [0,0,0,0], [0,9,0,0], [0,0,0,0]] ejCampo2 = fromLists [[9,9,0,0,0], [0,0,0,0,0], [0,9,0,0,0]]
Definir la función
buscaminas :: Campo -> Campo
tal que buscaminas c es el campo obtenido anotando las minas vecinas de cada casilla. Por ejemplo,
λ> buscaminas ejCampo1 ( 9 1 0 0 ) ( 2 2 1 0 ) ( 1 9 1 0 ) ( 1 1 1 0 ) λ> buscaminas ejCampo2 ( 9 9 1 0 0 ) ( 3 3 2 0 0 ) ( 1 9 1 0 0 )
Definir la función
seleccionConFallo :: (a -> Bool) -> [a] -> [a]
tal que (seleccionConFallo p xs) es la lista de los elementos de xs que cumplen el predicado p hasta el primero que no lo cumple inclusive. Por ejemplo,
seleccionConFallo (<5) [3,2,5,7,1,0] == [3,2,5] seleccionConFallo odd [1..4] == [1,2] seleccionConFallo odd [1,3,5] == [1,3,5] seleccionConFallo (<5) [10..20] == [10]
Definir la función
sumas :: (Num a, Ord a) => Int -> [a] -> a -> [[a]]
tal que (sumas n ys x) es la lista de las descomposiciones de x como sumas de n sumandos en la lista ys. Por ejemplo,
sumas 2 [1,2] 3 == [[1,2]] sumas 2 [-1] (-2) == [[-1,-1]] sumas 2 [-1,3,-1] 2 == [[-1,3]] sumas 2 [1,2] 4 == [[2,2]] sumas 2 [1,2] 5 == [] sumas 3 [1,2] 5 == [[1,2,2]] sumas 3 [1,2] 6 == [[2,2,2]] sumas 2 [1,2,5] 6 == [[1,5]] sumas 2 [1,2,3,5] 4 == [[1,3],[2,2]] sumas 2 [1..5] 6 == [[1,5],[2,4],[3,3]] sumas 3 [1..5] 7 == [[1,1,5],[1,2,4],[1,3,3],[2,2,3]] sumas 3 [1..200] 4 == [[1,1,2]]
Definir la función
divisoresConFinal :: Integer -> Integer -> [Integer]
tal que (divisoresConFinal n m) es la lista de los divisores de n cuyos dígitos finales coincide con m. Por ejemplo,
divisoresConFinal 84 4 == [4,14,84] divisoresConFinal 720 20 == [20,120,720]
La órbita prima de un número n es la sucesión construida de la siguiente forma:
n es compuesto su órbita no tiene elementosn es primo, entonces n está en su órbita; además, sumamos n y sus dígitos, si el resultado es un número primo repetimos el proceso hasta obtener un número compuesto.Por ejemplo, con el 11 podemos repetir el proceso dos veces
13 = 11+1+1 17 = 13+1+3 25 = 17+1+7
Así, la órbita prima de 11 es 11, 13, 17.
Definir la función
orbita :: Integer -> [Integer]
tal que (orbita n) es la órbita prima de n. Por ejemplo,
orbita 11 == [11,13,17] orbita 59 == [59,73,83]
Calcular el menor número cuya órbita prima tiene más de 3 elementos.
Se dice que una sucesión x(1), ..., x(n) está ordenada cíclicamente si existe un índice i tal que la sucesión
x(i), x(i+1), ..., x(n), x(1), ..., x(i-1)
está ordenada creciente de forma estricta.
Definir la función
ordenadaCiclicamente :: Ord a => [a] -> Maybe Int
tal que (ordenadaCiclicamente xs) es el índice a partir del cual está ordenada, si la lista está ordenado cíclicamente y Nothing en caso contrario. Por ejemplo,
ordenadaCiclicamente [1,2,3,4] == Just 0 ordenadaCiclicamente [5,8,1,3] == Just 2 ordenadaCiclicamente [4,6,7,5,1,3] == Nothing ordenadaCiclicamente [1,0,3,2] == Nothing ordenadaCiclicamente [1,2,0] == Just 2 ordenadaCiclicamente "cdeab" == Just 3
Nota: Se supone que el argumento es una lista no vacía sin elementos repetidos.