Parcial 1

-- -----------------------------------------------------------------------------
-- Informática de 1º de Grado en Matemáticas. Grupo 2.
-- Examen 1 de evaluación alternativa (12 de noviembre 2021).
-- -----------------------------------------------------------------------------

import Test.QuickCheck
import Data.Char

-- -----------------------------------------------------------------------------
-- Ejercicio 1.1. Un número imparitario es aquel que tiene una cantidad impar
-- de cifras pares y una cantidad par de cifras impares. Por ejemplo, 235 es
-- imparitario porque tiene 1 par (el 2) y 2 impares (el 3 y 5). De igual forma,
-- 101, 103, 105, 107, 291, 14238 y 1106871 son imparitarios, mientras que 21,
-- 2468 y 11258 no lo son.
--
-- Define la función (numeroImparitario n), tal que indique si un número n
-- es imparitario. Por ejemplo,
--   λ> numeroImparitario 103      == True
--   λ> numeroImparitario 291      == True
--   λ> numeroImparitario 1106871  == True
--   λ> numeroImparitario 21       == False
--   λ> numeroImparitario 2468     == False
--   λ> numeroImparitario 11358    == True
--   λ> numeroImparitario 11258    == False
-- -----------------------------------------------------------------------------

numeroImparitario :: Integer -> Bool
numeroImparitario n = undefined

-- -----------------------------------------------------------------------------
-- Ejercicio 1.2. Comprueba con QuickCheck que si n es un número positivo
-- de más de tres cifras e imparitario, m también es imparitario, donde
-- m es n+3, si la última cifra de n es 8 o 9, o n+2, en otro caso. Por ejemplo,
-- son imparitarios 291 y 291+2=293, 299 y 299+3=301, y 358 y 358+3=361.
-- -----------------------------------------------------------------------------

prop_imparitario :: Integer -> Property
prop_imparitario n = undefined

-- -----------------------------------------------------------------------------


-- -----------------------------------------------------------------------------
-- Ejercicio 2. Representaremos la agenda de nuestras asignaturas como sigue:
-- una lista de tuplas con primera componente el nombre abreviado de la
-- asignatura, y segunda componente una lista de ternas, donde cada
-- terna indica un día y un rago de horario representado como un entero (por
-- ejemplo, 900 es 9:00, 1130 es 11:30, etc.)

agenda :: [(String,[(String,Int,Int)])]
agenda = [ ("Inf",[("Mie",900,1100),("Vie",900,1100)]),
           ("Alg",[("Mie",1130,1330),("Ju",1130,1330)]),
           ("Fis",[("Lu",900,1100),("Mar",900,1100)]),
           ("Cal",[("Lu",1130,1330),("Ju",900,1100)]),
           ("Est",[("Mar",1130,1330),("Vie",900,1100)]) ]

-- Define la función (asignatura ds h as), tal que devuelva la lista de
-- asignaturas donde debemos estar el día ds a las h horas, según la agenda
-- as. Si estamos en el descanso o no hay asignaturas, devolver la lista
-- vacía. El nombre abreviado del día a buscar no debe diferenciar entre
-- minúsculas y mayúsculas (es decir, "lu" es igual que "Lu"). Por ejemplo,
--    λ> asignatura "Lu" 930 agenda
--       ["Fis"]
--    λ> asignatura "lu" 945 agenda
--       ["Fis"]
--    λ> asignatura "Vie" 930 agenda
--       ["Inf","Est"]
--    λ> asignatura "Mar" 1115 agenda
--       []
-- -----------------------------------------------------------------------------

asignatura :: String -> Int -> [(String,[(String,Int,Int)])] -> [String]
asignatura ds h as = undefined

-- -----------------------------------------------------------------------------


-- -----------------------------------------------------------------------------
-- Ejercicio 3. Dos vectores son más compatibles cuanto mayor sea su producto
-- escalar (hasta llegar a ser paralelos). Representaremos los vectores como
-- listas de números. Define la función (masCompatibles xs yss), tal que dado
-- un vector xs y una lista de vectores yss, devuelva la lista de los vectores
-- más compatibles de yss respecto de xs. Por ejemplo
--   λ> masCompatibles [1,0,1] [[0,1,0], [2,3,1], [-1,7,1],[3,1,0]]
--      [[2,3,1],[3,1,0]]
--   λ> masCompatibles [1,0,1] [[0,1,0], [2,3,1], [-1,7,1],[4,-1,4]]
--      [[4,-1,4]]
-- -----------------------------------------------------------------------------

masCompatibles :: (Ord a,Num a) => [a] -> [[a]] -> [[a]]
masCompatibles xs yss = undefined

-- -----------------------------------------------------------------------------


-- -----------------------------------------------------------------------------
-- Ejercicio 4.1 Definir, por comprensión, la función (coincidenciasC k xs ys),
-- tal que verifique si las listas xs e ys coinciden en, al menos, k de sus
-- posiciones. Por ejemplo,
--    λ> coincidenciasC 7 "salamanca" "salamandra"  ==  True
--    λ> coincidenciasC 2 [1,2,3,4,5] [1,3,3,8,1]   ==  True
--    λ> coincidenciasC 4 "almendra" "almazara"     ==  True
--    λ> coincidenciasC 6 "almendra" "almazara"     ==  False
-- -----------------------------------------------------------------------------

coincidenciasC :: Eq a => Int -> [a] -> [a] -> Bool
coincidenciasC = undefined

-- -----------------------------------------------------------------------------
-- Ejercicio 4.2 Definir, por recursión, la función (coincidencias k xs ys),
-- tal que verifique si las listas xs e ys coinciden en, al menos, k de sus
-- posiciones. Por ejemplo,
--    λ> coincidenciasR 7 "salamanca" "salamandra"  ==  True
--    λ> coincidenciasR 2 [1,2,3,4,5] [1,3,3,8,1]   ==  True
--    λ> coincidenciasR 4 "almendra" "almazara"     ==  True
--    λ> coincidenciasR 6 "almendra" "almazara"     ==  False
-- -----------------------------------------------------------------------------

coincidenciasR :: Eq a => Int -> [a] -> [a] -> Bool
coincidenciasR = undefined

-- -----------------------------------------------------------------------------