Expresiones aritméticas

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

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

Entradas recientes

Buscar

Correo electrónico