{"id":7876,"date":"2023-01-14T09:02:01","date_gmt":"2023-01-14T08:02:01","guid":{"rendered":"https:\/\/www.glc.us.es\/~jalonso\/vestigium\/?p=7876"},"modified":"2023-01-14T09:02:01","modified_gmt":"2023-01-14T08:02:01","slug":"14-ene-23","status":"publish","type":"post","link":"https:\/\/www.glc.us.es\/~jalonso\/vestigium\/14-ene-23\/","title":{"rendered":"PFH: La semana en Exercitium (14 de enero de 2023)"},"content":{"rendered":"<p>Esta semana he publicado en <a href=\"http:\/\/bit.ly\/2sqPtGs\">Exercitium<\/a> las soluciones de los siguientes problemas:<\/p>\n<ul>\n<li><a href=\"#ej1\">1. Valor de una expresi\u00f3n aritm\u00e9tica con una variable<\/a><\/li>\n<li><a href=\"#ej2\">2. N\u00famero de variables de una expresi\u00f3n aritm\u00e9tica<\/a><\/li>\n<li><a href=\"#ej3\">3. Valor de una expresi\u00f3n aritm\u00e9tica con variables<\/a><\/li>\n<li><a href=\"#ej4\">4. N\u00famero de sumas en una expresi\u00f3n aritm\u00e9tica<\/a><\/li>\n<li><a href=\"#ej5\">5. Sustituci\u00f3n en una expresi\u00f3n aritm\u00e9tica<\/a><\/li>\n<\/ul>\n<p>A continuaci\u00f3n se muestran las soluciones.<br \/>\n<!--more--><br \/>\n<a name=\"ej1\"><\/a><\/p>\n<h3>1. Valor de una expresi\u00f3n aritm\u00e9tica con una variable<\/h3>\n<p>Las expresiones aritm\u00e9ticas construidas con una variable (denotada por <code>X<\/code>), los n\u00fameros enteros y las operaciones de sumar y multiplicar se pueden representar mediante el tipo de datos Expr definido por<\/p>\n<pre lang=\"text\">\n   data Expr = X\n             | C Int\n             | S Expr Expr\n             | P Expr Expr\n<\/pre>\n<p>Por ejemplo, la expresi\u00f3n <code>X\u00b7(13+X)<\/code> se representa por<\/p>\n<pre lang=\"text\">\n   P X (S (C 13) X)\n<\/pre>\n<p>Definir la funci\u00f3n<\/p>\n<pre lang=\"text\">\n   valor :: Expr -> Int -> Int\n<\/pre>\n<p>tal que <code>valor e n<\/code> es el valor de la expresi\u00f3n <code>e<\/code> cuando se sustituye su variable por <code>n<\/code>. Por ejemplo,<\/p>\n<pre lang=\"text\">\n   valor (P X (S (C 13) X)) 2  ==  30\n<\/pre>\n<p><b>Soluciones<\/b><\/p>\n<p>A continuaci\u00f3n se muestran las <a href=\"#haskell\">soluciones en Haskell<\/a> y las <a href=\"#python\">soluciones en Python<\/a>.<\/p>\n<p><a name=\"haskell\"><\/a><br \/>\n<b>Soluciones en Haskell<\/b><\/p>\n<pre lang=\"haskell\">\ndata Expr = X\n          | C Int\n          | S Expr Expr\n          | P Expr Expr\n\nvalor :: Expr -> Int -> Int\nvalor X         n = n\nvalor (C a)     _ = a\nvalor (S e1 e2) n = valor e1 n + valor e2 n\nvalor (P e1 e2) n = valor e1 n * valor e2 n\n<\/pre>\n<p><a name=\"python\"><\/a><br \/>\n<b>Soluciones en Python<\/b><\/p>\n<pre lang=\"python\">\nfrom dataclasses import dataclass\n\n\n@dataclass\nclass Expr:\n    pass\n\n@dataclass\nclass X(Expr):\n    pass\n\n@dataclass\nclass C(Expr):\n    x: int\n\n@dataclass\nclass S(Expr):\n    x: Expr\n    y: Expr\n\n@dataclass\nclass P(Expr):\n    x: Expr\n    y: Expr\n\ndef valor(e: Expr, n: int) -> int:\n    match e:\n        case X():\n            return n\n        case C(a):\n            return a\n        case S(e1, e2):\n            return valor(e1, n) + valor(e2, n)\n        case P(e1, e2):\n            return valor(e1, n) * valor(e2, n)\n    assert False\n<\/pre>\n<p><a name=\"ej2\"><\/a><\/p>\n<h3>2. N\u00famero de variables de una expresi\u00f3n aritm\u00e9tica<\/h3>\n<p>Las expresiones aritm\u00e9ticas construidas con una variable (denotada por <code>X<\/code>), los n\u00fameros enteros y las operaciones de sumar y multiplicar se pueden representar mediante el tipo de datos Expr definido por<\/p>\n<pre lang=\"text\">\n   data Expr = X\n             | C Int\n             | S Expr Expr\n             | P Expr Expr\n<\/pre>\n<p>Por ejemplo, la expresi\u00f3n <code>X\u00b7(13+X)<\/code> se representa por<\/p>\n<pre lang=\"text\">\n   P X (S (C 13) X)\n<\/pre>\n<p>Definir la funci\u00f3n<\/p>\n<pre lang=\"text\">\n   numVars :: Expr -> Int\n<\/pre>\n<p>tal que <code>numVars e<\/code> es el n\u00famero de variables en la expresi\u00f3n <code>e<\/code>. Por ejemplo,<\/p>\n<pre lang=\"text\">\n   numVars (C 3)               ==  0\n   numVars X                   ==  1\n   numVars (P X (S (C 13) X))  ==  2\n<\/pre>\n<p><b>Soluciones<\/b><\/p>\n<p>A continuaci\u00f3n se muestran las <a href=\"#haskell\">soluciones en Haskell<\/a> y las <a href=\"#python\">soluciones en Python<\/a>.<\/p>\n<p><a name=\"haskell\"><\/a><br \/>\n<b>Soluciones en Haskell<\/b><\/p>\n<pre lang=\"haskell\">\ndata Expr = X\n          | C Int\n          | S Expr Expr\n          | P Expr Expr\n\nnumVars :: Expr -> Int\nnumVars X       = 1\nnumVars (C _)   = 0\nnumVars (S a b) = numVars a + numVars b\nnumVars (P a b) = numVars a + numVars b\n<\/pre>\n<p><a name=\"python\"><\/a><br \/>\n<b>Soluciones en Python<\/b><\/p>\n<pre lang=\"python\">\nfrom dataclasses import dataclass\n\n\n@dataclass\nclass Expr:\n    pass\n\n@dataclass\nclass X(Expr):\n    pass\n\n@dataclass\nclass C(Expr):\n    x: int\n\n@dataclass\nclass S(Expr):\n    x: Expr\n    y: Expr\n\n@dataclass\nclass P(Expr):\n    x: Expr\n    y: Expr\n\ndef numVars(e: Expr) -> int:\n    match e:\n        case X():\n            return 1\n        case C(_):\n            return 0\n        case S(e1, e2):\n            return numVars(e1) + numVars(e2)\n        case P(e1, e2):\n            return numVars(e1) + numVars(e2)\n    assert False\n<\/pre>\n<p><a name=\"ej3\"><\/a><\/p>\n<h3>3. Valor de una expresi\u00f3n aritm\u00e9tica con variables<\/h3>\n<p>Las expresiones aritm\u00e9ticas con variables pueden representarse usando el siguiente tipo de datos<\/p>\n<pre lang=\"text\">\n   data Expr = C Int\n             | V Char\n             | S Expr Expr\n             | P Expr Expr\n<\/pre>\n<p>Por ejemplo, la expresi\u00f3n <code>2\u00b7(a+5)<\/code> se representa por<\/p>\n<pre lang=\"text\">\n   P (C 2) (S (V 'a') (C 5))\n<\/pre>\n<p>Definir la funci\u00f3n<\/p>\n<pre lang=\"text\">\n   valor :: Expr -> [(Char,Int)] -> Int\n<\/pre>\n<p>tal que <code>valor x e<\/code> es el valor de la expresi\u00f3n <code>x<\/code> en el entorno <code>e<\/code> (es decir, el valor de la expresi\u00f3n donde las variables de <code>x<\/code> se sustituyen por los valores seg\u00fan se indican en el entorno <code>e<\/code>). Por ejemplo,<\/p>\n<pre lang=\"text\">\n   \u03bb> valor (P (C 2) (S (V 'a') (V 'b'))) [('a',2),('b',5)]\n   14\n<\/pre>\n<p><b>Soluciones<\/b><\/p>\n<p>A continuaci\u00f3n se muestran las <a href=\"#haskell\">soluciones en Haskell<\/a> y las <a href=\"#python\">soluciones en Python<\/a>.<\/p>\n<p><a name=\"haskell\"><\/a><br \/>\n<b>Soluciones en Haskell<\/b><\/p>\n<pre lang=\"haskell\">\ndata Expr = C Int\n          | V Char\n          | S Expr Expr\n          | P Expr Expr\n\nvalor :: Expr -> [(Char,Int)] -> Int\nvalor (C x)   _ = x\nvalor (V x)   e = head [y | (z,y) <- e, z == x]\nvalor (S x y) e = valor x e + valor y e\nvalor (P x y) e = valor x e * valor y e\n<\/pre>\n<p><a name=\"python\"><\/a><br \/>\n<b>Soluciones en Python<\/b><\/p>\n<pre lang=\"python\">\nfrom dataclasses import dataclass\n\n\n@dataclass\nclass Expr:\n    pass\n\n@dataclass\nclass C(Expr):\n    x: int\n\n@dataclass\nclass V(Expr):\n    x: str\n\n@dataclass\nclass S(Expr):\n    x: Expr\n    y: Expr\n\n@dataclass\nclass P(Expr):\n    x: Expr\n    y: Expr\n\ndef valor(e: Expr, xs: list[tuple[str, int]]) -> int:\n    match e:\n        case C(a):\n            return a\n        case V(x):\n            return [y for (z, y) in xs if z == x][0]\n        case S(e1, e2):\n            return valor(e1, xs) + valor(e2, xs)\n        case P(e1, e2):\n            return valor(e1, xs) * valor(e2, xs)\n    assert False\n<\/pre>\n<p><a name=\"ej4\"><\/a><\/p>\n<h3>4. N\u00famero de sumas en una expresi\u00f3n aritm\u00e9tica<\/h3>\n<p>Las expresiones aritm\u00e9ticas con variables pueden representarse usando el siguiente tipo de datos<\/p>\n<pre lang=\"text\">\n   data Expr = C Int\n             | V Char\n             | S Expr Expr\n             | P Expr Expr\n<\/pre>\n<p>Por ejemplo, la expresi\u00f3n <code>2\u00b7(a+5)<\/code> se representa por<\/p>\n<pre lang=\"text\">\n   P (C 2) (S (V 'a') (C 5))\n<\/pre>\n<p>Definir la funci\u00f3n<\/p>\n<pre lang=\"text\">\n   sumas :: Expr -> Int\n<\/pre>\n<p>tal que <code>sumas e<\/code> es el n\u00famero de sumas en la expresi\u00f3n <code>e<\/code>. Por ejemplo,<\/p>\n<pre lang=\"text\">\n   sumas (P (V 'z') (S (C 3) (V 'x')))  ==  1\n   sumas (S (V 'z') (S (C 3) (V 'x')))  ==  2\n   sumas (P (V 'z') (P (C 3) (V 'x')))  ==  0\n<\/pre>\n<p><b>Soluciones<\/b><\/p>\n<p>A continuaci\u00f3n se muestran las <a href=\"#haskell\">soluciones en Haskell<\/a> y las <a href=\"#python\">soluciones en Python<\/a>.<\/p>\n<p><a name=\"haskell\"><\/a><br \/>\n<b>Soluciones en Haskell<\/b><\/p>\n<pre lang=\"haskell\">\ndata Expr = C Int\n          | V Char\n          | S Expr Expr\n          | P Expr Expr\n\nsumas :: Expr -> Int\nsumas (V _)   = 0\nsumas (C _)   = 0\nsumas (S x y) = 1 + sumas x + sumas y\nsumas (P x y) = sumas x + sumas y\n<\/pre>\n<p><a name=\"python\"><\/a><br \/>\n<b>Soluciones en Python<\/b><\/p>\n<pre lang=\"python\">\nfrom dataclasses import dataclass\n\n\n@dataclass\nclass Expr:\n    pass\n\n@dataclass\nclass C(Expr):\n    x: int\n\n@dataclass\nclass V(Expr):\n    x: str\n\n@dataclass\nclass S(Expr):\n    x: Expr\n    y: Expr\n\n@dataclass\nclass P(Expr):\n    x: Expr\n    y: Expr\n\ndef sumas(e: Expr) -> int:\n    match e:\n        case C(a):\n            return 0\n        case V(x):\n            return 0\n        case S(e1, e2):\n            return 1 + sumas(e1) + sumas(e2)\n        case P(e1, e2):\n            return sumas(e1) + sumas(e2)\n    assert False\n<\/pre>\n<p><a name=\"ej5\"><\/a><\/p>\n<h3>5. Sustituci\u00f3n en una expresi\u00f3n aritm\u00e9tica<\/h3>\n<p>Las expresiones aritm\u00e9ticas con variables pueden representarse usando el siguiente tipo de datos<\/p>\n<pre lang=\"text\">\n   data Expr = C Int\n             | V Char\n             | S Expr Expr\n             | P Expr Expr\n     deriving (Eq, Show)\n<\/pre>\n<p>Por ejemplo, la expresi\u00f3n <code>2\u00b7(a+5)<\/code> se representa por<\/p>\n<pre lang=\"text\">\n   P (C 2) (S (V 'a') (C 5))\n<\/pre>\n<p>Definir la funci\u00f3n<\/p>\n<pre lang=\"text\">\n   sustitucion :: Expr -> [(Char, Int)] -> Expr\n<\/pre>\n<p>tal que <code>sustitucion e s<\/code> es la expresi\u00f3n obtenida sustituyendo las variables de la expresi\u00f3n <code>e<\/code> seg\u00fan se indica en la sustituci\u00f3n <code>s<\/code>. Por ejemplo,<\/p>\n<pre lang=\"text\">\n   \u03bb> sustitucion (P (V 'z') (S (C 3) (V 'x'))) [('x',7),('z',9)]\n   P (C 9) (S (C 3) (C 7))\n   \u03bb> sustitucion (P (V 'z') (S (C 3) (V 'y'))) [('x',7),('z',9)]\n   P (C 9) (S (C 3) (V 'y'))\n<\/pre>\n<p><b>Soluciones<\/b><\/p>\n<p>A continuaci\u00f3n se muestran las <a href=\"#haskell\">soluciones en Haskell<\/a> y las <a href=\"#python\">soluciones en Python<\/a>.<\/p>\n<p><a name=\"haskell\"><\/a><br \/>\n<b>Soluciones en Haskell<\/b><\/p>\n<pre lang=\"haskell\">\ndata Expr = C Int\n          | V Char\n          | S Expr Expr\n          | P Expr Expr\n  deriving (Eq, Show)\n\nsustitucion :: Expr -> [(Char, Int)] -> Expr\nsustitucion e []          = e\nsustitucion (V c) ((d,n):ps)\n  | c == d                = C n\n  | otherwise             = sustitucion (V c) ps\nsustitucion (C n) _      = C n\nsustitucion (S e1 e2) ps = S (sustitucion e1 ps) (sustitucion e2 ps)\nsustitucion (P e1 e2) ps = P (sustitucion e1 ps) (sustitucion e2 ps)\n<\/pre>\n<p><a name=\"python\"><\/a><br \/>\n<b>Soluciones en Python<\/b><\/p>\n<pre lang=\"python\">\nfrom dataclasses import dataclass\n\n\n@dataclass\nclass Expr:\n    pass\n\n@dataclass\nclass C(Expr):\n    x: int\n\n@dataclass\nclass V(Expr):\n    x: str\n\n@dataclass\nclass S(Expr):\n    x: Expr\n    y: Expr\n\n@dataclass\nclass P(Expr):\n    x: Expr\n    y: Expr\n\ndef sustitucion(e: Expr, ps: list[tuple[str, int]]) -> Expr:\n    match (e, ps):\n        case(e, []):\n            return e\n        case (V(c), ps):\n            if c == ps[0][0]:\n                return C(ps[0][1])\n            return sustitucion(V(c), ps[1:])\n        case (C(n), _):\n            return C(n)\n        case (S(e1, e2), ps):\n            return S(sustitucion(e1, ps), sustitucion(e2, ps))\n        case (P(e1, e2), ps):\n            return P(sustitucion(e1, ps), sustitucion(e2, ps))\n    assert False\n<\/pre>\n","protected":false},"excerpt":{"rendered":"<p>Esta semana he publicado en Exercitium las soluciones de los siguientes problemas: 1. Valor de una expresi\u00f3n aritm\u00e9tica con una variable 2. N\u00famero de variables de una expresi\u00f3n aritm\u00e9tica 3. Valor de una expresi\u00f3n aritm\u00e9tica con variables 4. N\u00famero de sumas en una expresi\u00f3n aritm\u00e9tica 5. Sustituci\u00f3n en una expresi\u00f3n aritm\u00e9tica A continuaci\u00f3n se muestran&#8230;<\/p>\n","protected":false},"author":2,"featured_media":0,"comment_status":"closed","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"jetpack_post_was_ever_published":false,"_kad_post_transparent":"","_kad_post_title":"","_kad_post_layout":"","_kad_post_sidebar_id":"","_kad_post_content_style":"","_kad_post_vertical_padding":"","_kad_post_feature":"","_kad_post_feature_position":"","_kad_post_header":false,"_kad_post_footer":false,"_jetpack_newsletter_access":"","_jetpack_dont_email_post_to_subs":false,"_jetpack_newsletter_tier_id":0,"_jetpack_memberships_contains_paywalled_content":false,"footnotes":"","_jetpack_memberships_contains_paid_content":false},"categories":[337],"tags":[],"jetpack_featured_media_url":"","jetpack_sharing_enabled":true,"jetpack_likes_enabled":false,"_links":{"self":[{"href":"https:\/\/www.glc.us.es\/~jalonso\/vestigium\/wp-json\/wp\/v2\/posts\/7876"}],"collection":[{"href":"https:\/\/www.glc.us.es\/~jalonso\/vestigium\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.glc.us.es\/~jalonso\/vestigium\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.glc.us.es\/~jalonso\/vestigium\/wp-json\/wp\/v2\/users\/2"}],"replies":[{"embeddable":true,"href":"https:\/\/www.glc.us.es\/~jalonso\/vestigium\/wp-json\/wp\/v2\/comments?post=7876"}],"version-history":[{"count":1,"href":"https:\/\/www.glc.us.es\/~jalonso\/vestigium\/wp-json\/wp\/v2\/posts\/7876\/revisions"}],"predecessor-version":[{"id":7877,"href":"https:\/\/www.glc.us.es\/~jalonso\/vestigium\/wp-json\/wp\/v2\/posts\/7876\/revisions\/7877"}],"wp:attachment":[{"href":"https:\/\/www.glc.us.es\/~jalonso\/vestigium\/wp-json\/wp\/v2\/media?parent=7876"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.glc.us.es\/~jalonso\/vestigium\/wp-json\/wp\/v2\/categories?post=7876"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.glc.us.es\/~jalonso\/vestigium\/wp-json\/wp\/v2\/tags?post=7876"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}