Menu Close

Evaluación de expresiones aritméticas

Las expresiones aritméticas se pueden definir mediante el siguiente tipo de dato

   data Expr  = N Int | V Char | Sum Expr Expr | Mul Expr Expr 
                deriving Show

Por ejemplo, (x+3)+(7*y) se representa por

   ejExpr :: Expr
   ejExpr = Sum (Sum (V 'x') (N 3))(Mul (N 7) (V 'y'))

Definir la función

   valor :: Expr -> Maybe Int

tal que (valor e) es ‘Just v’ si la expresión e es numérica y v es su valor, o bien ‘Nothing’ si e no es numérica. Por ejemplo:

   valor (Sum (N 7) (N 9))                            == Just 16
   valor (Sum (Sum (V 'x') (N 3))(Mul (N 7) (V 'y'))) == Nothing
   valor (Sum (Sum (N 1) (N 3))(Mul (N 7) (N 2)))     == Just 18

Soluciones

data Expr  = N Int | V Char | Sum Expr Expr | Mul Expr Expr 
             deriving Show
 
-- 1ª solución
-- ===========
 
valor1 :: Expr -> Maybe Int
valor1 e | null (aux e) = Nothing
         | otherwise    = Just (head (aux e))
    where aux (N x)       = [x]
          aux (V _)       = []
          aux (Sum e1 e2) = [x+y| x <- aux e1, y <- aux e2]
          aux (Mul e1 e2) = [x*y| x <- aux e1, y <- aux e2]
 
-- 2ª solución
-- ===========
 
valor2 :: Expr -> Maybe Int
valor2 e | numerico e = Just (aux e)
         | otherwise  = Nothing
    where aux (N x)       = x
          aux (Sum e1 e2) = aux e1 + aux e2
          aux (Mul e1 e2) = aux e1 * aux e2
 
numerico :: Expr -> Bool
numerico (N _)       = True
numerico (V _)       = False
numerico (Sum e1 e2) = numerico e1 && numerico e2
numerico (Mul e1 e2) = numerico e1 && numerico e2
Medio

7 soluciones de “Evaluación de expresiones aritméticas

  1. erisan
    data Expr  = N Int | V Char | Sum Expr Expr | Mul Expr Expr 
               deriving Show
     
     
    valor :: Expr -> Maybe Int
    valor xss = if numerico xss == 0 then Just (valor' xss) else Nothing
     
     
    valor' (N x) = x
    valor' (Sum x y) = valor' x + valor' y
    valor' (Mul x y) = valor' x * valor' y
     
     
    numerico (N x) = 0
    numerico (V x) = 1
    numerico (Sum x y) = numerico x + numerico y 
    numerico (Mul x y) = numerico x + numerico y
    • jespergue

      erisan, en numerico (Mul x y) yo he usado ‘numerico (Mul x y) = numerico x * numerico ‘, se te ha escapado ahi poner un “*” o el resultado bueno es con el “+”?

  2. juamorrom1
    data Expr  = N Int | V Char | Sum Expr Expr | Mul Expr Expr 
                    deriving Show
     
    valor :: Expr -> Maybe Int
    valor (N a) = Just a
    valor e | esNumerica e = Just (aux e)
            | otherwise    = Nothing
     
    esNumerica :: Expr -> Bool
    esNumerica (Sum (N _) (N _)) = True
    esNumerica (Mul (N _) (N _)) = True
    esNumerica (Sum a b) = esNumerica a && esNumerica b
    esNumerica (Mul a b) = esNumerica a && esNumerica b
    esNumerica _         = False
     
    aux :: Expr -> Int
    aux (Sum (N a) (N b)) = (a + b)
    aux (Mul (N a) (N b)) = (a * b)
    aux (Sum a b) = (aux a) + (aux b)
    aux (Mul a b) = (aux a) * (aux b)
  3. abrdelrod
    data Expr  = N Int | V Char | Sum Expr Expr | Mul Expr Expr 
                    deriving Show
     
    evaluable :: Expr -> Bool
    evaluable (N _) = True
    evaluable (V _) = False
    evaluable (Sum e1 e2) = evaluable e1 && evaluable e2
    evaluable (Mul e1 e2) = evaluable e1 && evaluable e2
     
    valor' :: Expr -> Int
    valor' (N a) = a
    valor' (Sum e1 e2) = valor' e1 + valor' e2
    valor' (Mul e1 e2) = valor' e1 * valor' e2
     
    valor :: Expr -> Maybe Int
    valor e | evaluable e = Just (valor' e)
            | otherwise = Nothing
  4. fracruzam
    valor :: Expr -> Maybe Int
    valor (N x) = Just x
    valor (V _) = Nothing
    valor (Sum i j) = (valor i) `sumJust` (valor j)
    valor (Mul i j) = (valor i) `mulJust` (valor j)
     
    sumJust :: Maybe Int -> Maybe Int -> Maybe Int
    sumJust (Just i) (Just j) = Just (i+j)
    sumJust _        _        = Nothing
     
    mulJust :: Maybe Int -> Maybe Int -> Maybe Int
    mulJust (Just i) (Just j) = Just (i*j)
    mulJust _        _        = Nothing
  5. Chema Cortés
    import Control.Monad (liftM2)
     
    data Expr  = N Int | V Char | Sum Expr Expr | Mul Expr Expr
                 deriving Show
     
    valor :: Expr -> Maybe Int
    valor (N v)     = Just v
    valor (V _)     = Nothing
    valor (Sum x y) = (liftM2 (+)) (valor x) (valor y)
    valor (Mul x y) = (liftM2 (*)) (valor x) (valor y)
  6. isrbelnun
    data Expr  = N Int | V Char | Sum Expr Expr | Mul Expr Expr 
                    deriving Show
     
    valor :: Expr -> Maybe Int
    valor (N a) = Just a
    valor (V _) = Nothing
    valor (Sum i d) | valor i /= Nothing && valor d /= Nothing = Just (l+r)
                    | otherwise                                = Nothing
                      where Just l = valor i
                            Just r = valor d
    valor (Mul i d) | valor i /= Nothing && valor d /= Nothing = Just (l*r)
                    | otherwise                                = Nothing
                      where Just l = valor i
                            Just r = valor d

Escribe tu solución

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