Menu Close

Evaluación de expresiones aritméticas

José A. Alonso,

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. Responder
    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
    • Responder
      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. Responder
    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. Responder
    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. Responder
    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. Responder
    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. Responder
    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.