I1M2013: Ejercicios de definiciones por recursión y comprensión (1)

En la clase de hoy del curso Informática (de 1º de Grado en Matemáticas) se han comentado las soluciones de los ejercicios 4 a 8 de la 8ª relación y los 5 primeros de la 10ª. En la relación 8 se proponen ejercicios por recursión de exámenes del curso anterior. En la relación 10 se proponen ejercicios con dos definiciones (una por recursión y otra por comprensión) y la comprobación de la equivalencia de las dos definiciones con QuickCheck.

Los ejercicios 4 a 8 de la relación 8 y soluciones se muestran a continuación

-- ---------------------------------------------------------------------
-- Ejercicio 4. Definir, por recursión, la función 
--    suma :: Num a => [[a]] -> a
-- tal que (suma xss) es la suma de todos los elementos de todas las
-- listas de xss. Por ejemplo,
--    suma [[1,3,5],[2,4,1],[3,7,9]]  ==  35
-- ---------------------------------------------------------------------

suma :: Num a => [[a]] -> a
suma []       = 0
suma (xs:xss) = sum xs + suma xss

-- ---------------------------------------------------------------------
-- Ejercicio 5. Definir, por recursión, la función 
--    maximaDiferencia :: [Integer] -> Integer
-- tal que (maximaDiferencia xs) es la mayor de las diferencias en
-- valor absoluto entre elementos consecutivos de la lista xs. Por
-- ejemplo,  
--    maximaDiferencia [2,5,-3]           ==  8
--    maximaDiferencia [1,5]              == 4
--    maximaDiferencia [10,-10,1,4,20,-2] == 22
-- ---------------------------------------------------------------------
 
maximaDiferencia :: [Integer] -> Integer
maximaDiferencia [x,y]    = abs (x-y)
maximaDiferencia (x:y:ys) = max (abs (x-y)) (maximaDiferencia (y:ys))

-- ---------------------------------------------------------------------
-- Ejercicio 6. Definir, por recursión, la función 
--    acumulada :: Num a => [a] -> [a]
-- tal que (acumulada xs) es la lista que tiene en cada posición i el valor que
-- resulta de sumar los elementos de la lista xs desde la posicion 0
-- hasta la i. Por ejemplo,
--    acumulada [2,5,1,4,3] == [2,7,8,12,15]
--    acumulada [1,-1,1,-1] == [1,0,1,0]
-- ---------------------------------------------------------------------

-- 1ª definición:
acumulada :: Num a => [a] -> [a]
acumulada [] =  []
acumulada xs =  acumulada (init xs) ++ [sum xs]

-- 2ª definición:
acumulada2 :: Num a => [a] -> [a]
acumulada2 [] = []
acumulada2 (x:xs) = reverse (aux xs [x])
    where aux [] ys = ys
          aux (x:xs) (y:ys) = aux xs (x+y:y:ys)

-- ---------------------------------------------------------------------
-- Ejercicio 7. Definir, por recursión, la función 
--    inicialesDistintos :: Eq a => [a] -> Int
-- tal que (inicialesDistintos xs) es el número de elementos que hay en
-- xs antes de que aparezca el primer repetido. Por ejemplo,
--    inicialesDistintos [1,2,3,4,5,3] == 2
--    inicialesDistintos [1,2,3]       == 3
--    inicialesDistintos "ahora"       == 0
--    inicialesDistintos "ahorA"       == 5
-- ---------------------------------------------------------------------

inicialesDistintos :: Eq a => [a] -> Int
inicialesDistintos [] = 0
inicialesDistintos (x:xs) 
    | elem x xs = 0 
    | otherwise = 1 + inicialesDistintos xs

-- ---------------------------------------------------------------------
-- Ejercicio 8. [Problema 387 del Proyecto Euler]. Un número de Harshad
-- es un entero divisible entre la suma de sus dígitos. Por ejemplo, 201
-- es un número de Harshad porque es divisible por 3 (la suma de sus
-- dígitos). Cuando se elimina el último dígito de 201 se obtiene 20 que
-- también es un número de Harshad. Cuando se elimina el último dígito
-- de 20 se obtiene 2 que también es un número de Harshad. Los número
-- como el 201 que son de Harshad y que los números obtenidos eliminando
-- sus últimos dígitos siguen siendo de Harshad se llaman números de
-- Harshad hereditarios por la derecha. 
-- 
-- Definir la función
--    numeroHHD :: Int -> Bool
-- tal que (numeroHHD n) se verifica si n es un número de Harshad
-- hereditario por la derecha. Por ejemplo,
--    numeroHHD 201  ==  True
--    numeroHHD 140  ==  False
--    numeroHHD 1104 ==  False
-- Calcular el mayor número de Harshad hereditario por la derecha con
-- tres dígitos.
-- ---------------------------------------------------------------------

numeroHHD :: Int -> Bool 
numeroHHD n | n < 10    = True
            | otherwise = numeroH n && numeroHHD (div n 10) 

-- (numeroH n) se verifica si n es un número de Harshad.
--    numeroH 201  ==  True
numeroH :: Int -> Bool
numeroH n = rem n (sum (digitos n)) == 0

-- (digitos n) es la lista de los dígitos de n. Por ejemplo,
--    digitos 201  ==  [2,0,1]
digitos :: Int -> [Int]
digitos n = [read [d] | d <- show n]

-- El cálculo es
--    ghci> head [n | n <- [999,998..100], numeroHHD n]
--    902

100

101

102

103

104

105

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

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

-- suma :: Num a => [[a]] -> a

-- tal que (suma xss) es la suma de todos los elementos de todas las

-- listas de xss. Por ejemplo,

-- suma [[1,3,5],[2,4,1],[3,7,9]] == 35

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

suma :: Num a => [[a]] -> a

suma [] = 0

suma (xs:xss) = sum xs + suma xss

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

-- Ejercicio 5. Definir, por recursión, la función

-- maximaDiferencia :: [Integer] -> Integer

-- tal que (maximaDiferencia xs) es la mayor de las diferencias en

-- valor absoluto entre elementos consecutivos de la lista xs. Por

-- ejemplo,

-- maximaDiferencia [2,5,-3] == 8

-- maximaDiferencia [1,5] == 4

-- maximaDiferencia [10,-10,1,4,20,-2] == 22

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

maximaDiferencia :: [Integer] -> Integer

maximaDiferencia [x,y] = abs (x-y)

maximaDiferencia (x:y:ys) = max (abs (x-y)) (maximaDiferencia (y:ys))

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

-- Ejercicio 6. Definir, por recursión, la función

-- acumulada :: Num a => [a] -> [a]

-- tal que (acumulada xs) es la lista que tiene en cada posición i el valor que

-- resulta de sumar los elementos de la lista xs desde la posicion 0

-- hasta la i. Por ejemplo,

-- acumulada [2,5,1,4,3] == [2,7,8,12,15]

-- acumulada [1,-1,1,-1] == [1,0,1,0]

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

-- 1ª definición:

acumulada :: Num a => [a] -> [a]

acumulada [] = []

acumulada xs = acumulada (init xs) ++ [sum xs]

-- 2ª definición:

acumulada2 :: Num a => [a] -> [a]

acumulada2 [] = []

acumulada2 (x:xs) = reverse (aux xs [x])

where aux [] ys = ys

aux (x:xs) (y:ys) = aux xs (x+y:y:ys)

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

-- Ejercicio 7. Definir, por recursión, la función

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

-- tal que (inicialesDistintos xs) es el número de elementos que hay en

-- xs antes de que aparezca el primer repetido. Por ejemplo,

-- inicialesDistintos [1,2,3,4,5,3] == 2

-- inicialesDistintos [1,2,3] == 3

-- inicialesDistintos "ahora" == 0

-- inicialesDistintos "ahorA" == 5

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

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

inicialesDistintos [] = 0

inicialesDistintos (x:xs)

| elem x xs = 0

| otherwise = 1 + inicialesDistintos xs

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

-- Ejercicio 8. [Problema 387 del Proyecto Euler]. Un número de Harshad

-- es un entero divisible entre la suma de sus dígitos. Por ejemplo, 201

-- es un número de Harshad porque es divisible por 3 (la suma de sus

-- dígitos). Cuando se elimina el último dígito de 201 se obtiene 20 que

-- también es un número de Harshad. Cuando se elimina el último dígito

-- de 20 se obtiene 2 que también es un número de Harshad. Los número

-- como el 201 que son de Harshad y que los números obtenidos eliminando

-- sus últimos dígitos siguen siendo de Harshad se llaman números de

-- Harshad hereditarios por la derecha.

-- Definir la función

-- numeroHHD :: Int -> Bool

-- tal que (numeroHHD n) se verifica si n es un número de Harshad

-- hereditario por la derecha. Por ejemplo,

-- numeroHHD 201 == True

-- numeroHHD 140 == False

-- numeroHHD 1104 == False

-- Calcular el mayor número de Harshad hereditario por la derecha con

-- tres dígitos.

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

numeroHHD :: Int -> Bool

numeroHHD n | n < 10 = True

| otherwise = numeroH n && numeroHHD (div n 10)

-- (numeroH n) se verifica si n es un número de Harshad.

-- numeroH 201 == True

numeroH :: Int -> Bool

numeroH n = rem n (sum (digitos n)) == 0

-- (digitos n) es la lista de los dígitos de n. Por ejemplo,

-- digitos 201 == [2,0,1]

digitos :: Int -> [Int]

digitos n = [read [d] | d <- show n]

-- El cálculo es

-- ghci> head [n | n <- [999,998..100], numeroHHD n]

-- 902

Los 5 primeros ejercicios la relación 10 y soluciones se muestran a continuación

-- ---------------------------------------------------------------------
-- Importación de librerías auxiliares                                --
-- ---------------------------------------------------------------------

import Test.QuickCheck
import Data.List

-- ---------------------------------------------------------------------
-- Ejercicio 1.1. Definir, por recursión, la función 
--    sumaCuadradosR :: Integer -> Integer
-- tal que (sumaCuadradosR n) es la suma de los cuadrados de los números
-- de 1 a n. Por ejemplo, 
--    sumaCuadradosR 4  ==  30 
-- ---------------------------------------------------------------------

sumaCuadradosR :: Integer -> Integer
sumaCuadradosR 0 = 0
sumaCuadradosR n = n^2 + sumaCuadradosR (n-1) 

-- ---------------------------------------------------------------------
-- Ejercicio 1.2. Comprobar con QuickCheck si sumaCuadradosR n es igual a
-- n(n+1)(2n+1)/6. 
-- ---------------------------------------------------------------------

-- La propiedad es
prop_SumaCuadrados n =
  n >= 0 ==>
    sumaCuadradosR n == n * (n+1) * (2*n+1) `div` 6  

-- La comprobación es
--    Main> quickCheck prop_SumaCuadrados
--    OK, passed 100 tests.

-- ---------------------------------------------------------------------
-- Ejercicio 1.3. Definir, por comprensión, la función 
--    sumaCuadradosC :: Integer --> Integer
-- tal que (sumaCuadradosC n) es la suma de los cuadrados de los números
-- de 1 a n. Por ejemplo, 
--    sumaCuadradosC 4  ==  30 
-- ---------------------------------------------------------------------

sumaCuadradosC :: Integer -> Integer
sumaCuadradosC n = sum [x^2 | x <- [1..n]]

-- ---------------------------------------------------------------------
-- Ejercicio 1.4. Comprobar con QuickCheck que las funciones
-- sumaCuadradosR y sumaCuadradosC son equivalentes sobre los números
-- naturales. 
-- ---------------------------------------------------------------------

-- La propiedad es
prop_sumaCuadradosR n =
    n >= 0 ==> sumaCuadradosR n == sumaCuadradosC n

-- La comprobación es
--    *Main> quickCheck prop_sumaCuadrados
--    +++ OK, passed 100 tests.

-- ---------------------------------------------------------------------
-- Ejercicio 2.1. Se quiere formar una escalera con bloques cuadrados,
-- de forma que tenga un número determinado de escalones. Por ejemplo,
-- una escalera con tres escalones tendría la siguiente forma:
--        XX
--      XXXX
--    XXXXXX
-- Definir, por recursión, la función 
--    numeroBloquesR :: Integer -> Integer    
-- tal que (numeroBloquesR n) es el número de bloques necesarios para
-- construir una escalera con n escalones. Por ejemplo,
--    numeroBloquesR 1   ==   2
--    numeroBloquesR 3   ==  12
--    numeroBloquesR 10  == 110
-- ---------------------------------------------------------------------

numeroBloquesR :: Integer -> Integer    
numeroBloquesR 0 = 0
numeroBloquesR n = 2*n + numeroBloquesR (n-1) 

-- ---------------------------------------------------------------------
-- Ejercicio 2.2. Definir, por comprensión, la función 
--    numeroBloquesC :: Integer -> Integer    
-- tal que (numeroBloquesC n) es el número de bloques necesarios para
-- construir una escalera con n escalones. Por ejemplo,
--    numeroBloquesC 1   == 2
--    numeroBloquesC 3   == 12
--    numeroBloquesC 10  == 110
-- ---------------------------------------------------------------------

numeroBloquesC :: Integer -> Integer    
numeroBloquesC n = sum [2*x | x <- [1..n]]

-- ---------------------------------------------------------------------
-- Ejercicio 2.3. Comprobar con QuickCheck que (numeroBloquesC n) es
-- igual a n+n^2.
-- ---------------------------------------------------------------------

-- La propiedad es
prop_numeroBloquesR n =
    n > 0 ==> numeroBloquesC n == n+n^2

-- La comprobación es
--    *Main> quickCheck prop_numeroBloques
--    +++ OK, passed 100 tests.

-- ---------------------------------------------------------------------
-- Ejercicio 3.1. Definir, por recursión, la función 
--    sumaCuadradosImparesR :: Integer -> Integer
-- tal que (sumaCuadradosImparesR n) es la suma de los cuadrados de los
-- números impares desde 1 hasta n. 
--    sumaCuadradosImparesR 1  ==   1
--    sumaCuadradosImparesR 7  ==  84
--    sumaCuadradosImparesR 4  ==  10
-- ---------------------------------------------------------------------

sumaCuadradosImparesR :: Integer -> Integer
sumaCuadradosImparesR 1 = 1
sumaCuadradosImparesR n 
    | odd n     = n^2 + sumaCuadradosImparesR (n-1)
    | otherwise = sumaCuadradosImparesR (n-1)
                     
-- ---------------------------------------------------------------------
-- Ejercicio 3.2. Definir, por comprensión, la función 
--    sumaCuadradosImparesC :: Integer -> Integer
-- tal que (sumaCuadradosImparesC n) es la suma de los cuadrados de los
-- números impares desde 1 hasta n. 
--    sumaCuadradosImparesC 1  ==   1
--    sumaCuadradosImparesC 7  ==  84
--    sumaCuadradosImparesC 4  ==  10
-- ---------------------------------------------------------------------

sumaCuadradosImparesC :: Integer -> Integer
sumaCuadradosImparesC n = sum [x^2 | x <- [1..n], odd x]

-- Otra definición más simple es
sumaCuadradosImparesC' :: Integer -> Integer
sumaCuadradosImparesC' n = sum [x^2 | x <- [1,3..n]]

-- ---------------------------------------------------------------------
-- Ejercicio 3.3. Se considera la función
--    f :: Integer -> Integer
--    f n = (4*m^3-m) `div` 3
--        where m = (n+1) `div` 2
--
-- Definir la función
--    prop_sumaCuadradosImparesR :: Integer -> Integer -> Bool
-- tal que (prop_sumaCuadradosImparesR m n) se verifica si las funciones
-- sumaCuadradosImparesR y f son equivalentes para todos los números
-- entre m y n. Por ejemplo,
--    prop_sumaCuadradosImparesR 1 100  ==  True
-- ---------------------------------------------------------------------

f :: Integer -> Integer
f n = (4*m^3-m) `div` 3
    where m = (n+1) `div` 2

prop_sumaCuadradosImparesR :: Integer -> Integer -> Bool
prop_sumaCuadradosImparesR m n =
    and [sumaCuadradosImparesR x == f x | x <- [m..n]] 

-- ---------------------------------------------------------------------
-- Ejercicio 3.4. Definir la función
--    prop_sumaCuadradosImparesC :: Integer -> Integer -> Bool
-- tal que (prop_sumaCuadradosImparesC m n) se verifica si las funciones
-- sumaCuadradosImparesC y f son equivalentes para todos los números
-- entre m y n. Por ejemplo,
--    prop_sumaCuadradosImparesC 1 100  ==  True
-- ---------------------------------------------------------------------

prop_sumaCuadradosImparesC :: Integer -> Integer -> Bool
prop_sumaCuadradosImparesC m n =
    and [sumaCuadradosImparesC x == f x | x <- [m..n]] 

-- ---------------------------------------------------------------------
-- Ejercicio 4.1. Definir, por recursión, la función
--    digitosR :: Integer -> [Integer]
-- tal que (digitosR n) es la lista de los dígitos del número n. Por
-- ejemplo, 
--    digitosR 320274  ==  [3,2,0,2,7,4]
-- ---------------------------------------------------------------------

digitosR :: Integer -> [Integer]
digitosR n = reverse (digitosR' n)

digitosR' n
    | n < 10    = [n]
    | otherwise = (n `rem` 10) : digitosR' (n `div` 10)

-- ---------------------------------------------------------------------
-- Ejercicio 4.2. Definir, por comprensión, la función
--    digitosC :: Integer -> [Integer]
-- tal que (digitosC n) es la lista de los dígitos del número n. Por
-- ejemplo, 
--    digitosC 320274  ==  [3,2,0,2,7,4]
-- Indicación: Usar las funciones show y read.
-- ---------------------------------------------------------------------

digitosC :: Integer -> [Integer]
digitosC n = [read [x] | x <- show n]

-- ---------------------------------------------------------------------
-- Ejercicio 4.3. Comprobar con QuickCheck que las funciones digitosR y
-- digitosC son equivalentes.
-- ---------------------------------------------------------------------

-- La propiedad es
prop_digitos :: Integer -> Property
prop_digitos n =
    n >= 0 ==> 
    digitosR n == digitosC n
  
-- La comprobación es
--    *Main> quickCheck prop_digitos
--    +++ OK, passed 100 tests.

-- ---------------------------------------------------------------------
-- Ejercicio 5.1. Definir, por recursión, la función 
--    sumaDigitosR :: Integer -> Integer
-- tal que (sumaDigitosR n) es la suma de los dígitos de n. Por ejemplo,
--    sumaDigitosR 3     ==  3
--    sumaDigitosR 2454  == 15
--    sumaDigitosR 20045 == 11
-- ---------------------------------------------------------------------

sumaDigitosR :: Integer -> Integer
sumaDigitosR n
    | n < 10    = n
    | otherwise = n `rem` 10 + sumaDigitosR (n `div` 10)

-- ---------------------------------------------------------------------
-- Ejercicio 5.2. Definir, sin usar recursión, la función 
--    sumaDigitosNR :: Integer -> Integer
-- tal que (sumaDigitosNR n) es la suma de los dígitos de n. Por ejemplo,
--    sumaDigitosNR 3     ==  3
--    sumaDigitosNR 2454  == 15
--    sumaDigitosNR 20045 == 11
-- ---------------------------------------------------------------------

sumaDigitosNR :: Integer -> Integer
sumaDigitosNR n = sum (digitosC n)

-- ---------------------------------------------------------------------
-- Ejercicio 5.3. Comprobar con QuickCheck que las funciones sumaDigitosR
-- y sumaDigitosNR son equivalentes.
-- ---------------------------------------------------------------------

-- La propiedad es
prop_sumaDigitos :: Integer -> Property
prop_sumaDigitos n =
    n >= 0 ==>
    sumaDigitosR n == sumaDigitosNR n

-- La comprobación es
--    *Main> quickCheck prop_sumaDigitos
--    +++ OK, passed 100 tests.

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

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

216

217

218

219

220

221

222

223

224

225

226

227

228

229

230

231

232

233

234

235

236

237

238

239

240

241

242

243

244

245

246

247

248

249

250

251

252

253

254

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

-- Importación de librerías auxiliares --

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

import Test.QuickCheck

import Data.List

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

-- Ejercicio 1.1. Definir, por recursión, la función

-- sumaCuadradosR :: Integer -> Integer

-- tal que (sumaCuadradosR n) es la suma de los cuadrados de los números

-- de 1 a n. Por ejemplo,

-- sumaCuadradosR 4 == 30

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

sumaCuadradosR :: Integer -> Integer

sumaCuadradosR 0 = 0

sumaCuadradosR n = n^2 + sumaCuadradosR (n-1)

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

-- Ejercicio 1.2. Comprobar con QuickCheck si sumaCuadradosR n es igual a

-- n(n+1)(2n+1)/6.

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

-- La propiedad es

prop_SumaCuadrados n =

n >= 0 ==>

sumaCuadradosR n == n * (n+1) * (2*n+1) `div` 6

-- La comprobación es

-- Main> quickCheck prop_SumaCuadrados

-- OK, passed 100 tests.

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

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

-- sumaCuadradosC :: Integer --> Integer

-- tal que (sumaCuadradosC n) es la suma de los cuadrados de los números

-- de 1 a n. Por ejemplo,

-- sumaCuadradosC 4 == 30

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

sumaCuadradosC :: Integer -> Integer

sumaCuadradosC n = sum [x^2 | x <- [1..n]]

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

-- Ejercicio 1.4. Comprobar con QuickCheck que las funciones

-- sumaCuadradosR y sumaCuadradosC son equivalentes sobre los números

-- naturales.

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

-- La propiedad es

prop_sumaCuadradosR n =

n >= 0 ==> sumaCuadradosR n == sumaCuadradosC n

-- La comprobación es

-- *Main> quickCheck prop_sumaCuadrados

-- +++ OK, passed 100 tests.

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

-- Ejercicio 2.1. Se quiere formar una escalera con bloques cuadrados,

-- de forma que tenga un número determinado de escalones. Por ejemplo,

-- una escalera con tres escalones tendría la siguiente forma:

-- XX

-- XXXX

-- XXXXXX

-- Definir, por recursión, la función

-- numeroBloquesR :: Integer -> Integer

-- tal que (numeroBloquesR n) es el número de bloques necesarios para

-- construir una escalera con n escalones. Por ejemplo,

-- numeroBloquesR 1 == 2

-- numeroBloquesR 3 == 12

-- numeroBloquesR 10 == 110

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

numeroBloquesR :: Integer -> Integer

numeroBloquesR 0 = 0

numeroBloquesR n = 2*n + numeroBloquesR (n-1)

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

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

-- numeroBloquesC :: Integer -> Integer

-- tal que (numeroBloquesC n) es el número de bloques necesarios para

-- construir una escalera con n escalones. Por ejemplo,

-- numeroBloquesC 1 == 2

-- numeroBloquesC 3 == 12

-- numeroBloquesC 10 == 110

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

numeroBloquesC :: Integer -> Integer

numeroBloquesC n = sum [2*x | x <- [1..n]]

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

-- Ejercicio 2.3. Comprobar con QuickCheck que (numeroBloquesC n) es

-- igual a n+n^2.

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

-- La propiedad es

prop_numeroBloquesR n =

n > 0 ==> numeroBloquesC n == n+n^2

-- La comprobación es

-- *Main> quickCheck prop_numeroBloques

-- +++ OK, passed 100 tests.

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

-- Ejercicio 3.1. Definir, por recursión, la función

-- sumaCuadradosImparesR :: Integer -> Integer

-- tal que (sumaCuadradosImparesR n) es la suma de los cuadrados de los

-- números impares desde 1 hasta n.

-- sumaCuadradosImparesR 1 == 1

-- sumaCuadradosImparesR 7 == 84

-- sumaCuadradosImparesR 4 == 10

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

sumaCuadradosImparesR :: Integer -> Integer

sumaCuadradosImparesR 1 = 1

sumaCuadradosImparesR n

| odd n = n^2 + sumaCuadradosImparesR (n-1)

| otherwise = sumaCuadradosImparesR (n-1)

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

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

-- sumaCuadradosImparesC :: Integer -> Integer

-- tal que (sumaCuadradosImparesC n) es la suma de los cuadrados de los

-- números impares desde 1 hasta n.

-- sumaCuadradosImparesC 1 == 1

-- sumaCuadradosImparesC 7 == 84

-- sumaCuadradosImparesC 4 == 10

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

sumaCuadradosImparesC :: Integer -> Integer

sumaCuadradosImparesC n = sum [x^2 | x <- [1..n], odd x]

-- Otra definición más simple es

sumaCuadradosImparesC' :: Integer -> Integer

sumaCuadradosImparesC' n = sum [x^2 | x <- [1,3..n]]

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

-- Ejercicio 3.3. Se considera la función

-- f :: Integer -> Integer

-- f n = (4*m^3-m) `div` 3

-- where m = (n+1) `div` 2

-- Definir la función

-- prop_sumaCuadradosImparesR :: Integer -> Integer -> Bool

-- tal que (prop_sumaCuadradosImparesR m n) se verifica si las funciones

-- sumaCuadradosImparesR y f son equivalentes para todos los números

-- entre m y n. Por ejemplo,

-- prop_sumaCuadradosImparesR 1 100 == True

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

f :: Integer -> Integer

f n = (4*m^3-m) `div` 3

where m = (n+1) `div` 2

prop_sumaCuadradosImparesR :: Integer -> Integer -> Bool

prop_sumaCuadradosImparesR m n =

and [sumaCuadradosImparesR x == f x | x <- [m..n]]

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

-- Ejercicio 3.4. Definir la función

-- prop_sumaCuadradosImparesC :: Integer -> Integer -> Bool

-- tal que (prop_sumaCuadradosImparesC m n) se verifica si las funciones

-- sumaCuadradosImparesC y f son equivalentes para todos los números

-- entre m y n. Por ejemplo,

-- prop_sumaCuadradosImparesC 1 100 == True

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

prop_sumaCuadradosImparesC :: Integer -> Integer -> Bool

prop_sumaCuadradosImparesC m n =

and [sumaCuadradosImparesC x == f x | x <- [m..n]]

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

-- Ejercicio 4.1. Definir, por recursión, la función

-- digitosR :: Integer -> [Integer]

-- tal que (digitosR n) es la lista de los dígitos del número n. Por

-- ejemplo,

-- digitosR 320274 == [3,2,0,2,7,4]

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

digitosR :: Integer -> [Integer]

digitosR n = reverse (digitosR' n)

digitosR' n

| n < 10 = [n]

| otherwise = (n `rem` 10) : digitosR' (n `div` 10)

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

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

-- digitosC :: Integer -> [Integer]

-- tal que (digitosC n) es la lista de los dígitos del número n. Por

-- ejemplo,

-- digitosC 320274 == [3,2,0,2,7,4]

-- Indicación: Usar las funciones show y read.

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

digitosC :: Integer -> [Integer]

digitosC n = [read [x] | x <- show n]

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

-- Ejercicio 4.3. Comprobar con QuickCheck que las funciones digitosR y

-- digitosC son equivalentes.

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

-- La propiedad es

prop_digitos :: Integer -> Property

prop_digitos n =

n >= 0 ==>

digitosR n == digitosC n

-- La comprobación es

-- *Main> quickCheck prop_digitos

-- +++ OK, passed 100 tests.

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

-- Ejercicio 5.1. Definir, por recursión, la función

-- sumaDigitosR :: Integer -> Integer

-- tal que (sumaDigitosR n) es la suma de los dígitos de n. Por ejemplo,

-- sumaDigitosR 3 == 3

-- sumaDigitosR 2454 == 15

-- sumaDigitosR 20045 == 11

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

sumaDigitosR :: Integer -> Integer

sumaDigitosR n

| n < 10 = n

| otherwise = n `rem` 10 + sumaDigitosR (n `div` 10)

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

-- Ejercicio 5.2. Definir, sin usar recursión, la función

-- sumaDigitosNR :: Integer -> Integer

-- tal que (sumaDigitosNR n) es la suma de los dígitos de n. Por ejemplo,

-- sumaDigitosNR 3 == 3

-- sumaDigitosNR 2454 == 15

-- sumaDigitosNR 20045 == 11

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

sumaDigitosNR :: Integer -> Integer

sumaDigitosNR n = sum (digitosC n)

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

-- Ejercicio 5.3. Comprobar con QuickCheck que las funciones sumaDigitosR

-- y sumaDigitosNR son equivalentes.

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

-- La propiedad es

prop_sumaDigitos :: Integer -> Property

prop_sumaDigitos n =

n >= 0 ==>

sumaDigitosR n == sumaDigitosNR n

-- La comprobación es

-- *Main> quickCheck prop_sumaDigitos

-- +++ OK, passed 100 tests.

Se puede imprimir o compartir con