I1M2012: Ejercicios de definiciones por comprensión (5)

En la clase de hoy del curso Informática (de 1º de Grado en Matemáticas) se han comentado las soluciones de los ejercicios 3 a 8 de la 5ª relación sobre definiciones por comprensión.

Los ejercicios y sus soluciones se muestran a continuación

-- ---------------------------------------------------------------------
-- Ejercicio 3. El producto escalar de dos listas de enteros xs y ys de
-- longitud n viene dado por la suma de los productos de los elementos
-- correspondientes. 
-- 
-- Definir por comprensión la función 
--    productoEscalar :: [Int] -> [Int] -> Int
-- tal que (productoEscalar xs ys) es el producto escalar de las listas
-- xs e ys. Por ejemplo,
--    productoEscalar [1,2,3] [4,5,6]  ==  32
-- ---------------------------------------------------------------------

productoEscalar :: [Int] -> [Int] -> Int
productoEscalar xs ys = sum [x*y | (x,y) <- zip xs ys]

-- ---------------------------------------------------------------------
-- Ejercicio 4. Definir, por comprensión, la función
--    sumaConsecutivos :: [Int] -> [Int]
-- tal que (sumaConsecutivos xs) es la suma de los pares de elementos
-- consecutivos de la lista xs. Por ejemplo,
--    sumaConsecutivos [3,1,5,2]  ==  [4,6,7]
--    sumaConsecutivos [3]        ==  []
-- ---------------------------------------------------------------------

sumaConsecutivos :: [Int] -> [Int]
sumaConsecutivos xs = [x+y | (x,y) <- zip xs (tail xs)]

-- ---------------------------------------------------------------------
-- Ejercicio 5. En el tema se ha definido la función 
--    posiciones :: Eq a => a -> [a] -> [Int]
-- tal que (posiciones x xs) es la lista de las posiciones ocupadas por
-- el elemento x en la lista xs. Por ejemplo,
--    posiciones 5 [1,5,3,5,5,7]  ==  [1,3,4]
-- 
-- Definir, usando la función busca (definida en el tema 5), la función
--    posiciones' :: Eq a => a -> [a] -> [Int]
-- tl que posiciones' sea equivalente a posiciones.
-- ---------------------------------------------------------------------

-- La definición de posiciones es
posiciones :: Eq a => a -> [a] -> [Int]
posiciones x xs = 
    [i | (x',i) <- zip xs [0..n], x == x']
    where n = length xs - 1

-- La definición de busca es
busca :: Eq a => a -> [(a, b)] -> [b]
busca c t = [v | (c', v) <- t, c' == c]

-- La redefinición de posiciones es
posiciones' :: Eq a => a -> [a] -> [Int]
posiciones' x xs = busca x (zip xs [0..])

-- ---------------------------------------------------------------------
-- Ejercicio 6. Los polinomios pueden representarse de forma dispersa o
-- densa. Por ejemplo, el polinomio 6x^4-5x^2+4x-7 se puede representar
-- de forma dispersa por [6,0,-5,4,-7] y de forma densa por
-- [(4,6),(2,-5),(1,4),(0,-7)].  
-- 
-- Definir la función 
--    densa :: [Int] -> [(Int,Int)]
-- tal que (densa xs) es la representación densa del polinomio cuya
-- representación dispersa es xs. Por ejemplo, 
--   densa [6,0,-5,4,-7]  ==  [(4,6),(2,-5),(1,4),(0,-7)]
--   densa [6,0,0,3,0,4]  ==  [(5,6),(2,3),(0,4)]
-- ---------------------------------------------------------------------

densa :: [Int] -> [(Int,Int)]
densa xs = [(x,y) | (x,y) <- zip [n-1,n-2..0] xs, y /= 0]
    where n = length xs

-- ---------------------------------------------------------------------
-- Ejercicio 7. La función 
--    pares :: [a] -> [b] -> [(a,b)]
-- definida por
--    pares xs ys = [(x,y) | x <- xs, y <- ys]
-- toma como argumento dos listas y devuelve la listas de los pares con
-- el primer elemento de la primera lista y el segundo de la
-- segunda. Por ejemplo,
--    ghci> pares [1..3] [4..6]
--    [(1,4),(1,5),(1,6),(2,4),(2,5),(2,6),(3,4),(3,5),(3,6)]
-- 
-- Definir, usando dos listas por comprensión con un generador cada una,
-- la función 
--    pares' :: [a] -> [b] -> [(a,b)]
-- tal que pares' sea equivalente a pares.
-- 
-- Indicación: Utilizar la función predefinida concat y encajar una
-- lista por comprensión dentro de la otra. 
-- ---------------------------------------------------------------------

-- La definición de pares es
pares :: [a] -> [b] -> [(a,b)]
pares xs ys = [(x,y) | x <- xs, y <- ys]

-- La redefinición de pares es
pares' :: [a] -> [b] -> [(a,b)]
pares' xs ys = concat [[(x,y) | y <- ys] | x <- xs]

-- ---------------------------------------------------------------------
-- Ejercicio 8. La bases de datos sobre actividades de personas pueden
-- representarse mediante listas de elementos de la forma (a,b,c,d),
-- donde a es el nombre de la persona, b su actividad, c su fecha de
-- nacimiento y d la de su fallecimiento. Un ejemplo es la siguiente que
-- usaremos a lo largo de este ejercicio,
-- ---------------------------------------------------------------------

personas :: [(String,String,Int,Int)]
personas = [("Cervantes","Literatura",1547,1616),
            ("Velazquez","Pintura",1599,1660),
            ("Picasso","Pintura",1881,1973),
            ("Beethoven","Musica",1770,1823),
            ("Poincare","Ciencia",1854,1912),
            ("Quevedo","Literatura",1580,1654),
            ("Goya","Pintura",1746,1828),
            ("Einstein","Ciencia",1879,1955),
            ("Mozart","Musica",1756,1791),
            ("Botticelli","Pintura",1445,1510),
            ("Borromini","Arquitectura",1599,1667),
            ("Bach","Musica",1685,1750)]

-- ---------------------------------------------------------------------
-- Ejercicio 8.1. Definir la función nombres tal que (nombres bd) es
-- la lista de los nombres de las personas de la base de datos bd. Por
-- ejemplo,  
--    ghci> nombres personas
--     ["Cervantes","Velazquez","Picasso","Beethoven","Poincare",
--      "Quevedo","Goya","Einstein","Mozart","Botticelli","Borromini","Bach"]
-- ---------------------------------------------------------------------

nombres :: [(String,String,Int,Int)] -> [String]
nombres bd = [x | (x,_,_,_) <- bd]

-- ---------------------------------------------------------------------
-- Ejercicio 8.2. Definir la función musicos tal que (musicos bd) es
-- la lista de los nombres de los músicos de la base de datos bd. Por
-- ejemplo,  
--    ghci> musicos personas
--    ["Beethoven","Mozart","Bach"]
-- ---------------------------------------------------------------------

musicos :: [(String,String,Int,Int)] -> [String]
musicos bd = [x | (x,"Musica",_,_) <- bd]

-- ---------------------------------------------------------------------
-- Ejercicio 8.3. Definir la función seleccion tal que (seleccion bd m) 
-- es la lista de los nombres de las personas de la base de datos bd
-- cuya actividad es m. Por ejemplo,  
--    ghci> seleccion personas "Pintura"
--    ["Velazquez","Picasso","Goya","Botticelli"]
--    ghci> seleccion personas "Musica"
--    ["Beethoven","Mozart","Bach"]
-- ---------------------------------------------------------------------

seleccion :: [(String,String,Int,Int)] -> String -> [String]
seleccion bd m = [ x | (x,m',_,_) <- bd, m == m' ]

-- ---------------------------------------------------------------------
-- Ejercicio 8.4. Definir, usando el apartado anterior, la función
-- musicos' tal que (musicos' bd) es la lista de los nombres de los
-- músicos de la base de datos bd. Por ejemplo,  
--    ghci> musicos' personas
--    ["Beethoven","Mozart","Bach"]
-- ---------------------------------------------------------------------

musicos' :: [(String,String,Int,Int)] -> [String]
musicos' bd = seleccion bd "Musica"

-- ---------------------------------------------------------------------
-- Ejercicio 8.5. Definir la función vivas tal que (vivas bd a) es la
-- lista de los nombres de las personas de la base de datos bd  que
-- estaban vivas en el año a. Por ejemplo,  
--    ghci> vivas personas 1600
--    ["Cervantes","Velazquez","Quevedo","Borromini"]
-- ---------------------------------------------------------------------

vivas :: [(String,String,Int,Int)] -> Int -> [String]
vivas ps a = [x | (x,_,a1,a2) <- ps, a1 <= a, a <= a2]

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

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

-- Ejercicio 3. El producto escalar de dos listas de enteros xs y ys de

-- longitud n viene dado por la suma de los productos de los elementos

-- correspondientes.

-- Definir por comprensión la función

-- productoEscalar :: [Int] -> [Int] -> Int

-- tal que (productoEscalar xs ys) es el producto escalar de las listas

-- xs e ys. Por ejemplo,

-- productoEscalar [1,2,3] [4,5,6] == 32

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

productoEscalar :: [Int] -> [Int] -> Int

productoEscalar xs ys = sum [x*y | (x,y) <- zip xs ys]

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

-- Ejercicio 4. Definir, por comprensión, la función

-- sumaConsecutivos :: [Int] -> [Int]

-- tal que (sumaConsecutivos xs) es la suma de los pares de elementos

-- consecutivos de la lista xs. Por ejemplo,

-- sumaConsecutivos [3,1,5,2] == [4,6,7]

-- sumaConsecutivos [3] == []

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

sumaConsecutivos :: [Int] -> [Int]

sumaConsecutivos xs = [x+y | (x,y) <- zip xs (tail xs)]

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

-- Ejercicio 5. En el tema se ha definido la función

-- posiciones :: Eq a => a -> [a] -> [Int]

-- tal que (posiciones x xs) es la lista de las posiciones ocupadas por

-- el elemento x en la lista xs. Por ejemplo,

-- posiciones 5 [1,5,3,5,5,7] == [1,3,4]

-- Definir, usando la función busca (definida en el tema 5), la función

-- posiciones' :: Eq a => a -> [a] -> [Int]

-- tl que posiciones' sea equivalente a posiciones.

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

-- La definición de posiciones es

posiciones :: Eq a => a -> [a] -> [Int]

posiciones x xs =

[i | (x',i) <- zip xs [0..n], x == x']

where n = length xs - 1

-- La definición de busca es

busca :: Eq a => a -> [(a, b)] -> [b]

busca c t = [v | (c', v) <- t, c' == c]

-- La redefinición de posiciones es

posiciones' :: Eq a => a -> [a] -> [Int]

posiciones' x xs = busca x (zip xs [0..])

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

-- Ejercicio 6. Los polinomios pueden representarse de forma dispersa o

-- densa. Por ejemplo, el polinomio 6x^4-5x^2+4x-7 se puede representar

-- de forma dispersa por [6,0,-5,4,-7] y de forma densa por

-- [(4,6),(2,-5),(1,4),(0,-7)].

-- Definir la función

-- densa :: [Int] -> [(Int,Int)]

-- tal que (densa xs) es la representación densa del polinomio cuya

-- representación dispersa es xs. Por ejemplo,

-- densa [6,0,-5,4,-7] == [(4,6),(2,-5),(1,4),(0,-7)]

-- densa [6,0,0,3,0,4] == [(5,6),(2,3),(0,4)]

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

densa :: [Int] -> [(Int,Int)]

densa xs = [(x,y) | (x,y) <- zip [n-1,n-2..0] xs, y /= 0]

where n = length xs

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

-- Ejercicio 7. La función

-- pares :: [a] -> [b] -> [(a,b)]

-- definida por

-- pares xs ys = [(x,y) | x <- xs, y <- ys]

-- toma como argumento dos listas y devuelve la listas de los pares con

-- el primer elemento de la primera lista y el segundo de la

-- segunda. Por ejemplo,

-- ghci> pares [1..3] [4..6]

-- [(1,4),(1,5),(1,6),(2,4),(2,5),(2,6),(3,4),(3,5),(3,6)]

-- Definir, usando dos listas por comprensión con un generador cada una,

-- la función

-- pares' :: [a] -> [b] -> [(a,b)]

-- tal que pares' sea equivalente a pares.

-- Indicación: Utilizar la función predefinida concat y encajar una

-- lista por comprensión dentro de la otra.

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

-- La definición de pares es

pares :: [a] -> [b] -> [(a,b)]

pares xs ys = [(x,y) | x <- xs, y <- ys]

-- La redefinición de pares es

pares' :: [a] -> [b] -> [(a,b)]

pares' xs ys = concat [[(x,y) | y <- ys] | x <- xs]

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

-- Ejercicio 8. La bases de datos sobre actividades de personas pueden

-- representarse mediante listas de elementos de la forma (a,b,c,d),

-- donde a es el nombre de la persona, b su actividad, c su fecha de

-- nacimiento y d la de su fallecimiento. Un ejemplo es la siguiente que

-- usaremos a lo largo de este ejercicio,

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

personas :: [(String,String,Int,Int)]

personas = [("Cervantes","Literatura",1547,1616),

("Velazquez","Pintura",1599,1660),

("Picasso","Pintura",1881,1973),

("Beethoven","Musica",1770,1823),

("Poincare","Ciencia",1854,1912),

("Quevedo","Literatura",1580,1654),

("Goya","Pintura",1746,1828),

("Einstein","Ciencia",1879,1955),

("Mozart","Musica",1756,1791),

("Botticelli","Pintura",1445,1510),

("Borromini","Arquitectura",1599,1667),

("Bach","Musica",1685,1750)]

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

-- Ejercicio 8.1. Definir la función nombres tal que (nombres bd) es

-- la lista de los nombres de las personas de la base de datos bd. Por

-- ejemplo,

-- ghci> nombres personas

-- ["Cervantes","Velazquez","Picasso","Beethoven","Poincare",

-- "Quevedo","Goya","Einstein","Mozart","Botticelli","Borromini","Bach"]

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

nombres :: [(String,String,Int,Int)] -> [String]

nombres bd = [x | (x,_,_,_) <- bd]

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

-- Ejercicio 8.2. Definir la función musicos tal que (musicos bd) es

-- la lista de los nombres de los músicos de la base de datos bd. Por

-- ejemplo,

-- ghci> musicos personas

-- ["Beethoven","Mozart","Bach"]

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

musicos :: [(String,String,Int,Int)] -> [String]

musicos bd = [x | (x,"Musica",_,_) <- bd]

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

-- Ejercicio 8.3. Definir la función seleccion tal que (seleccion bd m)

-- es la lista de los nombres de las personas de la base de datos bd

-- cuya actividad es m. Por ejemplo,

-- ghci> seleccion personas "Pintura"

-- ["Velazquez","Picasso","Goya","Botticelli"]

-- ghci> seleccion personas "Musica"

-- ["Beethoven","Mozart","Bach"]

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

seleccion :: [(String,String,Int,Int)] -> String -> [String]

seleccion bd m = [ x | (x,m',_,_) <- bd, m == m' ]

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

-- Ejercicio 8.4. Definir, usando el apartado anterior, la función

-- musicos' tal que (musicos' bd) es la lista de los nombres de los

-- músicos de la base de datos bd. Por ejemplo,

-- ghci> musicos' personas

-- ["Beethoven","Mozart","Bach"]

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

musicos' :: [(String,String,Int,Int)] -> [String]

musicos' bd = seleccion bd "Musica"

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

-- Ejercicio 8.5. Definir la función vivas tal que (vivas bd a) es la

-- lista de los nombres de las personas de la base de datos bd que

-- estaban vivas en el año a. Por ejemplo,

-- ghci> vivas personas 1600

-- ["Cervantes","Velazquez","Quevedo","Borromini"]

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

vivas :: [(String,String,Int,Int)] -> Int -> [String]

vivas ps a = [x | (x,_,a1,a2) <- ps, a1 <= a, a <= a2]

Se puede imprimir o compartir con