Suma de todos los anteriores.

PorJosé A. Alonso 5-noviembre-201427-diciembre-2014

Enunciado

-- Definir la función
--    sumaAnteriores :: [Integer] -> Bool
-- tal que (sumaAnteriores xs) se verifica si cada elemento de la lista
-- xs (excepto el primero) es la suma de sus anteriores elementos en la
-- lista. Por ejemplo,  
--    sumaAnteriores [3,3,6,12]  ==  True
--    sumaAnteriores [3,3,7,10]  ==  False
--    sumaAnteriores [3]         ==  True
--    sumaAnteriores []          ==  True

1

2

3

4

5

6

7

8

9

-- Definir la función

-- sumaAnteriores :: [Integer] -> Bool

-- tal que (sumaAnteriores xs) se verifica si cada elemento de la lista

-- xs (excepto el primero) es la suma de sus anteriores elementos en la

-- lista. Por ejemplo,

-- sumaAnteriores [3,3,6,12] == True

-- sumaAnteriores [3,3,7,10] == False

-- sumaAnteriores [3] == True

-- sumaAnteriores [] == True

Soluciones

import Test.QuickCheck

-- 1ª definición (por recursión):
sumaAnteriores :: [Integer] -> Bool
sumaAnteriores xs = aux (reverse xs)
    where aux []     = True
          aux [_]    = True
          aux (x:xs) = x == sum xs && aux xs

-- 2ª definición (por comprensión):
sumaAnteriores2 :: [Integer] -> Bool
sumaAnteriores2 (x:y:zs) = 
    x == y && and [b == 2*a | (a,b) <- adyacentes (y:zs)]
    where adyacentes xs = zip xs (tail xs)
sumaAnteriores2 _ = True

-- La propiedad de equivalencia es
prop_equiv_sumaAnteriores :: [Integer] -> Bool
prop_equiv_sumaAnteriores xs = 
    sumaAnteriores xs == sumaAnteriores2 xs

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

import Test.QuickCheck

-- 1ª definición (por recursión):

sumaAnteriores :: [Integer] -> Bool

sumaAnteriores xs = aux (reverse xs)

where aux [] = True

aux [_] = True

aux (x:xs) = x == sum xs && aux xs

-- 2ª definición (por comprensión):

sumaAnteriores2 :: [Integer] -> Bool

sumaAnteriores2 (x:y:zs) =

x == y && and [b == 2*a | (a,b) <- adyacentes (y:zs)]

where adyacentes xs = zip xs (tail xs)

sumaAnteriores2 _ = True

-- La propiedad de equivalencia es

prop_equiv_sumaAnteriores :: [Integer] -> Bool

prop_equiv_sumaAnteriores xs =

sumaAnteriores xs == sumaAnteriores2 xs

8 Comentarios

sumaAnteriores :: [Integer] -> Bool
sumaAnteriores []   = True
sumaAnteriores [x]  = True
sumaAnteriores (xs) = and [sum (take n xs) == xs !! n | n <- [1..(length xs - 1)]]

1

2

3

4

sumaAnteriores :: [Integer] -> Bool

sumaAnteriores [] = True

sumaAnteriores [x] = True

sumaAnteriores (xs) = and [sum (take n xs) == xs !! n | n <- [1..(length xs - 1)]]

sumaAnteriores :: [Integer] -> Bool
sumaAnteriores []  = True
sumaAnteriores [x] = True
sumaAnteriores xs  = and [sum (take n xs) == xs !! n | n <- [1..(length xs - 1)]]

1

2

3

4

sumaAnteriores :: [Integer] -> Bool

sumaAnteriores [] = True

sumaAnteriores [x] = True

sumaAnteriores xs = and [sum (take n xs) == xs !! n | n <- [1..(length xs - 1)]]

*He quitado los paréntesis innecesarios de xs

sumaAnteriores :: [Integer] -> Bool
sumaAnteriores []  = True
sumaAnteriores [_] = True
sumaAnteriores xs  =
    and [xs !! n == sum (take n xs) | n <- [1..(length xs - 1)]]

1

2

3

4

5

sumaAnteriores :: [Integer] -> Bool

sumaAnteriores [] = True

sumaAnteriores [_] = True

sumaAnteriores xs =

and [xs !! n == sum (take n xs) | n <- [1..(length xs - 1)]]

Jesús Navas Orozco dice:

7-noviembre-2014 a las 18:43

En la segunda ecuación, en mejor sustituir [x] por [_], con una variable anónima

Responder

sumaAnteriores :: [Integer] -> Bool
sumaAnteriores xs = sumaAnterioresAux (reverse xs)

sumaAnterioresAux []     = True
sumaAnterioresAux (x:[]) = True
sumaAnterioresAux (x:xs) = x == sum xs && sumaAnterioresAux xs

1

2

3

4

5

6

sumaAnteriores :: [Integer] -> Bool

sumaAnteriores xs = sumaAnterioresAux (reverse xs)

sumaAnterioresAux [] = True

sumaAnterioresAux (x:[]) = True

sumaAnterioresAux (x:xs) = x == sum xs && sumaAnterioresAux xs

sumaAnteriores :: [Integer] -> Bool
sumaAnteriores []     = True
sumaAnteriores [x]    = True
sumaAnteriores (x:xs) = if x == head xs
                        then sumaAnterioresA1 ((x+head xs):(tail xs))
                        else False

1

2

3

4

5

6

sumaAnteriores :: [Integer] -> Bool

sumaAnteriores [] = True

sumaAnteriores [x] = True

sumaAnteriores (x:xs) = if x == head xs

then sumaAnterioresA1 ((x+head xs):(tail xs))

else False

Pedro Martín Chávez dice:

7-noviembre-2014 a las 01:07

La definición se puede mejorar, pues en sumaAnteriores [x] = True podemos sustituir la x por la variable anónima: sumaAnteriores [_] = True

Responder

sumaAnteriores :: [Integer] -> Bool
sumaAnteriores [] = True
sumaAnteriores [_] = True
sumaAnteriores (x:xs) = head xs == x && sumaAnteriores ((x+head xs) : tail xs)

1

2

3

4

sumaAnteriores :: [Integer] -> Bool

sumaAnteriores [] = True

sumaAnteriores [_] = True

sumaAnteriores (x:xs) = head xs == x && sumaAnteriores ((x+head xs) : tail xs)

Escribe tu soluciónCancel reply