Valor de una expresión vectorial
Se consideran las expresiones vectoriales formadas por un vector, la suma de dos expresiones vectoriales o el producto de un entero por una expresión vectorial. El siguiente tipo de dato define las expresiones vectoriales
|
1 2 3 4 |
data ExpV = Vec Int Int | Sum ExpV ExpV | Mul Int ExpV deriving Show |
Definir la función
|
1 |
valorEV :: ExpV -> (Int,Int) |
tal que valorEV e es el valorEV de la expresión vectorial e. Por ejemplo,
|
1 2 3 4 5 |
valorEV (Vec 1 2) == (1,2) valorEV (Sum (Vec 1 2) (Vec 3 4)) == (4,6) valorEV (Mul 2 (Vec 3 4)) == (6,8) valorEV (Mul 2 (Sum (Vec 1 2 ) (Vec 3 4))) == (8,12) valorEV (Sum (Mul 2 (Vec 1 2)) (Mul 2 (Vec 3 4))) == (8,12) |
Soluciones
A continuación se muestran las soluciones en Haskell y las soluciones en Python.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 |
data ExpV = Vec Int Int | Sum ExpV ExpV | Mul Int ExpV deriving Show -- 1ª solución -- =========== valorEV1 :: ExpV -> (Int,Int) valorEV1 (Vec x y) = (x,y) valorEV1 (Sum e1 e2) = (x1+x2,y1+y2) where (x1,y1) = valorEV1 e1 (x2,y2) = valorEV1 e2 valorEV1 (Mul n e) = (n*x,n*y) where (x,y) = valorEV1 e -- 2ª solución -- =========== valorEV2 :: ExpV -> (Int,Int) valorEV2 (Vec a b) = (a, b) valorEV2 (Sum e1 e2) = suma (valorEV2 e1) (valorEV2 e2) valorEV2 (Mul n e1) = multiplica n (valorEV2 e1) suma :: (Int,Int) -> (Int,Int) -> (Int,Int) suma (a,b) (c,d) = (a+c,b+d) multiplica :: Int -> (Int, Int) -> (Int, Int) multiplica n (a,b) = (n*a,n*b) |
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 |
from dataclasses import dataclass @dataclass class ExpV: pass @dataclass class Vec(ExpV): x: int y: int @dataclass class Sum(ExpV): x: ExpV y: ExpV @dataclass class Mul(ExpV): x: int y: ExpV # 1ª solución # =========== def valorEV1(e: ExpV) -> tuple[int, int]: match e: case Vec(x, y): return (x, y) case Sum(e1, e2): x1, y1 = valorEV1(e1) x2, y2 = valorEV1(e2) return (x1 + x2, y1 + y2) case Mul(n, e): x, y = valorEV1(e) return (n * x, n * y) assert False # 2ª solución # =========== def suma(p: tuple[int, int], q: tuple[int, int]) -> tuple[int, int]: a, b = p c, d = q return (a + c, b + d) def multiplica(n: int, p: tuple[int, int]) -> tuple[int, int]: a, b = p return (n * a, n * b) def valorEV2(e: ExpV) -> tuple[int, int]: match e: case Vec(x, y): return (x, y) case Sum(e1, e2): return suma(valorEV2(e1), valorEV2(e2)) case Mul(n, e): return multiplica(n, valorEV2(e)) assert False |
La función valorEV puede ser definida usando un patrón match en el tipo ExpV:
Cada caso es tratado de manera diferente dependiendo del tipo de dato que se recibe. En el caso de Vec, se devuelve directamente el vector. En el caso de Sum, se suman los valores de las dos expresiones vectoriales. En el caso de Mul, se multiplican los valores de la expresión vectorial por el entero recibido.