Raíz digital

PorJosé A. Alonso 6-abril-202113-abril-2021

La raíz digital de un número entero positivo n es el dígito que resulta al sumar sus dígitos, volviendo a sumar reiteradamente los resultados de esa suma y de las siguientes hasta que la suma sea un número de un dígito, al que se llama la raíz digital del número n y se representa por D(n). Por ejemplo, la raíz digital del número 23451 es 6, porque 2+3+4+5+1 = 15 y sumando los dígitos del 15 resulta 6.

Definir la función

   raizDigital :: Integer -> Integer

1	raizDigital :: Integer -> Integer

tal que (raizDigital n) es la raíz digital del entero positivo n. Por ejemplo,

   raizDigital 23451  ==  6

1	raizDigital 23451 == 6

Comprobar con QuickCheck las siguientes propiedades de la raíz digital:

D(m + n) = D(D(m) + D(n)).
D(mn) = D(D(m)D(n)).
D(m^n) = D(D(m)^n).
D(D(n)) = D(n).
D(n + 9) = D(n).
D(9n) = 9.

Soluciones

import Test.QuickCheck (Property, (==>), quickCheck)

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

raizDigital :: Integer -> Integer
raizDigital n
  | n < 10    = n
  | otherwise = raizDigital (sumaDigitos n)

-- (sumaDigitos n) es la suma de los dígitos de n. Por ejemplo,
--    sumaDigitos 2021  ==  5
sumaDigitos :: Integer -> Integer
sumaDigitos = sum . digitos

-- (digitos n) es la lista de los dígitos de n. Por ejemplo,
--    digitos 2021  ==  [2,0,2,1]
digitos :: Integer -> [Integer]
digitos x = [read [c] | c <- show x]

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

raizDigital2 :: Integer -> Integer
raizDigital2 n =
  head (dropWhile (>9) (iterate sumaDigitos n))

-- 3ª solución
-- ===========

raizDigital3 :: Integer -> Integer
raizDigital3 n
  | m == 0    = 9
  | otherwise = m
  where m = n `mod` 9

-- 4ª solución
-- ===========

raizDigital4 :: Integer -> Integer
raizDigital4 n = 1 + (n-1) `mod` 9

-- Comprobación de equivalencia
-- ============================

-- La propiedad es
prop_raizDigital_equiv :: Integer -> Property
prop_raizDigital_equiv n =
  n > 0 ==>
  all (== (raizDigital n))
      [raizDigital2 n,
       raizDigital3 n,
       raizDigital4 n]

-- La comprobación es
--    λ> quickCheck prop_raizDigital_equiv
--    +++ OK, passed 100 tests.

-- Propiedades
-- ===========

-- Las propiedades son
prop_raizDigital :: Integer -> Integer -> Property
prop_raizDigital m n =
  m > 0 && n > 0 ==>
  d(m + n) == d(d(m) + d(n)) &&
  d(m*n) == d(d(m)*d(n)) &&
  d(m^n) == d(d(m)^n) &&
  d(d(n)) == d(n) &&
  d(n + 9) == d(n) &&
  d(9*n) == 9
  where d = raizDigital

-- La comprobación es
--    λ> quickCheck prop_raizDigital
--    +++ OK, passed 100 tests.

import Test.QuickCheck (Property, (==>), quickCheck)

-- 1ª solución

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

raizDigital :: Integer -> Integer

raizDigital n

| n < 10 = n

| otherwise = raizDigital (sumaDigitos n)

-- (sumaDigitos n) es la suma de los dígitos de n. Por ejemplo,

-- sumaDigitos 2021 == 5

sumaDigitos :: Integer -> Integer

sumaDigitos = sum . digitos

-- (digitos n) es la lista de los dígitos de n. Por ejemplo,

-- digitos 2021 == [2,0,2,1]

digitos :: Integer -> [Integer]

digitos x = [read [c] | c <- show x]

-- 2ª solución

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

raizDigital2 :: Integer -> Integer

raizDigital2 n =

head (dropWhile (>9) (iterate sumaDigitos n))

-- 3ª solución

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

raizDigital3 :: Integer -> Integer

raizDigital3 n

| m == 0 = 9

| otherwise = m

where m = n `mod` 9

-- 4ª solución

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

raizDigital4 :: Integer -> Integer

raizDigital4 n = 1 + (n-1) `mod` 9

-- Comprobación de equivalencia

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

-- La propiedad es

prop_raizDigital_equiv :: Integer -> Property

prop_raizDigital_equiv n =

n > 0 ==>

all (== (raizDigital n))

[raizDigital2 n,

raizDigital3 n,

raizDigital4 n]

-- La comprobación es

-- λ> quickCheck prop_raizDigital_equiv

-- +++ OK, passed 100 tests.

-- Propiedades

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

-- Las propiedades son

prop_raizDigital :: Integer -> Integer -> Property

prop_raizDigital m n =

m > 0 && n > 0 ==>

d(m + n) == d(d(m) + d(n)) &&

d(m*n) == d(d(m)*d(n)) &&

d(m^n) == d(d(m)^n) &&

d(d(n)) == d(n) &&

d(n + 9) == d(n) &&

d(9*n) == 9

where d = raizDigital

-- La comprobación es

-- λ> quickCheck prop_raizDigital

-- +++ OK, passed 100 tests.

Nuevas soluciones

En los comentarios se pueden escribir nuevas soluciones.
El código se debe escribir entre una línea con <pre lang="haskell"> y otra con </pre>

4 Comentarios

-- Definición:
-- ==========

raizDigital :: Integer -> Integer
raizDigital n
  | div n 10 == 0 = n
  | otherwise     = raizDigital (sum [read [x] | x <- show n])

-- Propiedades:
-- ===========

prop1 :: Integer -> Integer -> Bool
prop1 m n = raizDigital (m' + n') == raizDigital (raizDigital m' + raizDigital n')
  where m' = abs m + 1
        n' = abs n + 1

-- La comprobación es:
-- λ> quickCheck prop1
-- +++ OK, passed 100 tests.

prop2 :: Integer -> Integer -> Bool
prop2 m n = raizDigital (m' * n') == raizDigital (raizDigital m' * raizDigital n')
  where m' = abs m + 1
        n' = abs n + 1

-- La comprobación es:
-- λ> quickCheck prop2
-- +++ OK, passed 100 tests.

prop3 :: Integer -> Integer -> Bool
prop3 m n = raizDigital (m' ^ n') == raizDigital (raizDigital m' ^ n')
  where m' = abs m + 1
        n' = abs n + 1

-- La comprobación es:
-- λ> quickCheck prop3
-- +++ OK, passed 100 tests.

prop4 :: Integer -> Bool
prop4 n = raizDigital (raizDigital n') == raizDigital n'
  where n' = abs n + 1

-- La comprobación es:
-- λ> quickCheck prop4
-- +++ OK, passed 100 tests.

prop5 :: Integer -> Bool
prop5 n = raizDigital (n' + 9) == raizDigital n'
  where n' = abs n + 1

-- La comprobación es:
-- λ> quickCheck prop5
-- +++ OK, passed 100 tests.

prop6 :: Integer -> Bool
prop6 n = raizDigital (9 * n') == 9
  where n' = abs n + 1

-- La comprobación es:
-- λ> quickCheck prop6
-- +++ OK, passed 100 tests.

-- Definición en base a las propiedades:
-- ====================================

raizDigitalOpt :: Integer -> Integer
raizDigitalOpt 0 = 0
raizDigitalOpt n
  | k == 0    = 9
  | otherwise = k
      where k = mod n 9

-- Equivalencia de las definiciones:
-- ================================

prop :: Integer -> Bool
prop n = raizDigital n' == raizDigitalOpt n'
  where n' = abs n

-- La comprobación es:
-- λ> quickCheck prop
-- +++ OK, passed 100 tests.

-- Comparación de eficiencia:
-- =========================
--
-- λ> raizDigital (10^1000000 - 1)
-- 9
-- (1.84 secs, 3,928,719,984 bytes)
--
-- λ> raizDigitalOpt (10^1000000 - 1)
-- 9
-- (0.04 secs, 1,656,840 bytes)

-- Definición:

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

raizDigital :: Integer -> Integer

raizDigital n

| div n 10 == 0 = n

| otherwise = raizDigital (sum [read [x] | x <- show n])

-- Propiedades:

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

prop1 :: Integer -> Integer -> Bool

prop1 m n = raizDigital (m' + n') == raizDigital (raizDigital m' + raizDigital n')

where m' = abs m + 1

n' = abs n + 1

-- La comprobación es:

-- λ> quickCheck prop1

-- +++ OK, passed 100 tests.

prop2 :: Integer -> Integer -> Bool

prop2 m n = raizDigital (m' * n') == raizDigital (raizDigital m' * raizDigital n')

where m' = abs m + 1

n' = abs n + 1

-- La comprobación es:

-- λ> quickCheck prop2

-- +++ OK, passed 100 tests.

prop3 :: Integer -> Integer -> Bool

prop3 m n = raizDigital (m' ^ n') == raizDigital (raizDigital m' ^ n')

where m' = abs m + 1

n' = abs n + 1

-- La comprobación es:

-- λ> quickCheck prop3

-- +++ OK, passed 100 tests.

prop4 :: Integer -> Bool

prop4 n = raizDigital (raizDigital n') == raizDigital n'

where n' = abs n + 1

-- La comprobación es:

-- λ> quickCheck prop4

-- +++ OK, passed 100 tests.

prop5 :: Integer -> Bool

prop5 n = raizDigital (n' + 9) == raizDigital n'

where n' = abs n + 1

-- La comprobación es:

-- λ> quickCheck prop5

-- +++ OK, passed 100 tests.

prop6 :: Integer -> Bool

prop6 n = raizDigital (9 * n') == 9

where n' = abs n + 1

-- La comprobación es:

-- λ> quickCheck prop6

-- +++ OK, passed 100 tests.

-- Definición en base a las propiedades:

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

raizDigitalOpt :: Integer -> Integer

raizDigitalOpt 0 = 0

raizDigitalOpt n

| k == 0 = 9

| otherwise = k

where k = mod n 9

-- Equivalencia de las definiciones:

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

prop :: Integer -> Bool

prop n = raizDigital n' == raizDigitalOpt n'

where n' = abs n

-- La comprobación es:

-- λ> quickCheck prop

-- +++ OK, passed 100 tests.

-- Comparación de eficiencia:

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

-- λ> raizDigital (10^1000000 - 1)

-- 9

-- (1.84 secs, 3,928,719,984 bytes)

-- λ> raizDigitalOpt (10^1000000 - 1)

-- 9

-- (0.04 secs, 1,656,840 bytes)

Responder

raizDigital :: Integer -> Integer
raizDigital n | length(dig n) == 1 = n
              | otherwise          =  raizDigital (sum (dig n))
     where dig x = digitosConjunto x
           
propS :: Integer -> Integer -> Property
propS x y = x>0 && y>0 ==> rd (x+y) == rd(rd x + rd y)
  where rd m = raizDigital m 

propM :: Integer -> Integer -> Property
propM x y = x>0 && y>0 ==> rd (x*y) == rd(rd x * rd y)
  where rd m = raizDigital m 

propE :: Integer -> Integer -> Property
propE x y = x>0 && y>0 ==> rd (x^y) == rd(rd x ^ rd y)
  where rd m = raizDigital m

prop9S :: Integer -> Property
prop9S x = x>0 ==> rd (x+9) == rd x
  where rd m = raizDigital m

prop9M :: Integer -> Property
prop9M x = x>0 ==> rd (9*x) == rd 9
  where rd m = raizDigital m

raizDigital :: Integer -> Integer

raizDigital n | length(dig n) == 1 = n

| otherwise = raizDigital (sum (dig n))

where dig x = digitosConjunto x

propS :: Integer -> Integer -> Property

propS x y = x>0 && y>0 ==> rd (x+y) == rd(rd x + rd y)

where rd m = raizDigital m

propM :: Integer -> Integer -> Property

propM x y = x>0 && y>0 ==> rd (x*y) == rd(rd x * rd y)

where rd m = raizDigital m

propE :: Integer -> Integer -> Property

propE x y = x>0 && y>0 ==> rd (x^y) == rd(rd x ^ rd y)

where rd m = raizDigital m

prop9S :: Integer -> Property

prop9S x = x>0 ==> rd (x+9) == rd x

where rd m = raizDigital m

prop9M :: Integer -> Property

prop9M x = x>0 ==> rd (9*x) == rd 9

where rd m = raizDigital m

Responder

import Data.Char
import Test.QuickCheck

raizDigital :: Integer -> Integer
raizDigital n | x < 10 = x
              | otherwise = raizDigital x
 where x = sum $ integerToList n

-- integerToList toma un entero y crea una lista con sus cifras.
-- integerToList 513 == [5,1,3]

integerToList :: Integer -> [Integer]
integerToList n = [toInteger $ digitToInt x | x <- show n]


prop1 :: Integer -> Integer -> Property
prop1 m n = m>0 && n>0 ==> raizDigital (m+n) == raizDigital (raizDigital m + raizDigital n)

prop2 :: Integer -> Integer -> Property
prop2 m n = m>0 && n>0 ==> raizDigital (m*n) == raizDigital (raizDigital m * raizDigital n)

prop3 :: Integer -> Integer -> Property
prop3 m n = m>0 && n>0 ==> raizDigital (m^n) == raizDigital ((raizDigital m)^n)

prop4 :: Integer -> Property
prop4 n = n>0 ==> raizDigital (raizDigital n) == raizDigital n

prop5 :: Integer -> Property
prop5 n = n>0 ==> raizDigital (n+9) == raizDigital n

prop6 :: Integer -> Property
prop6 n = n>0 ==> raizDigital (9*n) == 9

-- Las comprobaciones son
--   λ> quickCheck prop1
--   +++ OK, passed 100 tests.
--   λ> quickCheck prop2
--   +++ OK, passed 100 tests.
--   λ> quickCheck prop3
--   +++ OK, passed 100 tests.
--   λ> quickCheck prop4
--   +++ OK, passed 100 tests.
--   λ> quickCheck prop5
--   +++ OK, passed 100 tests.
--   λ> quickCheck prop6
--   +++ OK, passed 100 tests.

import Data.Char

import Test.QuickCheck

raizDigital :: Integer -> Integer

raizDigital n | x < 10 = x

| otherwise = raizDigital x

where x = sum $ integerToList n

-- integerToList toma un entero y crea una lista con sus cifras.

-- integerToList 513 == [5,1,3]

integerToList :: Integer -> [Integer]

integerToList n = [toInteger $ digitToInt x | x <- show n]

prop1 :: Integer -> Integer -> Property

prop1 m n = m>0 && n>0 ==> raizDigital (m+n) == raizDigital (raizDigital m + raizDigital n)

prop2 :: Integer -> Integer -> Property

prop2 m n = m>0 && n>0 ==> raizDigital (m*n) == raizDigital (raizDigital m * raizDigital n)

prop3 :: Integer -> Integer -> Property

prop3 m n = m>0 && n>0 ==> raizDigital (m^n) == raizDigital ((raizDigital m)^n)

prop4 :: Integer -> Property

prop4 n = n>0 ==> raizDigital (raizDigital n) == raizDigital n

prop5 :: Integer -> Property

prop5 n = n>0 ==> raizDigital (n+9) == raizDigital n

prop6 :: Integer -> Property

prop6 n = n>0 ==> raizDigital (9*n) == 9

-- Las comprobaciones son

-- λ> quickCheck prop1

-- +++ OK, passed 100 tests.

-- λ> quickCheck prop2

-- +++ OK, passed 100 tests.

-- λ> quickCheck prop3

-- +++ OK, passed 100 tests.

-- λ> quickCheck prop4

-- +++ OK, passed 100 tests.

-- λ> quickCheck prop5

-- +++ OK, passed 100 tests.

-- λ> quickCheck prop6

-- +++ OK, passed 100 tests.

Responder

import Data.List

digitos :: Integer -> [Integer]
digitos n = [read [x] | x<-show n]

raizDigital :: Integer -> Integer
raizDigital n | length (digitos s) > 1 = raizDigital s
              | otherwise = s
              where s = sum (digitos n)
              
prop1 :: Integer -> Integer -> Property
prop1 m n = m>0 && n>0 ==> raizDigital (raizDigital(m) + raizDigital(n)) == raizDigital s
          where s = m+n

prop2 :: Integer -> Integer -> Property
prop2 m n = m>0 && n>0 ==> raizDigital (raizDigital(m) * raizDigital(n)) == raizDigital s
          where s = m*n

prop3 :: Integer -> Integer -> Property
prop3 m n = m>0 && n>0 ==> raizDigital (raizDigital(m)^n) == raizDigital s
          where s = m^n
                
prop4 :: Integer -> Property
prop4 n = n>0 ==> raizDigital (raizDigital(n)) == raizDigital n
                      
prop5 :: Integer -> Property
prop5 n =  n>0 ==> raizDigital (n+9) == raizDigital n
          
prop6 :: Integer ->  Property
prop6 n = n>0 ==> raizDigital (9*n) == raizDigital 9

-- Las comprobaciones son:

--   raizDigital 23451
-- 6
-- (0.01 secs, 82,312 bytes)

-- quickCheck prop1
-- +++ OK, passed 100 tests.
-- (0.04 secs, 13,089,816 bytes)

-- λ> quickCheck prop2
-- +++ OK, passed 100 tests.
-- (0.01 secs, 13,590,256 bytes)

-- λ> quickCheck prop3
-- +++ OK, passed 100 tests.
-- (0.04 secs, 54,645,504 bytes)

-- λ> quickCheck prop4
-- +++ OK, passed 100 tests.
-- (0.00 secs, 5,832,424 bytes)

-- λ> quickCheck prop5
-- +++ OK, passed 100 tests.
-- (0.01 secs, 5,308,408 bytes)

-- λ> quickCheck prop6
-- +++ OK, passed 100 tests.
-- (0.00 secs, 5,014,712 bytes)

import Data.List

digitos :: Integer -> [Integer]

digitos n = [read [x] | x<-show n]

raizDigital :: Integer -> Integer

raizDigital n | length (digitos s) > 1 = raizDigital s

| otherwise = s

where s = sum (digitos n)

prop1 :: Integer -> Integer -> Property

prop1 m n = m>0 && n>0 ==> raizDigital (raizDigital(m) + raizDigital(n)) == raizDigital s

where s = m+n

prop2 :: Integer -> Integer -> Property

prop2 m n = m>0 && n>0 ==> raizDigital (raizDigital(m) * raizDigital(n)) == raizDigital s

where s = m*n

prop3 :: Integer -> Integer -> Property

prop3 m n = m>0 && n>0 ==> raizDigital (raizDigital(m)^n) == raizDigital s

where s = m^n

prop4 :: Integer -> Property

prop4 n = n>0 ==> raizDigital (raizDigital(n)) == raizDigital n

prop5 :: Integer -> Property

prop5 n = n>0 ==> raizDigital (n+9) == raizDigital n

prop6 :: Integer -> Property

prop6 n = n>0 ==> raizDigital (9*n) == raizDigital 9

-- Las comprobaciones son:

-- raizDigital 23451

-- 6

-- (0.01 secs, 82,312 bytes)

-- quickCheck prop1

-- +++ OK, passed 100 tests.

-- (0.04 secs, 13,089,816 bytes)

-- λ> quickCheck prop2

-- +++ OK, passed 100 tests.

-- (0.01 secs, 13,590,256 bytes)

-- λ> quickCheck prop3

-- +++ OK, passed 100 tests.

-- (0.04 secs, 54,645,504 bytes)

-- λ> quickCheck prop4

-- +++ OK, passed 100 tests.

-- (0.00 secs, 5,832,424 bytes)

-- λ> quickCheck prop5

-- +++ OK, passed 100 tests.

-- (0.01 secs, 5,308,408 bytes)

-- λ> quickCheck prop6

-- +++ OK, passed 100 tests.

-- (0.00 secs, 5,014,712 bytes)

Responder

Raíz digital

Soluciones

Nuevas soluciones

4 Comentarios

Escribe tu soluciónCancel reply

Entradas recientes

Buscar

Correo electrónico

Soluciones

Nuevas soluciones

Se puede imprimir o compartir con

4 Comentarios

Escribe tu soluciónCancel reply

Entradas recientes

Buscar

Correo electrónico