Exercitium

Valor de expresiones aritméticas generales

PorJosé A. Alonso 18-enero-202331-diciembre-2022

Las operaciones de suma, resta y multiplicación se pueden representar mediante el siguiente tipo de datos

   data Op = S | R | M

1	data Op = S \| R \| M

La expresiones aritméticas con dichas operaciones se pueden representar mediante el siguiente tipo de dato algebraico

   data Expr = C Int
             | A Op Expr Expr

1 2	data Expr = C Int \| A Op Expr Expr

Por ejemplo, la expresión

   (7-3)+(2*5)

1	(7-3)+(2*5)

se representa por

   A S (A R (C 7) (C 3)) (A M (C 2) (C 5))

1	A S (A R (C 7) (C 3)) (A M (C 2) (C 5))

Definir la función

   valor :: Expr -> Int

1	valor :: Expr -> Int

tal que valor e es el valor de la expresión e. Por ejemplo,

   valor (A S (A R (C 7) (C 3)) (A M (C 2) (C 5)))  ==  14
   valor (A M (A R (C 7) (C 3)) (A S (C 2) (C 5)))  ==  28

1 2	valor (A S (A R (C 7) (C 3)) (A M (C 2) (C 5))) == 14 valor (A M (A R (C 7) (C 3)) (A S (C 2) (C 5))) == 28

Soluciones

A continuación se muestran las soluciones en Haskell y las soluciones en Python.

Soluciones en Haskell

data Op = S | R | M

data Expr = C Int
          | A Op Expr Expr

-- 1ª solución
-- ===========

valor :: Expr -> Int
valor (C x)      = x
valor (A o e1 e2) = aplica o (valor e1) (valor e2)
  where aplica :: Op -> Int -> Int -> Int
        aplica S x y = x+y
        aplica R x y = x-y
        aplica M x y = x*y

-- 2ª solución
-- ===========

valor2 :: Expr -> Int
valor2 (C n)    = n
valor2 (A o x y) = sig o (valor2 x) (valor2 y)
  where sig :: Op -> Int -> Int -> Int
        sig S = (+)
        sig M = (*)
        sig R = (-)

data Op = S | R | M

data Expr = C Int

| A Op Expr Expr

-- 1ª solución

-- ===========

valor :: Expr -> Int

valor (C x) = x

valor (A o e1 e2) = aplica o (valor e1) (valor e2)

where aplica :: Op -> Int -> Int -> Int

aplica S x y = x+y

aplica R x y = x-y

aplica M x y = x*y

-- 2ª solución

-- ===========

valor2 :: Expr -> Int

valor2 (C n) = n

valor2 (A o x y) = sig o (valor2 x) (valor2 y)

where sig :: Op -> Int -> Int -> Int

sig S = (+)

sig M = (*)

sig R = (-)

Soluciones en Python

from dataclasses import dataclass
from enum import Enum

Op = Enum('Op', ['S', 'R', 'M'])

@dataclass
class Expr:
    pass

@dataclass
class C(Expr):
    x: int

@dataclass
class A(Expr):
    o: Op
    x: Expr
    y: Expr

def aplica(o: Op, x: int, y: int) -> int:
    match o:
        case Op.S:
            return x + y
        case Op.R:
            return x - y
        case Op.M:
            return x * y
    assert False

def valor(e: Expr) -> int:
    match e:
        case C(x):
            return x
        case A(o, e1, e2):
            return aplica(o, valor(e1), valor(e2))
    assert False

from dataclasses import dataclass

from enum import Enum

Op = Enum('Op', ['S', 'R', 'M'])

@dataclass

class Expr:

pass

@dataclass

class C(Expr):

x: int

@dataclass

class A(Expr):

o: Op

x: Expr

y: Expr

def aplica(o: Op, x: int, y: int) -> int:

match o:

case Op.S:

return x + y

case Op.R:

return x - y

case Op.M:

return x * y

assert False

def valor(e: Expr) -> int:

match e:

case C(x):

return x

case A(o, e1, e2):

return aplica(o, valor(e1), valor(e2))

assert False

Máximos valores de una expresión aritmética

PorJosé A. Alonso 17-enero-202331-diciembre-2022

Las expresiones aritméticas generales se pueden definir usando el siguiente tipo de datos

   data Expr = C Int
             | X
             | S Expr Expr
             | R Expr Expr
             | P Expr Expr
             | E Expr Int
     deriving (Eq, Show)

data Expr = C Int

| X

| S Expr Expr

| R Expr Expr

| P Expr Expr

| E Expr Int

deriving (Eq, Show)

Por ejemplo, la expresión

   3*x - (x+2)^7

1	3*x - (x+2)^7

se puede definir por

   R (P (C 3) X) (E (S X (C 2)) 7)

1	R (P (C 3) X) (E (S X (C 2)) 7)

Definir la función

   maximo :: Expr -> [Int] -> (Int,[Int])

1	maximo :: Expr -> [Int] -> (Int,[Int])

tal que maximo e xs es el par formado por el máximo valor de la expresión e para los puntos de xs y en qué puntos alcanza el máximo. Por ejemplo,

   λ> maximo (E (S (C 10) (P (R (C 1) X) X)) 2) [-3..3]
   (100,[0,1])

1 2	λ> maximo (E (S (C 10) (P (R (C 1) X) X)) 2) [-3..3] (100,[0,1])

Soluciones

A continuación se muestran las soluciones en Haskell y las soluciones en Python.

Soluciones en Haskell

data Expr = C Int
          | X
          | S Expr Expr
          | R Expr Expr
          | P Expr Expr
          | E Expr Int
  deriving (Eq, Show)

maximo :: Expr -> [Int] -> (Int,[Int])
maximo e ns = (m,[n | n <- ns, valor e n == m])
  where m = maximum [valor e n | n <- ns]

valor :: Expr -> Int -> Int
valor (C x) _     = x
valor X     n     = n
valor (S e1 e2) n = valor e1 n + valor e2 n
valor (R e1 e2) n = valor e1 n - valor e2 n
valor (P e1 e2) n = valor e1 n * valor e2 n
valor (E e1 m1) n = valor e1 n ^ m1

data Expr = C Int

| X

| S Expr Expr

| R Expr Expr

| P Expr Expr

| E Expr Int

deriving (Eq, Show)

maximo :: Expr -> [Int] -> (Int,[Int])

maximo e ns = (m,[n | n <- ns, valor e n == m])

where m = maximum [valor e n | n <- ns]

valor :: Expr -> Int -> Int

valor (C x) _ = x

valor X n = n

valor (S e1 e2) n = valor e1 n + valor e2 n

valor (R e1 e2) n = valor e1 n - valor e2 n

valor (P e1 e2) n = valor e1 n * valor e2 n

valor (E e1 m1) n = valor e1 n ^ m1

Soluciones en Python

from dataclasses import dataclass


@dataclass
class Expr:
    pass

@dataclass
class C(Expr):
    x: int

@dataclass
class X(Expr):
    pass

@dataclass
class S(Expr):
    x: Expr
    y: Expr

@dataclass
class R(Expr):
    x: Expr
    y: Expr

@dataclass
class P(Expr):
    x: Expr
    y: Expr

@dataclass
class E(Expr):
    x: Expr
    y: int

def valor(e: Expr, n: int) -> int:
    match e:
        case C(a):
            return a
        case X():
            return n
        case S(e1, e2):
            return valor(e1, n) + valor(e2, n)
        case R(e1, e2):
            return valor(e1, n) - valor(e2, n)
        case P(e1, e2):
            return valor(e1, n) * valor(e2, n)
        case E(e1, m):
            return valor(e1, n) ** m
    assert False

def maximo(e: Expr, ns: list[int]) -> tuple[int, list[int]]:
    m = max((valor(e, n) for n in ns))
    return (m, [n for n in ns if valor(e, n) == m])

from dataclasses import dataclass

@dataclass

class Expr:

pass

@dataclass

class C(Expr):

x: int

@dataclass

class X(Expr):

pass

@dataclass

class S(Expr):

x: Expr

y: Expr

@dataclass

class R(Expr):

x: Expr

y: Expr

@dataclass

class P(Expr):

x: Expr

y: Expr

@dataclass

class E(Expr):

x: Expr

y: int

def valor(e: Expr, n: int) -> int:

match e:

case C(a):

return a

case X():

return n

case S(e1, e2):

return valor(e1, n) + valor(e2, n)

case R(e1, e2):

return valor(e1, n) - valor(e2, n)

case P(e1, e2):

return valor(e1, n) * valor(e2, n)

case E(e1, m):

return valor(e1, n) ** m

assert False

def maximo(e: Expr, ns: list[int]) -> tuple[int, list[int]]:

m = max((valor(e, n) for n in ns))

return (m, [n for n in ns if valor(e, n) == m])

Expresiones aritméticas reducibles

PorJosé A. Alonso 16-enero-202330-diciembre-2022

Las expresiones aritméticas con variables pueden representarse usando el siguiente tipo de datos

   data Expr = C Int
             | V Char
             | S Expr Expr
             | P Expr Expr

data Expr = C Int

| V Char

| S Expr Expr

| P Expr Expr

Por ejemplo, la expresión 2·(a+5) se representa por

   P (C 2) (S (V 'a') (C 5))

1	P (C 2) (S (V 'a') (C 5))

Definir la función

   reducible :: Expr -> Bool

1	reducible :: Expr -> Bool

tal que reducible a se verifica si a es una expresión reducible; es decir, contiene una operación en la que los dos operandos son números. Por ejemplo,

   reducible (S (C 3) (C 4))             == True
   reducible (S (C 3) (V 'x'))           == False
   reducible (S (C 3) (P (C 4) (C 5)))   == True
   reducible (S (V 'x') (P (C 4) (C 5))) == True
   reducible (S (C 3) (P (V 'x') (C 5))) == False
   reducible (C 3)                       == False
   reducible (V 'x')                     == False

reducible (S (C 3) (C 4)) == True

reducible (S (C 3) (V 'x')) == False

reducible (S (C 3) (P (C 4) (C 5))) == True

reducible (S (V 'x') (P (C 4) (C 5))) == True

reducible (S (C 3) (P (V 'x') (C 5))) == False

reducible (C 3) == False

reducible (V 'x') == False

Soluciones

A continuación se muestran las soluciones en Haskell y las soluciones en Python.

Soluciones en Haskell

data Expr = C Int
          | V Char
          | S Expr Expr
          | P Expr Expr

reducible :: Expr -> Bool
reducible (C _)           = False
reducible (V _)           = False
reducible (S (C _) (C _)) = True
reducible (S a b)         = reducible a || reducible b
reducible (P (C _) (C _)) = True
reducible (P a b)         = reducible a || reducible b

data Expr = C Int

| V Char

| S Expr Expr

| P Expr Expr

reducible :: Expr -> Bool

reducible (C _) = False

reducible (V _) = False

reducible (S (C _) (C _)) = True

reducible (S a b) = reducible a || reducible b

reducible (P (C _) (C _)) = True

reducible (P a b) = reducible a || reducible b

Soluciones en Python

from dataclasses import dataclass


@dataclass
class Expr:
    pass

@dataclass
class C(Expr):
    x: int

@dataclass
class V(Expr):
    x: str

@dataclass
class S(Expr):
    x: Expr
    y: Expr

@dataclass
class P(Expr):
    x: Expr
    y: Expr

def reducible(e: Expr) -> bool:
    match e:
        case C(_):
            return False
        case V(_):
            return False
        case S(C(_), C(_)):
            return True
        case S(a, b):
            return reducible(a) or reducible(b)
        case P(C(_), C(_)):
            return True
        case P(a, b):
            return reducible(a) or reducible(b)
    assert False

from dataclasses import dataclass

@dataclass

class Expr:

pass

@dataclass

class C(Expr):

x: int

@dataclass

class V(Expr):

x: str

@dataclass

class S(Expr):

x: Expr

y: Expr

@dataclass

class P(Expr):

x: Expr

y: Expr

def reducible(e: Expr) -> bool:

match e:

case C(_):

return False

case V(_):

return False

case S(C(_), C(_)):

return True

case S(a, b):

return reducible(a) or reducible(b)

case P(C(_), C(_)):

return True

case P(a, b):

return reducible(a) or reducible(b)

assert False

Sustitución en una expresión aritmética

PorJosé A. Alonso 13-enero-202330-diciembre-2022

Las expresiones aritméticas con variables pueden representarse usando el siguiente tipo de datos

   data Expr = C Int
             | V Char
             | S Expr Expr
             | P Expr Expr
     deriving (Eq, Show)

data Expr = C Int

| V Char

| S Expr Expr

| P Expr Expr

deriving (Eq, Show)

Por ejemplo, la expresión 2·(a+5) se representa por

   P (C 2) (S (V 'a') (C 5))

1	P (C 2) (S (V 'a') (C 5))

Definir la función

   sustitucion :: Expr -> [(Char, Int)] -> Expr

1	sustitucion :: Expr -> [(Char, Int)] -> Expr

tal que sustitucion e s es la expresión obtenida sustituyendo las variables de la expresión e según se indica en la sustitución s. Por ejemplo,

   λ> sustitucion (P (V 'z') (S (C 3) (V 'x'))) [('x',7),('z',9)]
   P (C 9) (S (C 3) (C 7))
   λ> sustitucion (P (V 'z') (S (C 3) (V 'y'))) [('x',7),('z',9)]
   P (C 9) (S (C 3) (V 'y'))

λ> sustitucion (P (V 'z') (S (C 3) (V 'x'))) [('x',7),('z',9)]

P (C 9) (S (C 3) (C 7))

λ> sustitucion (P (V 'z') (S (C 3) (V 'y'))) [('x',7),('z',9)]

P (C 9) (S (C 3) (V 'y'))

Soluciones

A continuación se muestran las soluciones en Haskell y las soluciones en Python.

Soluciones en Haskell

data Expr = C Int
          | V Char
          | S Expr Expr
          | P Expr Expr
  deriving (Eq, Show)

sustitucion :: Expr -> [(Char, Int)] -> Expr
sustitucion e []          = e
sustitucion (V c) ((d,n):ps)
  | c == d                = C n
  | otherwise             = sustitucion (V c) ps
sustitucion (C n) _      = C n
sustitucion (S e1 e2) ps = S (sustitucion e1 ps) (sustitucion e2 ps)
sustitucion (P e1 e2) ps = P (sustitucion e1 ps) (sustitucion e2 ps)

data Expr = C Int

| V Char

| S Expr Expr

| P Expr Expr

deriving (Eq, Show)

sustitucion :: Expr -> [(Char, Int)] -> Expr

sustitucion e [] = e

sustitucion (V c) ((d,n):ps)

| c == d = C n

| otherwise = sustitucion (V c) ps

sustitucion (C n) _ = C n

sustitucion (S e1 e2) ps = S (sustitucion e1 ps) (sustitucion e2 ps)

sustitucion (P e1 e2) ps = P (sustitucion e1 ps) (sustitucion e2 ps)

Soluciones en Python

from dataclasses import dataclass


@dataclass
class Expr:
    pass

@dataclass
class C(Expr):
    x: int

@dataclass
class V(Expr):
    x: str

@dataclass
class S(Expr):
    x: Expr
    y: Expr

@dataclass
class P(Expr):
    x: Expr
    y: Expr

def sustitucion(e: Expr, ps: list[tuple[str, int]]) -> Expr:
    match (e, ps):
        case(e, []):
            return e
        case (V(c), ps):
            if c == ps[0][0]:
                return C(ps[0][1])
            return sustitucion(V(c), ps[1:])
        case (C(n), _):
            return C(n)
        case (S(e1, e2), ps):
            return S(sustitucion(e1, ps), sustitucion(e2, ps))
        case (P(e1, e2), ps):
            return P(sustitucion(e1, ps), sustitucion(e2, ps))
    assert False

from dataclasses import dataclass

@dataclass

class Expr:

pass

@dataclass

class C(Expr):

x: int

@dataclass

class V(Expr):

x: str

@dataclass

class S(Expr):

x: Expr

y: Expr

@dataclass

class P(Expr):

x: Expr

y: Expr

def sustitucion(e: Expr, ps: list[tuple[str, int]]) -> Expr:

match (e, ps):

case(e, []):

return e

case (V(c), ps):

if c == ps[0][0]:

return C(ps[0][1])

return sustitucion(V(c), ps[1:])

case (C(n), _):

return C(n)

case (S(e1, e2), ps):

return S(sustitucion(e1, ps), sustitucion(e2, ps))

case (P(e1, e2), ps):

return P(sustitucion(e1, ps), sustitucion(e2, ps))

assert False

Número de sumas en una expresión aritmética

PorJosé A. Alonso 12-enero-202330-diciembre-2022

Las expresiones aritméticas con variables pueden representarse usando el siguiente tipo de datos

   data Expr = C Int
             | V Char
             | S Expr Expr
             | P Expr Expr

data Expr = C Int

| V Char

| S Expr Expr

| P Expr Expr

Por ejemplo, la expresión 2·(a+5) se representa por

   P (C 2) (S (V 'a') (C 5))

1	P (C 2) (S (V 'a') (C 5))

Definir la función

   sumas :: Expr -> Int

1	sumas :: Expr -> Int

tal que sumas e es el número de sumas en la expresión e. Por ejemplo,

   sumas (P (V 'z') (S (C 3) (V 'x')))  ==  1
   sumas (S (V 'z') (S (C 3) (V 'x')))  ==  2
   sumas (P (V 'z') (P (C 3) (V 'x')))  ==  0

sumas (P (V 'z') (S (C 3) (V 'x'))) == 1

sumas (S (V 'z') (S (C 3) (V 'x'))) == 2

sumas (P (V 'z') (P (C 3) (V 'x'))) == 0

Soluciones

A continuación se muestran las soluciones en Haskell y las soluciones en Python.

Soluciones en Haskell

data Expr = C Int
          | V Char
          | S Expr Expr
          | P Expr Expr

sumas :: Expr -> Int
sumas (V _)   = 0
sumas (C _)   = 0
sumas (S x y) = 1 + sumas x + sumas y
sumas (P x y) = sumas x + sumas y

data Expr = C Int

| V Char

| S Expr Expr

| P Expr Expr

sumas :: Expr -> Int

sumas (V _) = 0

sumas (C _) = 0

sumas (S x y) = 1 + sumas x + sumas y

sumas (P x y) = sumas x + sumas y

Soluciones en Python

from dataclasses import dataclass


@dataclass
class Expr:
    pass

@dataclass
class C(Expr):
    x: int

@dataclass
class V(Expr):
    x: str

@dataclass
class S(Expr):
    x: Expr
    y: Expr

@dataclass
class P(Expr):
    x: Expr
    y: Expr

def sumas(e: Expr) -> int:
    match e:
        case C(a):
            return 0
        case V(x):
            return 0
        case S(e1, e2):
            return 1 + sumas(e1) + sumas(e2)
        case P(e1, e2):
            return sumas(e1) + sumas(e2)
    assert False

from dataclasses import dataclass

@dataclass

class Expr:

pass

@dataclass

class C(Expr):

x: int

@dataclass

class V(Expr):

x: str

@dataclass

class S(Expr):

x: Expr

y: Expr

@dataclass

class P(Expr):

x: Expr

y: Expr

def sumas(e: Expr) -> int:

match e:

case C(a):

return 0

case V(x):

return 0

case S(e1, e2):

return 1 + sumas(e1) + sumas(e2)

case P(e1, e2):

return sumas(e1) + sumas(e2)

assert False

Valor de una expresión aritmética con variables

PorJosé A. Alonso 11-enero-202330-diciembre-2022

Las expresiones aritméticas con variables pueden representarse usando el siguiente tipo de datos

   data Expr = C Int
             | V Char
             | S Expr Expr
             | P Expr Expr

data Expr = C Int

| V Char

| S Expr Expr

| P Expr Expr

Por ejemplo, la expresión 2·(a+5) se representa por

   P (C 2) (S (V 'a') (C 5))

1	P (C 2) (S (V 'a') (C 5))

Definir la función

   valor :: Expr -> [(Char,Int)] -> Int

1	valor :: Expr -> [(Char,Int)] -> Int

tal que valor x e es el valor de la expresión x en el entorno e (es decir, el valor de la expresión donde las variables de x se sustituyen por los valores según se indican en el entorno e). Por ejemplo,

   λ> valor (P (C 2) (S (V 'a') (V 'b'))) [('a',2),('b',5)]
   14

1 2	λ> valor (P (C 2) (S (V 'a') (V 'b'))) [('a',2),('b',5)] 14

Soluciones

A continuación se muestran las soluciones en Haskell y las soluciones en Python.

Soluciones en Haskell

data Expr = C Int
          | V Char
          | S Expr Expr
          | P Expr Expr

valor :: Expr -> [(Char,Int)] -> Int
valor (C x)   _ = x
valor (V x)   e = head [y | (z,y) <- e, z == x]
valor (S x y) e = valor x e + valor y e
valor (P x y) e = valor x e * valor y e

data Expr = C Int

| V Char

| S Expr Expr

| P Expr Expr

valor :: Expr -> [(Char,Int)] -> Int

valor (C x) _ = x

valor (V x) e = head [y | (z,y) <- e, z == x]

valor (S x y) e = valor x e + valor y e

valor (P x y) e = valor x e * valor y e

Soluciones en Python

from dataclasses import dataclass


@dataclass
class Expr:
    pass

@dataclass
class C(Expr):
    x: int

@dataclass
class V(Expr):
    x: str

@dataclass
class S(Expr):
    x: Expr
    y: Expr

@dataclass
class P(Expr):
    x: Expr
    y: Expr

def valor(e: Expr, xs: list[tuple[str, int]]) -> int:
    match e:
        case C(a):
            return a
        case V(x):
            return [y for (z, y) in xs if z == x][0]
        case S(e1, e2):
            return valor(e1, xs) + valor(e2, xs)
        case P(e1, e2):
            return valor(e1, xs) * valor(e2, xs)
    assert False

from dataclasses import dataclass

@dataclass

class Expr:

pass

@dataclass

class C(Expr):

x: int

@dataclass

class V(Expr):

x: str

@dataclass

class S(Expr):

x: Expr

y: Expr

@dataclass

class P(Expr):

x: Expr

y: Expr

def valor(e: Expr, xs: list[tuple[str, int]]) -> int:

match e:

case C(a):

return a

case V(x):

return [y for (z, y) in xs if z == x][0]

case S(e1, e2):

return valor(e1, xs) + valor(e2, xs)

case P(e1, e2):

return valor(e1, xs) * valor(e2, xs)

assert False

El tipo de las expresiones aritméticas con variables

PorJosé A. Alonso 11-enero-202326-abril-2023

1. El tipo de las expresiones aritméticas con variables en Haskell

La expresión 2*(a+5) puede representarse por

   P (C 2) (S (V 'a') (C 5))

1	P (C 2) (S (V 'a') (C 5))

usando el tipo de las expresiones aritméticas con variables definido como se muestra a continuación.

module Expresion_aritmetica_con_variables where

data Expr = C Int
          | V Char
          | S Expr Expr
          | P Expr Expr
  deriving (Eq, Show)

module Expresion_aritmetica_con_variables where

data Expr = C Int

| V Char

| S Expr Expr

| P Expr Expr

deriving (Eq, Show)

2. El tipo de las expresiones aritméticas con variables en Python

La expresión 2*(a+5) puede representarse por

   P(C(2), S(V('a'), C(5)))

1	P(C(2), S(V('a'), C(5)))

usando el tipo de las expresiones aritméticas con variables definido como se muestra a continuación.

from dataclasses import dataclass


@dataclass
class Expr:
    pass

@dataclass
class C(Expr):
    x: int

@dataclass
class V(Expr):
    x: str

@dataclass
class S(Expr):
    x: Expr
    y: Expr

@dataclass
class P(Expr):
    x: Expr
    y: Expr

from dataclasses import dataclass

@dataclass

class Expr:

pass

@dataclass

class C(Expr):

x: int

@dataclass

class V(Expr):

x: str

@dataclass

class S(Expr):

x: Expr

y: Expr

@dataclass

class P(Expr):

x: Expr

y: Expr

Número de variables de una expresión aritmética

PorJosé A. Alonso 10-enero-202330-diciembre-2022

Las expresiones aritméticas construidas con una variable (denotada por X), los números enteros y las operaciones de sumar y multiplicar se pueden representar mediante el tipo de datos Expr definido por

   data Expr = X
             | C Int
             | S Expr Expr
             | P Expr Expr

data Expr = X

| C Int

| S Expr Expr

| P Expr Expr

Por ejemplo, la expresión X·(13+X) se representa por

   P X (S (C 13) X)

1	P X (S (C 13) X)

Definir la función

   numVars :: Expr -> Int

1	numVars :: Expr -> Int

tal que numVars e es el número de variables en la expresión e. Por ejemplo,

   numVars (C 3)               ==  0
   numVars X                   ==  1
   numVars (P X (S (C 13) X))  ==  2

numVars (C 3) == 0

numVars X == 1

numVars (P X (S (C 13) X)) == 2

Soluciones

A continuación se muestran las soluciones en Haskell y las soluciones en Python.

Soluciones en Haskell

data Expr = X
          | C Int
          | S Expr Expr
          | P Expr Expr

numVars :: Expr -> Int
numVars X       = 1
numVars (C _)   = 0
numVars (S a b) = numVars a + numVars b
numVars (P a b) = numVars a + numVars b

data Expr = X

| C Int

| S Expr Expr

| P Expr Expr

numVars :: Expr -> Int

numVars X = 1

numVars (C _) = 0

numVars (S a b) = numVars a + numVars b

numVars (P a b) = numVars a + numVars b

Soluciones en Python

from dataclasses import dataclass


@dataclass
class Expr:
    pass

@dataclass
class X(Expr):
    pass

@dataclass
class C(Expr):
    x: int

@dataclass
class S(Expr):
    x: Expr
    y: Expr

@dataclass
class P(Expr):
    x: Expr
    y: Expr

def numVars(e: Expr) -> int:
    match e:
        case X():
            return 1
        case C(_):
            return 0
        case S(e1, e2):
            return numVars(e1) + numVars(e2)
        case P(e1, e2):
            return numVars(e1) + numVars(e2)
    assert False

from dataclasses import dataclass

@dataclass

class Expr:

pass

@dataclass

class X(Expr):

pass

@dataclass

class C(Expr):

x: int

@dataclass

class S(Expr):

x: Expr

y: Expr

@dataclass

class P(Expr):

x: Expr

y: Expr

def numVars(e: Expr) -> int:

match e:

case X():

return 1

case C(_):

return 0

case S(e1, e2):

return numVars(e1) + numVars(e2)

case P(e1, e2):

return numVars(e1) + numVars(e2)

assert False

Valor de una expresión aritmética con una variable

PorJosé A. Alonso 9-enero-202330-diciembre-2022

   data Expr = X
             | C Int
             | S Expr Expr
             | P Expr Expr

data Expr = X

| C Int

| S Expr Expr

| P Expr Expr

Por ejemplo, la expresión X·(13+X) se representa por

   P X (S (C 13) X)

1	P X (S (C 13) X)

Definir la función

   valor :: Expr -> Int -> Int

1	valor :: Expr -> Int -> Int

tal que valor e n es el valor de la expresión e cuando se sustituye su variable por n. Por ejemplo,

   valor (P X (S (C 13) X)) 2  ==  30

1	valor (P X (S (C 13) X)) 2 == 30

Soluciones

A continuación se muestran las soluciones en Haskell y las soluciones en Python.

Soluciones en Haskell

data Expr = X
          | C Int
          | S Expr Expr
          | P Expr Expr

valor :: Expr -> Int -> Int
valor X         n = n
valor (C a)     _ = a
valor (S e1 e2) n = valor e1 n + valor e2 n
valor (P e1 e2) n = valor e1 n * valor e2 n

data Expr = X

| C Int

| S Expr Expr

| P Expr Expr

valor :: Expr -> Int -> Int

valor X n = n

valor (C a) _ = a

valor (S e1 e2) n = valor e1 n + valor e2 n

valor (P e1 e2) n = valor e1 n * valor e2 n

Soluciones en Python

from dataclasses import dataclass


@dataclass
class Expr:
    pass

@dataclass
class X(Expr):
    pass

@dataclass
class C(Expr):
    x: int

@dataclass
class S(Expr):
    x: Expr
    y: Expr

@dataclass
class P(Expr):
    x: Expr
    y: Expr

def valor(e: Expr, n: int) -> int:
    match e:
        case X():
            return n
        case C(a):
            return a
        case S(e1, e2):
            return valor(e1, n) + valor(e2, n)
        case P(e1, e2):
            return valor(e1, n) * valor(e2, n)
    assert False

from dataclasses import dataclass

@dataclass

class Expr:

pass

@dataclass

class X(Expr):

pass

@dataclass

class C(Expr):

x: int

@dataclass

class S(Expr):

x: Expr

y: Expr

@dataclass

class P(Expr):

x: Expr

y: Expr

def valor(e: Expr, n: int) -> int:

match e:

case X():

return n

case C(a):

return a

case S(e1, e2):

return valor(e1, n) + valor(e2, n)

case P(e1, e2):

return valor(e1, n) * valor(e2, n)

assert False

Tipo de expresiones aritméticas con una variable

PorJosé A. Alonso 9-enero-202320-abril-2023

1. El tipo de las expresiones aritméticas con una variable en Haskell

La expresión X·(13+X) se representa por

   P(X(), S(C(13), X()))

1	P(X(), S(C(13), X()))

usando el tipo de las expresiones aritméticas con una variable (denotada por X) que se define como se muestra a continuación,

data Expr = C Int
          | V Char
          | S Expr Expr
          | P Expr Expr

data Expr = C Int

| V Char

| S Expr Expr

| P Expr Expr

2. El tipo de las expresiones aritméticas con una variable en Python

La expresión X*(13+X) se representa por

   P(X(), S(C(13), X()))

1	P(X(), S(C(13), X()))

usando el tipo de las expresiones aritméticas con una variable (denotada por X) que se define como se muestra a continuación,

from dataclasses import dataclass


@dataclass
class Expr:
    pass

@dataclass
class X(Expr):
    pass

@dataclass
class C(Expr):
    x: int

@dataclass
class S(Expr):
    x: Expr
    y: Expr

@dataclass
class P(Expr):
    x: Expr
    y: Expr

from dataclasses import dataclass

@dataclass

class Expr:

pass

@dataclass

class X(Expr):

pass

@dataclass

class C(Expr):

x: int

@dataclass

class S(Expr):

x: Expr

y: Expr

@dataclass

class P(Expr):

x: Expr

y: Expr

Valor de expresiones aritméticas generales

Máximos valores de una expresión aritmética

Expresiones aritméticas reducibles

Sustitución en una expresión aritmética

Número de sumas en una expresión aritmética

Valor de una expresión aritmética con variables

El tipo de las expresiones aritméticas con variables

1. El tipo de las expresiones aritméticas con variables en Haskell

2. El tipo de las expresiones aritméticas con variables en Python

Número de variables de una expresión aritmética

Valor de una expresión aritmética con una variable

Tipo de expresiones aritméticas con una variable

1. El tipo de las expresiones aritméticas con una variable en Haskell

2. El tipo de las expresiones aritméticas con una variable en Python

Entradas recientes

Buscar

Correo electrónico