Relación 23

-- I1M 2021-22: Relación 23
-- Combinatoria
-- Departamento de Ciencias de la Computación e Inteligencia Artificial
-- Universidad de Sevilla
-- ============================================================================

-- ============================================================================
-- Subconjuntos
-- ============================================================================

-- ----------------------------------------------------------------------------
-- Ejercicio 1. Definir la función
--   subconjuntos :: [a] -> [[a]]
-- tal que '(subconjuntos xs)' es la lista de las subconjuntos de la lista
-- 'xs'. Por ejemplo,
--   subconjuntos [2,3,4]    ==
--     [[2,3,4],[2,3],[2,4],[2],[3,4],[3],[4],[]]
--   subconjuntos [1,2,3,4]  ==
--     [[1,2,3,4],[1,2,3],[1,2,4],[1,2],[1,3,4],[1,3],[1,4],[1],
--      [2,3,4],  [2,3],  [2,4],  [2],  [3,4],  [3],  [4], []]
-- ----------------------------------------------------------------------------
--Daniel Cebrián Castillo
subconjuntos :: [a] -> [[a]]
subconjuntos xs | null xs = [[]]
                | otherwise = map ([xs!!0]++) (subconjuntos(tail xs)) ++ subconjuntos (tail xs)

-- ============================================================================
-- Permutaciones
-- ============================================================================

-- ----------------------------------------------------------------------------
-- Ejercicio 2. Definir la función
--   intercala :: a -> [a] -> [[a]]
-- tal que '(intercala x ys)' es la lista de las listas obtenidas intercalando
-- el elemento 'x' entre los elementos de la lista 'ys'. Por ejemplo,
--   intercala 1 [2,3]  ==  [[1,2,3],[2,1,3],[2,3,1]]
-- ----------------------------------------------------------------------------

--Daniel Cebrián Castillo
intercala :: a -> [a] -> [[a]]
intercala i xs = [ take n xs ++ [i] ++ drop n xs | n<-[0..length xs]]


-- ----------------------------------------------------------------------------
-- Ejercicio 3. Definir la función
--   permutaciones :: [a] -> [[a]]
-- tal que '(permutaciones xs)' es la lista de las permutaciones de la lista
-- 'xs'. Por ejemplo,
--   permutaciones "bc"   ==  ["bc","cb"]
--   permutaciones "abc"  ==  ["abc","bac","bca","acb","cab","cba"]
-- ----------------------------------------------------------------------------

--Daniel Cebrián Castillo
permutaciones :: [a] -> [[a]]
permutaciones [] = [[]]
permutaciones (x:xs) = concat[(intercala x p) |p<-permutaciones xs ] 

-- ----------------------------------------------------------------------------
-- Ejercicio 4. Definir la función
--   permutacionesN :: Integer -> [[Integer]]
-- tal que '(permutacionesN n)' es la lista de las permutaciones de los 'n'
-- primeros números naturales positivos. Por ejemplo,
--   permutacionesN 3  ==  [[1,2,3],[2,1,3],[2,3,1],[1,3,2],[3,1,2],[3,2,1]]
-- ----------------------------------------------------------------------------

--Daniel Cebrián Castillo
permutacionesN :: Integer -> [[Integer]]
permutacionesN n = permutaciones [ j | j<-[1..n]]

-- ----------------------------------------------------------------------------
-- Ejercicio 5. Definir la función
--   numeroPermutacionesL :: Integer -> Integer
-- tal que '(numeroPermutacionesL n)' es el número de permutaciones de un
-- conjunto con 'n' elementos, calculado usando la función 'permutacionesN'.
-- Por ejemplo,
--   numeroPermutacionesL 3  ==  6
--   numeroPermutacionesL 4  ==  24
-- ----------------------------------------------------------------------------

--Daniel Cebrián Castillo
numeroPermutacionesL :: Integer -> Integer
numeroPermutacionesL n = fromIntegral (length (permutacionesN n))

-- ----------------------------------------------------------------------------
-- Ejercicio 6. Definir la función
--   numeroPermutacionesF :: Integer -> Integer
-- tal que '(numeroPermutacionesF n)' es el número de permutaciones de un
-- conjunto con 'n' elementos, calculado usando la fórmula
--   P(n) = n!
-- Por ejemplo,
--   numeroPermutacionesF 3  ==  6
--   numeroPermutacionesF 4  ==  24
-- ----------------------------------------------------------------------------

--Daniel Cebrián Castillo
numeroPermutacionesF :: Integer -> Integer
numeroPermutacionesF 0 = 1
numeroPermutacionesF n =  n*numeroPermutacionesF (n-1)

-- ----------------------------------------------------------------------------
-- Ejercicio 7. Definir la función
--   prop_numeroPermutaciones :: Integer -> Bool
-- tal que '(prop_numeroPermutaciones n)' se verifica si las funciones
-- 'numeroPermutacionesL' y 'numeroPermutacionesF' son equivalentes para los
-- desde 1 hasta n. Por ejemplo,
--   prop_numeroPermutaciones 5  ==  True
-- ----------------------------------------------------------------------------

--Daniel Cebrián Castillo
prop_numeroPermutaciones :: Integer -> Bool
prop_numeroPermutaciones n = numeroPermutacionesF n == numeroPermutacionesL n

-- ============================================================================
-- Permutaciones con repetición
-- ============================================================================

-- ----------------------------------------------------------------------------
-- Ejercicio 8. Definir la función
--   intercalaRep :: (Eq a) => a -> [a] -> [[a]]
-- tal que '(intercalaRep x ys)' es la lista de las listas obtenidas
-- intercalando el elemento 'x' entre los elementos de la lista 'ys', hasta la
-- primera ocurrencia del elemento 'x' en 'ys'. Por ejemplo,
--   intercalaRep 1 [1,2,1]  ==  [[1,1,2,1]]
--   intercalaRep 1 [2,1,1]  ==  [[1,2,1,1],[2,1,1,1]]
--   intercalaRep 1 [2,2,1]  ==  [[1,2,2,1],[2,1,2,1],[2,2,1,1]]
-- ----------------------------------------------------------------------------

--Daniel Cebrián Castillo
--fstaparcion es una función que devuelve la primera aparición de un elemento en un conjunto
fstaparicion :: (Eq a)=> a -> [a] -> Int
fstaparicion i xs = length xs - length (dropWhile (i/=) xs)

intercalaRep :: (Eq a) => a -> [a] -> [[a]]
intercalaRep i xs = [ take n xs ++ [i] ++ drop n xs | n<-[0..ii]]
  where ii = fstaparicion i xs

-- ----------------------------------------------------------------------------
-- Ejercicio 9. Definir la función
--   permutacionesRep :: (Eq a) => [a] -> [[a]]
-- tal que '(permutacionesRep xs)' es la lista (sin elementos repetidos) de
-- las permutaciones con repetición de la lista 'xs'. Por ejemplo,
--   permutacionesRep "aba"   ==  ["aba","baa","aab"]
--   permutacionesRep "abab"  ==  ["abab","baab","aabb","abba","baba","bbaa"]
-- ----------------------------------------------------------------------------

--Daniel Cebrián Castillo
permutacionesRep :: (Eq a) => [a] -> [[a]]
permutacionesRep [] =[[]]
permutacionesRep (x:xs) = concat [ intercalaRep x p |p<- permutacionesRep xs]


-- ----------------------------------------------------------------------------
-- Ejercicio 10. Definir la función
--   permutacionesRepN :: Integer -> Integer -> [[Integer]]
-- tal que '(permutacionesRepN n k)' es la lista de las permutaciones con
-- repetición de los 'n' primeros números naturales positivos con 'k'
-- repeticiones de cada uno de ellos. Por ejemplo,
--   permutacionesRepN 2 2  ==
--     [[1,2,1,2],[2,1,1,2],[1,1,2,2],[1,2,2,1],[2,1,2,1],[2,2,1,1]]
-- ----------------------------------------------------------------------------

--Daniel Cebrián Castillo
permutacionesRepN :: Integer -> Integer -> [[Integer]]
permutacionesRepN n k = permutacionesRep (concat [replicate (fromInteger k) t | t<-[1..n]])

-- ----------------------------------------------------------------------------
-- Ejercicio 11. Definir la función
--   numeroPermutacionesRepL :: Integer -> Integer -> Integer
-- tal que '(numeroPermutacionesRepL n k)' es el número de permutaciones con
-- repetición de un conjunto con 'k*n' elementos, donde cada uno de ellos se
-- repite 'k' veces, calculado usando la función 'permutacionesRepN'. Por
-- ejemplo,
--   numeroPermutacionesRepL 2 2  ==  6
--   numeroPermutacionesRepL 2 3  ==  20
--   numeroPermutacionesRepL 3 2  ==  90
-- ----------------------------------------------------------------------------

--Daniel Cebrián Castillo
numeroPermutacionesRepL :: Integer -> Integer -> Integer
numeroPermutacionesRepL n k= fromIntegral (length (permutacionesRepN n k))

-- ----------------------------------------------------------------------------
-- Ejercicio 12. Definir la función
--   numeroPermutacionesRepF :: Integer -> Integer -> Integer
-- tal que '(numeroPermutacionesRepF n k)' es el número de permutaciones con
-- repetición de un conjunto con 'k*n' elementos, donde cada uno de ellos se
-- repite 'k' veces, calculado usando la fórmula
--                                n!
--   PR(n,[a,b,c,...]) = --------------------
--                        a! * b! * c! * ...
-- Por ejemplo,
--   numeroPermutacionesRepF 2 2  ==  6
--   numeroPermutacionesRepF 2 3  ==  20
--   numeroPermutacionesRepF 3 2  ==  90
-- ----------------------------------------------------------------------------

--Daniel Cebrián Castillo
numeroPermutacionesRepF :: Integer -> Integer -> Integer
numeroPermutacionesRepF n k = div (numeroPermutacionesF (k*n)) ((numeroPermutacionesF k)^n) 

-- ----------------------------------------------------------------------------
-- Ejercicio 13. Definir la función
--   prop_numeroPermutacionesRep :: Integer -> Bool
-- tal que '(prop_numeroPermutacionesRep n)' se verifica si las funciones
-- 'numeroPermutacionesRepL' y 'numeroPermutacionesRepF' son equivalentes para
-- los 'n' primeros números naturales positivos y para todo 'k' entre 1 y 'n'.
-- Por ejemplo,
--   prop_numeroPermutacionesRep 3  ==  True
-- ----------------------------------------------------------------------------

--Daniel Cebrián Castillo
prop_numeroPermutacionesRep :: Integer -> Bool
prop_numeroPermutacionesRep n = and [ numeroPermutacionesRepF n k == numeroPermutacionesRepL n k | k<-[1..n]]

-- ============================================================================
-- Combinaciones
-- ============================================================================

-- ----------------------------------------------------------------------------
-- Ejercicio 14. Definir la función
--   combinaciones :: Integer -> [a] -> [[a]]
-- tal que '(combinaciones k xs)' es la lista de las combinaciones de orden 'k'
-- de los elementos de la lista 'xs'. Por ejemplo,
--   combinaciones 2 "bcde"   ==  ["bc","bd","be","cd","ce","de"]
--   combinaciones 3 "bcde"   ==  ["bcd","bce","bde","cde"]
--   combinaciones 3 "abcde"  ==
--     ["abc","abd","abe","acd","ace","ade","bcd","bce","bde","cde"]
-- ----------------------------------------------------------------------------

--Daniel Cebrián Castillo
combinaciones :: Integer -> [a] -> [[a]]
combinaciones n xs = filter (\ xs -> length xs == fromIntegral n) (subconjuntos xs)

-- ----------------------------------------------------------------------------
-- Ejercicio 15. Definir la función
--   combinacionesN :: Integer -> Integer -> [[Integer]]
-- tal que '(combinacionesN k n)' es la lista de las combinaciones de orden 'k'
-- de los 'n' primeros números naturales positivos. Por ejemplo,
--   combinacionesN 2 4  ==  [[1,2],[1,3],[1,4],[2,3],[2,4],[3,4]]
--   combinacionesN 3 4  ==  [[1,2,3],[1,2,4],[1,3,4],[2,3,4]]
-- ----------------------------------------------------------------------------

--Daniel Cebrián Castillo
combinacionesN :: Integer -> Integer -> [[Integer]]
combinacionesN k n = combinaciones k [1..n] 

-- ----------------------------------------------------------------------------
-- Ejercicio 16. Definir la función
--   numeroCombinacionesL :: Integer -> Integer -> Integer
-- tal que '(numeroCombinacionesL k n)' es el número de combinaciones de orden
-- 'k' de un conjunto con 'n' elementos, calculado usando la función
-- 'combinacionesN'. Por ejemplo,
--   numeroCombinacionesL 2 4  ==  6
--   numeroCombinacionesL 3 4  ==  4
-- ----------------------------------------------------------------------------

--Daniel Cebrián Castillo
numeroCombinacionesL :: Integer -> Integer -> Integer
numeroCombinacionesL n k = fromIntegral (length (combinacionesN n k))

-- ----------------------------------------------------------------------------
-- Ejercicio 17. Definir la función 'comb' tal que '(comb n k)' es el número
-- combinatorio 'n' sobre 'k'; es decir, (comb n k) = n! / (k!(n-k)!). Por
-- ejemplo,
--   comb 4 2  ==  6
--   comb 4 3  ==  4
-- ----------------------------------------------------------------------------

--Daniel Cebrián Castillo
comb :: Integer -> Integer -> Integer
comb n k = div (numeroPermutacionesF n) ((numeroPermutacionesF (n-k))*(numeroPermutacionesF k))

-- ----------------------------------------------------------------------------
-- Ejercicio 18. Definir la función
--   numeroCombinacionesF :: Integer -> Integer -> Integer
-- tal que '(numeroCombinacionesF k n)' es el número de combinaciones de orden
-- 'k' de un conjunto con 'n' elementos, calculado usando la fórmula
--            / n \         n!
--   C(n,k) = |   | = -------------
--            \ k /    k! * (n-k)!
-- Por ejemplo,
--   numeroCombinacionesF 2 4  ==  6
--   numeroCombinacionesF 3 4  ==  4
-- ----------------------------------------------------------------------------

--Daniel Cebrián Castillo
numeroCombinacionesF :: Integer -> Integer -> Integer
numeroCombinacionesF n k = comb n k

-- ----------------------------------------------------------------------------
-- Ejercicio 19. Definir la función
--   prop_numeroCombinaciones :: Integer -> Bool
-- tal que '(prop_numeroCombinaciones n)' se verifica si las funciones
-- 'numeroCombinaciones' y 'numeroCombinacionesC' son equivalentes para los 'n'
-- primeros números naturales positivos y para todo 'k' entre 1 y 'n'. Por
-- ejemplo,
--   prop_numeroCombinaciones 5  ==  True
-- ----------------------------------------------------------------------------

--Daniel Cebrián Castillo
prop_numeroCombinaciones :: Integer -> Bool
prop_numeroCombinaciones n = and [numeroCombinacionesF n k == numeroCombinacionesL n k | k<-[1..n]]

-- ============================================================================
-- Combinaciones con repetición
-- ============================================================================

-- ----------------------------------------------------------------------------
-- Ejercicio 20. Definir la función
--   combinacionesRep :: Integer -> [a] -> [[a]]
-- tal que '(combinacionesRep k xs)' es la lista de las combinaciones con
-- repetición de orden 'k' de los elementos de la lista 'xs'. Por ejemplo,
--   combinacionesRep 2 "abc"  ==  ["aa","ab","ac","bb","bc","cc"]
--   combinacionesRep 3 "bc"   ==  ["bbb","bbc","bcc","ccc"]
--   combinacionesRep 3 "abc"  ==
--     ["aaa","aab","aac","abb","abc","acc","bbb","bbc","bcc","ccc"]
-- ----------------------------------------------------------------------------

--Daniel Cebrián Castillo
factorial :: Integer -> Integer
factorial 0 = 1
factorial n = n*factorial (n-1)

combinacionesRep :: Integer -> [a] -> [[a]]
combinacionesRep 0 xs = combinaciones 0 xs
combinacionesRep 1 xs = combinaciones 1 xs
combinacionesRep n xs =  concat[map([xs!!k]++) (combinacionesRep (n-1) (drop k xs)) | k<-[0..(length xs) -1]] 

-- ----------------------------------------------------------------------------
-- Ejercicio 21. Definir la función
--   combinacionesRepN :: Integer -> Integer -> [[Integer]]
-- tal que '(combinacionesRepN k n)' es la lista de las combinaciones con
-- repetición de orden 'k' de los 'n' primeros números naturales positivos. Por
-- ejemplo,
--   combinacionesRepN 2 3  ==  [[1,1],[1,2],[1,3],[2,2],[2,3],[3,3]]
--   combinacionesRepN 3 2  ==  [[1,1,1],[1,1,2],[1,2,2],[2,2,2]]
-- ----------------------------------------------------------------------------

--Daniel Cebrián Castillo
combinacionesRepN :: Integer -> Integer -> [[Integer]]
combinacionesRepN k n= combinacionesRep k [1..n] 

-- ----------------------------------------------------------------------------
-- Ejercicio 22. Definir la función
--   numeroCombinacionesRepL :: Integer -> Integer -> Integer
-- tal que '(numeroCombinacionesRepL k n)' es el número de combinaciones con
-- repetición de orden 'k' de un conjunto con 'n' elementos, calculado usando
-- la función 'combinacionesRepN'. Por ejemplo,
--   numeroCombinacionesRepL 2 3  ==  6
--   numeroCombinacionesRepL 3 2  ==  4
-- ----------------------------------------------------------------------------

--Daniel Cebrián Castillo
numeroCombinacionesRepL :: Integer -> Integer -> Integer
numeroCombinacionesRepL k n = fromIntegral (length (combinacionesRepN k n))

-- ----------------------------------------------------------------------------
-- Ejercicio 23. Definir la función
--   numeroCombinacionesRepF :: Integer -> Integer -> Integer
-- tal que '(numeroCombinacionesRepF k n)' es el número de combinaciones con
-- repetición de orden 'k' de un conjunto con 'n' elementos, calculado usando
-- la fórmula
--             / n+k-1 \     (n+k-1)!
--   CR(n,k) = |       | = -------------
--             \   k   /    k! * (n-1)!
-- Por ejemplo,
--   numeroCombinacionesRepF 2 3  ==  6
--   numeroCombinacionesRepF 3 2  ==  4
-- ----------------------------------------------------------------------------

--Daniel Cebrián Castillo
numeroCombinacionesRepF :: Integer -> Integer -> Integer
numeroCombinacionesRepF k n = div (factorial (n+k-1)) ((factorial k)*(factorial (n-1)))

-- ----------------------------------------------------------------------------
-- Ejercicio 24. Definir la función
--   prop_numeroCombinacionesRep :: Integer -> Bool
-- tal que '(prop_numeroCombinacioneRep n)' se verifica si las funciones
-- 'numeroCombinacionesRepL' y 'numeroCombinacionesRepF' son equivalentes para
-- los 'n' primeros números naturales positivos y para todo 'k' entre 1 y 'n'.
-- Por ejemplo,
--   prop_numeroCombinacionesRep 5  ==  True
-- ----------------------------------------------------------------------------

--Daniel Cebrián Castillo
prop_numeroCombinacionesRep :: Integer -> Bool
prop_numeroCombinacionesRep n = and [numeroCombinacionesRepF n k == numeroCombinacionesRepL n k | k<-[1..n]]

-- ============================================================================
-- Variaciones
-- ============================================================================

-- ----------------------------------------------------------------------------
-- Ejercicio 25. Definir la función
--   variaciones :: Integer -> [a] -> [[a]]
-- tal que '(variaciones k xs)' es la lista de las variaciones de orden 'k' de
-- los elementos de la lista 'xs'. Por ejemplo,
--   variaciones 2 "abc"  ==  ["ab","ba","ac","ca","bc","cb"]
-- ----------------------------------------------------------------------------

--Daniel Cebrián Castillo
variaciones :: Integer -> [a] -> [[a]]
variaciones k xs = concat [permutaciones c | c<-(combinaciones k xs)]

-- ----------------------------------------------------------------------------
-- Ejercicio 26. Definir la función
--   variacionesN :: Integer -> Integer -> [[Integer]]
-- tal que '(variacionesN k n)' es la lista de las variaciones de orden 'k' de
-- los 'n' primeros números naturales positivos. Por ejemplo,
--   variacionesN 2 3  ==  [[1,2],[2,1],[1,3],[3,1],[2,3],[3,2]]
-- ----------------------------------------------------------------------------

--Daniel Cebrián Castillo
variacionesN :: Integer -> Integer -> [[Integer]]
variacionesN k n = variaciones k [1..n]

-- ----------------------------------------------------------------------------
-- Ejercicio 27. Definir la función
--   numeroVariacionesL :: Integer -> Integer -> Integer
-- tal que '(numeroVariacionesL k n)' es el número de variaciones de orden 'k'
-- de un conjunto con 'n' elementos, calculado usando la función
-- 'variacionesN'. Por ejemplo,
--   numeroVariacionesL 2 4  ==  12
--   numeroVariacionesL 3 4  ==  24
-- ----------------------------------------------------------------------------

--Daniel Cebrián Castillo
numeroVariacionesL :: Integer -> Integer -> Integer
numeroVariacionesL k n = fromIntegral (length (variacionesN k n))

-- ----------------------------------------------------------------------------
-- Ejercicio 28. Definir la función
--   numeroVariacionesF :: Integer -> Integer -> Integer
-- tal que '(numeroVariacionesF k n)' es el número de variaciones de orden 'k'
-- de un conjunto con 'n' elementos, calculado usando la fórmula
--               n!
--   V(n,k) = --------
--             (n-k)!
-- Por ejemplo,
--   numeroVariacionesF 2 4  ==  12
--   numeroVariacionesF 3 4  ==  24
-- ----------------------------------------------------------------------------

--Daniel Cebrián Castillo
numeroVariacionesF :: Integer -> Integer -> Integer
numeroVariacionesF k n = div (factorial n) (factorial (n-k))

-- ----------------------------------------------------------------------------
-- Ejercicio 29. Definir la función
--   prop_numeroVariaciones :: Integer -> Bool
-- tal que '(prop_numeroVariaciones n)' se verifica si las funciones
-- 'numeroVariacionesL' y 'numeroVariacionesF' son equivalentes para los 'n'
-- primeros números naturales positivos y para todo 'k' entre 1 y 'n'. Por
-- ejemplo,
--   prop_numeroVariaciones 5  ==  True
-- ----------------------------------------------------------------------------

--Daniel Cebrián Castillo
prop_numeroVariaciones :: Integer -> Bool
prop_numeroVariaciones n = and [numeroVariacionesF k n == numeroVariacionesL k n | k<-[1..n]]

-- ============================================================================
-- Variaciones con repetición
-- ============================================================================

-- ----------------------------------------------------------------------------
-- Ejercicio 30. Definir la función
--   variacionesRep :: Integer -> [a] -> [[a]]
-- tal que '(variacionesRep k xs)' es la lista de las variaciones con
-- repetición de orden 'k' de los elementos de la lista 'xs'. Por ejemplo,
--   variacionesRep 1 "ab"  ==  ["a","b"]
--   variacionesRep 2 "ab"  ==  ["aa","ab","ba","bb"]
--   variacionesRep 3 "ab"  ==
--     ["aaa","aab","aba","abb","baa","bab","bba","bbb"]
-- ----------------------------------------------------------------------------

--Daniel Cebrián Castillo
variacionesRep :: Integer -> [a] -> [[a]]
variacionesRep k xs = concat (map (permutacionesRep) (combinacionesRep k xs))

-- ----------------------------------------------------------------------------
-- Ejercicio 31. Definir la función
--   variacionesRepN :: Integer -> Integer -> [[Integer]]
-- tal que '(variacionesRepN k n)' es la lista de las variaciones con
-- repetición de orden 'k' de los 'n' primeros números naturales positivos. Por
-- ejemplo,
--   variacionesRepN 2 3  ==
--     [[1,1],[1,2],[1,3],[2,1],[2,2],[2,3],[3,1],[3,2],[3,3]]
--   variacionesRepN 3 2  ==
--     [[1,1,1],[1,1,2],[1,2,1],[1,2,2],[2,1,1],[2,1,2],[2,2,1],[2,2,2]]
-- ----------------------------------------------------------------------------

--Daniel Cebrián Castillo
variacionesRepN :: Integer -> Integer -> [[Integer]]
variacionesRepN k n= variacionesRep k [1..n]

-- ----------------------------------------------------------------------------
-- Ejercicio 32. Definir la función
--   numeroVariacionesRepL :: Integer -> Integer -> Integer
-- tal que '(numeroVariacionesRepL k n)' es el número de variaciones con
-- repetición de orden 'k' de un conjunto con 'n' elementos, calculado usando
-- la función 'variacionesRepN'. Por ejemplo,
--   numeroVariacionesRepL 2 3  ==  9
--   numeroVariacionesRepL 3 2  ==  8
-- ----------------------------------------------------------------------------

--Daniel Cebrián Castillo
numeroVariacionesRepL :: Integer -> Integer -> Integer
numeroVariacionesRepL k n = fromIntegral(length (variacionesRepN k n))

-- ----------------------------------------------------------------------------
-- Ejercicio 33. Definir la función
--   numeroVariacionesRepF :: Integer -> Integer -> Integer
-- tal que '(numeroVariacionesRepF k n)' es el número de variaciones con
-- repetición de orden 'k' de un conjunto con 'n' elementos, calculado usando
-- la fórmula
--   VR(n,k) = n^k
-- Por ejemplo,
--   numeroVariacionesRepF 2 3  ==  9
--   numeroVariacionesRepF 3 2  ==  8
-- ----------------------------------------------------------------------------

--Daniel Cebrián Castillo
numeroVariacionesRepF :: Integer -> Integer -> Integer
numeroVariacionesRepF k n = n^k

-- ----------------------------------------------------------------------------
-- Ejercicio 34. Definir la función
--   prop_numeroVariacionesRep :: Integer -> Bool
-- tal que '(prop_numeroVariacionesRep n)' se verifica si las funciones
-- 'numeroVariacionesRepL' y 'numeroVariacionesRepF' son equivalentes para los
-- 'n' primeros números naturales positivos y para todo 'k' entre 1 y 'n'. Por
-- ejemplo,
--   prop_numeroVariacionesRep 5  ==  True
-- ----------------------------------------------------------------------------

--Daniel Cebrián Castillo
prop_numeroVariacionesRep :: Integer -> Bool
prop_numeroVariacionesRep n = and [numeroVariacionesRepL k n == numeroVariacionesRepF k n | k<-[1..n]]

-- ============================================================================