{"id":8495,"date":"2024-02-19T06:00:10","date_gmt":"2024-02-19T04:00:10","guid":{"rendered":"https:\/\/www.glc.us.es\/~jalonso\/exercitium\/?p=8495"},"modified":"2024-02-23T10:42:39","modified_gmt":"2024-02-23T08:42:39","slug":"19-feb-24","status":"publish","type":"post","link":"https:\/\/www.glc.us.es\/~jalonso\/exercitium\/19-feb-24\/","title":{"rendered":"Sistema factor\u00e1dico de numeraci\u00f3n"},"content":{"rendered":"<p>El <a href=\"https:\/\/bit.ly\/3KQZRue\">sistema factor\u00e1dico<\/a> es un sistema num\u00e9rico basado en factoriales en el que el n-\u00e9simo d\u00edgito, empezando desde la derecha, debe ser multiplicado por n! Por ejemplo, el n\u00famero \u00ab341010\u00bb en el sistema factor\u00e1dico es 463 en el sistema decimal ya que<\/p>\n<pre lang=\"text\">\n   3\u00d75! + 4\u00d74! + 1\u00d73! + 0\u00d72! + 1\u00d71! + 0\u00d70! = 463\n<\/pre>\n<p>En este sistema num\u00e9rico, el d\u00edgito de m\u00e1s a la derecha es siempre 0, el segundo 0 o 1, el tercero 0,1 o 2 y as\u00ed sucesivamente.<\/p>\n<p>Con los d\u00edgitos del 0 al 9 el mayor n\u00famero que podemos codificar es el 10!-1 = 3628799. En cambio, si lo ampliamos con las letras A a Z podemos codificar hasta 36!-1 = 37199332678990121746799944815083519999999910.<\/p>\n<p>Definir las funciones<\/p>\n<pre lang=\"text\">\n   factoradicoAdecimal :: String -> Integer\n   decimalAfactoradico :: Integer -> String\n<\/pre>\n<p>tales que<\/p>\n<ul>\n<li>(factoradicoAdecimal cs) es el n\u00famero decimal correspondiente al n\u00famero factor\u00e1dico cs. Por ejemplo,<\/li>\n<\/ul>\n<pre lang=\"text\">\n     \u03bb> factoradicoAdecimal \"341010\"\n     463\n     \u03bb> factoradicoAdecimal \"2441000\"\n     2022\n     \u03bb> factoradicoAdecimal \"A0000000000\"\n     36288000\n     \u03bb> map factoradicoAdecimal [\"10\",\"100\",\"110\",\"200\",\"210\",\"1000\",\"1010\",\"1100\",\"1110\",\"1200\"]\n     [1,2,3,4,5,6,7,8,9,10]\n     \u03bb> factoradicoAdecimal \"3KXWVUTSRQPONMLKJIHGFEDCBA9876543210\"\n     37199332678990121746799944815083519999999\n<\/pre>\n<ul>\n<li>(decimalAfactoradico n) es el n\u00famero factor\u00e1dico correpondiente al n\u00famero decimal n. Por ejemplo,<\/li>\n<\/ul>\n<pre lang=\"text\">\n     \u03bb> decimalAfactoradico 463\n     \"341010\"\n     \u03bb> decimalAfactoradico 2022\n     \"2441000\"\n     \u03bb> decimalAfactoradico 36288000\n     \"A0000000000\"\n     \u03bb> map decimalAfactoradico [1..10]\n     [\"10\",\"100\",\"110\",\"200\",\"210\",\"1000\",\"1010\",\"1100\",\"1110\",\"1200\"]\n     \u03bb> decimalAfactoradico 37199332678990121746799944815083519999999\n     \"3KXWVUTSRQPONMLKJIHGFEDCBA9876543210\"\n<\/pre>\n<p>Comprobar con QuickCheck que, para cualquier entero positivo n,<\/p>\n<pre lang=\"text\">\n   factoradicoAdecimal (decimalAfactoradico n) == n\n<\/pre>\n<p><!--more--><\/p>\n<p><a name=\"haskell\"><\/a><\/p>\n<h2>1. Soluciones en Haskell<\/h2>\n<pre lang=\"haskell\">\nmodule Sistema_factoradico_de_numeracion where\n\nimport Data.List (genericIndex, genericLength)\nimport qualified Data.Map as M ((!), Map, fromList)\nimport Test.Hspec (Spec, describe, hspec, it, shouldBe)\nimport Test.QuickCheck\n\n-- 1\u00aa definici\u00f3n de factoradicoAdecimal\n-- ====================================\n\nfactoradicoAdecimal1 :: String -> Integer\nfactoradicoAdecimal1 cs = sum (zipWith (*) xs ys)\n  where xs = map caracterAentero cs\n        n  = length cs\n        ys = reverse (take n facts)\n\n-- (caracterAentero c) es la posici\u00f3n del car\u00e1cter c en la lista de\n-- caracteres ['0', '1',..., '9', 'A', 'B',..., 'Z']. Por ejemplo,\n--    caracterAentero '0'  ==  0\n--    caracterAentero '1'  ==  1\n--    caracterAentero '9'  ==  9\n--    caracterAentero 'A'  ==  10\n--    caracterAentero 'B'  ==  11\n--    caracterAentero 'Z'  ==  35\ncaracterAentero :: Char -> Integer\ncaracterAentero c =\n  head [n | (n,x) <- zip [0..] caracteres, x == c]\n\n-- caracteres es la lista de caracteres\n-- ['0', '1',..., '9', 'A', 'B',..., 'Z']\ncaracteres :: String\ncaracteres = ['0'..'9'] ++ ['A'..'Z']\n\n-- facts es la lista de los factoriales. Por ejemplo,\n--    \u03bb> take 12 facts\n--    [1,1,2,6,24,120,720,5040,40320,362880,3628800,39916800]\nfacts :: [Integer]\nfacts = scanl (*) 1 [1..]\n\n-- 2\u00aa definici\u00f3n de factoradicoAdecimal\n-- ====================================\n\nfactoradicoAdecimal2 :: String -> Integer\nfactoradicoAdecimal2 cs = sum (zipWith (*) xs ys)\n    where xs = map caracterAentero2 cs\n          n  = length cs\n          ys = reverse (take n facts)\n\n-- (caracterAentero2 c) es la posici\u00f3n del car\u00e1cter c en la lista de\n-- caracteres ['0', '1',..., '9', 'A', 'B',..., 'Z']. Por ejemplo,\n--    caracterAentero2 '0'  ==  0\n--    caracterAentero2 '1'  ==  1\n--    caracterAentero2 '9'  ==  9\n--    caracterAentero2 'A'  ==  10\n--    caracterAentero2 'B'  ==  11\n--    caracterAentero2 'Z'  ==  35\ncaracterAentero2 :: Char -> Integer\ncaracterAentero2 c = caracteresEnteros M.! c\n\n-- caracteresEnteros es el diccionario cuyas claves son los caracteres y\n-- las claves son los n\u00fameros de 0 a 35.\ncaracteresEnteros :: M.Map Char Integer\ncaracteresEnteros = M.fromList (zip (['0'..'9'] ++ ['A'..'Z']) [0..])\n\n-- 3\u00aa definici\u00f3n de factoradicoAdecimal\n-- ====================================\n\nfactoradicoAdecimal3 :: String -> Integer\nfactoradicoAdecimal3 cs =\n  sum (zipWith (*) facts (reverse (map caracterAentero3 cs)))\n\n-- (caracterAentero3 c) es la posici\u00f3n del car\u00e1cter c en la lista de\n-- caracteres ['0', '1',..., '9', 'A', 'B',..., 'Z']. Por ejemplo,\n--    caracterAentero3 '0'  ==  0\n--    caracterAentero3 '1'  ==  1\n--    caracterAentero3 '9'  ==  9\n--    caracterAentero3 'A'  ==  10\n--    caracterAentero3 'B'  ==  11\n--    caracterAentero3 'Z'  ==  35\ncaracterAentero3 :: Char -> Integer\ncaracterAentero3 c =\n  genericLength (takeWhile (\/= c) caracteres)\n\n-- 4\u00aa definici\u00f3n de factoradicoAdecimal\n-- ====================================\n\nfactoradicoAdecimal4 :: String -> Integer\nfactoradicoAdecimal4 =\n  sum . zipWith (*) facts . reverse . map caracterAentero4\n\n-- (caracterAentero4 c) es la posici\u00f3n del car\u00e1cter c en la lista de\n-- caracteres ['0', '1',..., '9', 'A', 'B',..., 'Z']. Por ejemplo,\n--    caracterAentero4 '0'  ==  0\n--    caracterAentero4 '1'  ==  1\n--    caracterAentero4 '9'  ==  9\n--    caracterAentero4 'A'  ==  10\n--    caracterAentero4 'B'  ==  11\n--    caracterAentero4 'Z'  ==  35\ncaracterAentero4 :: Char -> Integer\ncaracterAentero4 =\n  genericLength . flip takeWhile caracteres . (\/=)\n\n-- 1\u00aa definici\u00f3n de decimalAfactoradico\n-- ====================================\n\ndecimalAfactoradico1 :: Integer -> String\ndecimalAfactoradico1 n = aux n (reverse (takeWhile (<=n) facts))\n  where aux 0 xs     = ['0' | _ <- xs]\n        aux m (x:xs) = enteroAcaracter (m `div` x) : aux (m `mod` x) xs\n\n-- (enteroAcaracter k) es el k-\u00e9simo elemento de la lista\n-- ['0', '1',..., '9', 'A', 'B',..., 'Z']. . Por ejemplo,\n--    enteroAcaracter 0   ==  '0'\n--    enteroAcaracter 1   ==  '1'\n--    enteroAcaracter 9   ==  '9'\n--    enteroAcaracter 10  ==  'A'\n--    enteroAcaracter 11  ==  'B'\n--    enteroAcaracter 35  ==  'Z'\nenteroAcaracter :: Integer -> Char\nenteroAcaracter k = caracteres `genericIndex` k\n\n-- 2\u00aa definici\u00f3n de decimalAfactoradico\n-- ====================================\n\ndecimalAfactoradico2 :: Integer -> String\ndecimalAfactoradico2 n = aux n (reverse (takeWhile (<=n) facts))\n  where aux 0 xs     = ['0' | _ <- xs]\n        aux m (x:xs) = enteroAcaracter2 (m `div` x) : aux (m `mod` x) xs\n\n-- (enteroAcaracter2 k) es el k-\u00e9simo elemento de la lista\n-- ['0', '1',..., '9', 'A', 'B',..., 'Z']. . Por ejemplo,\n--    enteroAcaracter2 0   ==  '0'\n--    enteroAcaracter2 1   ==  '1'\n--    enteroAcaracter2 9   ==  '9'\n--    enteroAcaracter2 10  ==  'A'\n--    enteroAcaracter2 11  ==  'B'\n--    enteroAcaracter2 35  ==  'Z'\nenteroAcaracter2 :: Integer -> Char\nenteroAcaracter2 k = enterosCaracteres M.! k\n\n-- enterosCaracteres es el diccionario cuyas claves son los n\u00famero de 0\n-- a 35 y las claves son los caracteres.\nenterosCaracteres :: M.Map Integer Char\nenterosCaracteres = M.fromList (zip [0..] caracteres)\n\n-- 3\u00aa definici\u00f3n de decimalAfactoradico\n-- ====================================\n\ndecimalAfactoradico3 :: Integer -> String\ndecimalAfactoradico3 n = aux \"\" 2 (n, 0)\n  where aux s _ (0, 0) = s\n        aux s m (d, r) = aux (enteroAcaracter3 r: s) (m + 1) (d `divMod` m)\n\n-- (enteroAcaracter3 k) es el k-\u00e9simo elemento de la lista\n-- ['0', '1',..., '9', 'A', 'B',..., 'Z']. . Por ejemplo,\n--    enteroAcaracter3 0   ==  '0'\n--    enteroAcaracter3 1   ==  '1'\n--    enteroAcaracter3 9   ==  '9'\n--    enteroAcaracter3 10  ==  'A'\n--    enteroAcaracter3 11  ==  'B'\n--    enteroAcaracter3 35  ==  'Z'\nenteroAcaracter3 :: Integer -> Char\nenteroAcaracter3 n =\n  caracteres !! fromInteger n\n\n-- 4\u00aa definici\u00f3n de decimalAfactoradico\n-- ====================================\n\ndecimalAfactoradico4 :: Integer -> String\ndecimalAfactoradico4 = f \"\" 2 . (, 0)\n  where f s _ (0, 0) = s\n        f s n (d, r) = f (enteroAcaracter4 r: s) (n + 1) (d `divMod` n)\n\n-- (enteroAcaracter4 k) es el k-\u00e9simo elemento de la lista\n-- ['0', '1',..., '9', 'A', 'B',..., 'Z']. . Por ejemplo,\n--    enteroAcaracter4 0   ==  '0'\n--    enteroAcaracter4 1   ==  '1'\n--    enteroAcaracter4 9   ==  '9'\n--    enteroAcaracter4 10  ==  'A'\n--    enteroAcaracter4 11  ==  'B'\n--    enteroAcaracter4 35  ==  'Z'\nenteroAcaracter4 :: Integer -> Char\nenteroAcaracter4 = (caracteres `genericIndex`)\n\n-- Verificaci\u00f3n\n-- ============\n\nverifica :: IO ()\nverifica = hspec spec\n\nspecG1 :: (String -> Integer) -> Spec\nspecG1 factoradicoAdecimal = do\n  it \"e1\" $\n    factoradicoAdecimal \"341010\" `shouldBe` 463\n  it \"e2\" $\n    factoradicoAdecimal \"2441000\" `shouldBe` 2022\n  it \"e3\" $\n    factoradicoAdecimal \"A0000000000\" `shouldBe` 36288000\n\nspecG2 :: (Integer -> String) -> Spec\nspecG2 decimalAfactoradico = do\n  it \"e1\" $\n    decimalAfactoradico 463 `shouldBe` \"341010\"\n  it \"e2\" $\n    decimalAfactoradico 2022 `shouldBe` \"2441000\"\n  it \"e3\" $\n    decimalAfactoradico 36288000 `shouldBe` \"A0000000000\"\n\nspec :: Spec\nspec = do\n  describe \"def. 1\" $ specG1 factoradicoAdecimal1\n  describe \"def. 2\" $ specG1 factoradicoAdecimal2\n  describe \"def. 3\" $ specG1 factoradicoAdecimal3\n  describe \"def. 4\" $ specG1 factoradicoAdecimal4\n  describe \"def. 1\" $ specG2 decimalAfactoradico1\n  describe \"def. 2\" $ specG2 decimalAfactoradico2\n  describe \"def. 3\" $ specG2 decimalAfactoradico3\n  describe \"def. 4\" $ specG2 decimalAfactoradico4\n\n-- La verificaci\u00f3n es\n--    \u03bb> verifica\n--\n--    24 examples, 0 failures\n\n-- Propiedad de inverso\n-- ====================\n\nprop_factoradico :: Integer -> Property\nprop_factoradico n =\n  n >= 0 ==>\n  factoradicoAdecimal1 (decimalAfactoradico1 n) == n &&\n  factoradicoAdecimal2 (decimalAfactoradico2 n) == n &&\n  factoradicoAdecimal3 (decimalAfactoradico3 n) == n &&\n  factoradicoAdecimal4 (decimalAfactoradico4 n) == n\n\n-- La comprobaci\u00f3n es\n--    \u03bb> quickCheck prop_factoradico\n--    +++ OK, passed 100 tests; 101 discarded.\n\n-- Comparaci\u00f3n de eficiencia\n-- =========================\n\n-- La comparaci\u00f3n es\n--    \u03bb> length (decimalAfactoradico1 (10^300000))\n--    68191\n--    (2.46 secs, 9,088,634,744 bytes)\n--    \u03bb> length (decimalAfactoradico2 (10^300000))\n--    68191\n--    (2.36 secs, 9,088,634,800 bytes)\n--    \u03bb> length (decimalAfactoradico3 (10^300000))\n--    68191\n--    (2.18 secs, 4,490,856,416 bytes)\n--    \u03bb> length (decimalAfactoradico4 (10^300000))\n--    68191\n--    (1.98 secs, 4,490,311,536 bytes)\n--\n--    \u03bb> length (show (factoradicoAdecimal1 (show (10^50000))))\n--    213237\n--    (0.93 secs, 2,654,156,680 bytes)\n--    \u03bb> length (show (factoradicoAdecimal2 (show (10^50000))))\n--    213237\n--    (0.51 secs, 2,633,367,168 bytes)\n--    \u03bb> length (show (factoradicoAdecimal3 (show (10^50000))))\n--    213237\n--    (0.93 secs, 2,635,792,192 bytes)\n--    \u03bb> length (show (factoradicoAdecimal4 (show (10^50000))))\n--    213237\n--    (0.43 secs, 2,636,996,848 bytes)\n<\/pre>\n<p><a name=\"python\"><\/a><\/p>\n<h2>2. Soluciones en Python<\/h2>\n<pre lang=\"python\">\nfrom itertools import count, takewhile\nfrom math import factorial\nfrom typing import Iterator\n\nfrom hypothesis import given\nfrom hypothesis import strategies as st\n\n# 1\u00aa definici\u00f3n de factoradicoAdecimal\n# ====================================\n\n# caracterAentero(c) es la posici\u00f3n del car\u00e1cter c en la lista de\n# caracteres ['0', '1',..., '9', 'A', 'B',..., 'Z']. Por ejemplo,\n#    caracterAentero('0')  ==  0\n#    caracterAentero('1')  ==  1\n#    caracterAentero('9')  ==  9\n#    caracterAentero('A')  ==  10\n#    caracterAentero('B')  ==  11\n#    caracterAentero('Z')  ==  35\ndef caracterAentero(c: str) -> int:\n    if c.isdigit():\n        return int(c)\n    return ord(c) - ord('A') +  10\n\ndef factoradicoAdecimal1(cs: str) -> int:\n    xs = map(caracterAentero, cs)\n    n  = len(cs)\n    ys = reversed([factorial(k) for k in range(n)])\n    return sum((x * y for (x, y) in zip(xs, ys)))\n\n# 2\u00aa definici\u00f3n de factoradicoAdecimal\n# ====================================\n\n# caracteres es la cadena de los caracteres.\ncaracteres: str = '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ'\n\n# caracteresEnteros es el diccionario cuyas claves son los caracteres y\n# los valores son los n\u00fameros de 0 a 35.\ncaracteresEnteros: dict[str, int] = {c: i for i, c in enumerate(caracteres)}\n\n# caracterAentero2(c) es la posici\u00f3n del car\u00e1cter c en la lista de\n# caracteres ['0', '1',..., '9', 'A', 'B',..., 'Z']. Por ejemplo,\n#    caracterAentero2('0')  ==  0\n#    caracterAentero2('1')  ==  1\n#    caracterAentero2('9')  ==  9\n#    caracterAentero2('A')  ==  10\n#    caracterAentero2('B')  ==  11\n#    caracterAentero2('Z')  ==  35\ndef caracterAentero2(c: str) -> int:\n    return caracteresEnteros[c]\n\ndef factoradicoAdecimal2(cs: str) -> int:\n    xs = map(caracterAentero2, cs)\n    n  = len(cs)\n    ys = reversed([factorial(k) for k in range(n)])\n    return sum((x * y for (x, y) in zip(xs, ys)))\n\n# 3\u00aa definici\u00f3n de factoradicoAdecimal\n# ====================================\n\n# caracterAentero3(c) es la posici\u00f3n del car\u00e1cter c en la lista de\n# caracteres ['0', '1',..., '9', 'A', 'B',..., 'Z']. Por ejemplo,\n#    caracterAentero3('0')  ==  0\n#    caracterAentero3('1')  ==  1\n#    caracterAentero3('9')  ==  9\n#    caracterAentero3('A')  ==  10\n#    caracterAentero3('B')  ==  11\n#    caracterAentero3('Z')  ==  35\ndef caracterAentero3(c: str) -> int:\n    return len(list(takewhile(lambda x: x != c, caracteres)))\n\ndef factoradicoAdecimal3(cs: str) -> int:\n    return sum(x * y for x, y in zip([factorial(k) for k in range(len(cs))],\n                                     reversed(list(map(caracterAentero3, cs)))))\n\n# 1\u00aa definici\u00f3n de decimalAfactoradico\n# ====================================\n\n# enteroAcaracter(k) es el k-\u00e9simo elemento de la lista\n# ['0', '1',..., '9', 'A', 'B',..., 'Z']. . Por ejemplo,\n#    enteroAcaracter(0)   ==  '0'\n#    enteroAcaracter(1)   ==  '1'\n#    enteroAcaracter(9)   ==  '9'\n#    enteroAcaracter(10)  ==  'A'\n#    enteroAcaracter(11)  ==  'B'\n#    enteroAcaracter(35)  ==  'Z'\ndef enteroAcaracter(k: int) -> str:\n    return caracteres[k]\n\n# facts() es la lista de los factoriales. Por ejemplo,\n#    >>> list(takewhile(lambda x : x < 900, facts()))\n#    [1, 1, 2, 6, 24, 120, 720]\ndef facts() -> Iterator[int]:\n    return (factorial(n) for n in count())\n\ndef decimalAfactoradico1(n: int) -> str:\n    def aux(m: int, xs: list[int]) -> str:\n        if m == 0:\n            return \"0\" * len(xs)\n        y, *ys = xs\n        print(m, y, m \/\/ y)\n        return enteroAcaracter(m \/\/ y) + aux(m % y, ys)\n    return aux(n, list(reversed(list(takewhile(lambda x : x <= n, facts())))))\n\n# 2\u00aa definici\u00f3n de decimalAfactoradico\n# ====================================\n\n# enterosCaracteres es el diccionario cuyas claves son los n\u00famero de 0\n# a 35 y las claves son los caracteres.\nenterosCaracteres: dict[int, str] = dict(enumerate(caracteres))\n\n# enteroAcaracter2(k) es el k-\u00e9simo elemento de la lista\n# ['0', '1',..., '9', 'A', 'B',..., 'Z']. . Por ejemplo,\n#    enteroAcaracter2(0)   ==  '0'\n#    enteroAcaracter2(1)   ==  '1'\n#    enteroAcaracter2(9)   ==  '9'\n#    enteroAcaracter2(10)  ==  'A'\n#    enteroAcaracter2(11)  ==  'B'\n#    enteroAcaracter2(35)  ==  'Z'\ndef enteroAcaracter2(k: int) -> str:\n    return enterosCaracteres[k]\n\ndef decimalAfactoradico2(n: int) -> str:\n    def aux(m: int, xs: list[int]) -> str:\n        if m == 0:\n            return \"0\" * len(xs)\n        y, *ys = xs\n        return enteroAcaracter2(m \/\/ y) + aux(m % y, ys)\n    return aux(n, list(reversed(list(takewhile(lambda x : x <= n, facts())))))\n\n# 3\u00aa definici\u00f3n de decimalAfactoradico\n# ====================================\n\n# enteroAcaracter3(k) es el k-\u00e9simo elemento de la lista\n# ['0', '1',..., '9', 'A', 'B',..., 'Z']. . Por ejemplo,\n#    enteroAcaracter3(0)   ==  '0'\n#    enteroAcaracter3(1)   ==  '1'\n#    enteroAcaracter3(9)   ==  '9'\n#    enteroAcaracter3(10)  ==  'A'\n#    enteroAcaracter3(11)  ==  'B'\n#    enteroAcaracter3(35)  ==  'Z'\ndef enteroAcaracter3(n: int) -> str:\n    return caracteres[n]\n\ndef decimalAfactoradico3(n: int) -> str:\n    def aux(m: int, xs: list[int]) -> str:\n        if m == 0:\n            return \"0\" * len(xs)\n        y, *ys = xs\n        return enteroAcaracter3(m \/\/ y) + aux(m % y, ys)\n    return aux(n, list(reversed(list(takewhile(lambda x : x <= n, facts())))))\n\n# Verificaci\u00f3n\n# ============\n\ndef test_factoradico() -> None:\n    for factoradicoAdecimal in [factoradicoAdecimal1,\n                                factoradicoAdecimal2,\n                                factoradicoAdecimal3]:\n        assert factoradicoAdecimal(\"341010\") == 463\n        assert factoradicoAdecimal(\"2441000\") == 2022\n        assert factoradicoAdecimal(\"A0000000000\") == 36288000\n    for decimalAfactoradico in [decimalAfactoradico1,\n                                decimalAfactoradico2,\n                                decimalAfactoradico3]:\n        assert decimalAfactoradico(463) == \"341010\"\n        assert decimalAfactoradico(2022) == \"2441000\"\n        assert decimalAfactoradico(36288000) == \"A0000000000\"\n    print(\"Verificado\")\n\n# La verificaci\u00f3n es\n#    >>> test_factoradico()\n#    Verificado\n\n# Propiedad de inverso\n# ====================\n\n@given(st.integers(min_value=0, max_value=1000))\ndef test_factoradico_equiv(n: int) -> None:\n    assert factoradicoAdecimal1(decimalAfactoradico1(n)) == n\n    assert factoradicoAdecimal2(decimalAfactoradico3(n)) == n\n    assert factoradicoAdecimal3(decimalAfactoradico3(n)) == n\n\n# La comprobaci\u00f3n es\n#    >>> test_factoradico_equiv()\n#    >>>\n<\/pre>\n","protected":false},"excerpt":{"rendered":"<p>El sistema factor\u00e1dico es un sistema num\u00e9rico basado en factoriales en el que el n-\u00e9simo d\u00edgito, empezando desde la derecha, debe ser multiplicado por n! Por ejemplo, el n\u00famero \u00ab341010\u00bb en el sistema factor\u00e1dico es 463 en el sistema decimal ya que 3\u00d75! + 4\u00d74! + 1\u00d73! + 0\u00d72! + 1\u00d71! + 0\u00d70! = 463&#8230;<\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"jetpack_post_was_ever_published":false,"_kad_post_transparent":"default","_kad_post_title":"default","_kad_post_layout":"default","_kad_post_sidebar_id":"","_kad_post_content_style":"default","_kad_post_vertical_padding":"default","_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":[581],"tags":[],"jetpack_featured_media_url":"","jetpack_sharing_enabled":true,"_links":{"self":[{"href":"https:\/\/www.glc.us.es\/~jalonso\/exercitium\/wp-json\/wp\/v2\/posts\/8495"}],"collection":[{"href":"https:\/\/www.glc.us.es\/~jalonso\/exercitium\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.glc.us.es\/~jalonso\/exercitium\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.glc.us.es\/~jalonso\/exercitium\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/www.glc.us.es\/~jalonso\/exercitium\/wp-json\/wp\/v2\/comments?post=8495"}],"version-history":[{"count":2,"href":"https:\/\/www.glc.us.es\/~jalonso\/exercitium\/wp-json\/wp\/v2\/posts\/8495\/revisions"}],"predecessor-version":[{"id":8497,"href":"https:\/\/www.glc.us.es\/~jalonso\/exercitium\/wp-json\/wp\/v2\/posts\/8495\/revisions\/8497"}],"wp:attachment":[{"href":"https:\/\/www.glc.us.es\/~jalonso\/exercitium\/wp-json\/wp\/v2\/media?parent=8495"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.glc.us.es\/~jalonso\/exercitium\/wp-json\/wp\/v2\/categories?post=8495"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.glc.us.es\/~jalonso\/exercitium\/wp-json\/wp\/v2\/tags?post=8495"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}