Menu Close

Suma de todos los anteriores.

José A. Alonso,

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

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
Medio
, , , , , ,

8 soluciones de “Suma de todos los anteriores.”

  1. Responder
    Jesús Navas Orozco 
    sumaAnteriores :: [Integer] -> Bool
sumaAnteriores []   = True
sumaAnteriores [x]  = True
sumaAnteriores (xs) = and [sum (take n xs) == xs !! n | n <- [1..(length xs - 1)]]
    • Responder
      Jesús Navas Orozco 
      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

    • Responder
      Pedro Martín Chávez 
      sumaAnteriores :: [Integer] -> Bool
sumaAnteriores []  = True
sumaAnteriores [_] = True
sumaAnteriores xs  =
    and [xs !! n == sum (take n xs) | n <- [1..(length xs - 1)]]
    • Responder
      Jesús Navas Orozco

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

  2. Responder
    Julián Galindo 
    sumaAnteriores :: [Integer] -> Bool
sumaAnteriores xs = sumaAnterioresAux (reverse xs)
 
sumaAnterioresAux []     = True
sumaAnterioresAux (x:[]) = True
sumaAnterioresAux (x:xs) = x == sum xs && sumaAnterioresAux xs
  3. Responder
    Jesús Camacho Moro 
    sumaAnteriores :: [Integer] -> Bool
sumaAnteriores []     = True
sumaAnteriores [x]    = True
sumaAnteriores (x:xs) = if x == head xs
                        then sumaAnterioresA1 ((x+head xs):(tail xs))
                        else False
  4. Responder
    Pedro Martín Chávez

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

  5. Responder
    Tamara Royán González 
    sumaAnteriores :: [Integer] -> Bool
sumaAnteriores [] = True
sumaAnteriores [_] = True
sumaAnteriores (x:xs) = head xs == x && sumaAnteriores ((x+head xs) : tail xs)

Escribe tu solución

Este sitio usa Akismet para reducir el spam. Aprende cómo se procesan los datos de tus comentarios.