Evaluación de expresiones aritméticas

PorJosé A. Alonso 29-marzo-201626-marzo-2022

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

1 2	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'))

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

Definir la función

   valor :: Expr -> Maybe Int

1	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

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

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

7 Comentarios

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

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 dice:

29-marzo-2016 a las 16:41

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 «+»?

Responder

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)

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)

Responder

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

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

Responder

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

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

Responder

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)

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)

Responder

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

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

Responder

Evaluación de expresiones aritméticas

Soluciones

7 Comentarios

Escribe tu soluciónCancel reply

Entradas recientes

Buscar

Correo electrónico

Soluciones

Se puede imprimir o compartir con

7 Comentarios

Escribe tu soluciónCancel reply

Entradas recientes

Buscar

Correo electrónico