Números con cuadrados con dígitos pares

PorJosé A. Alonso 17-marzo-202124-marzo-2021

Definir la lista

   numerosConCuadradosConDigitosPares :: [Integer]

1	numerosConCuadradosConDigitosPares :: [Integer]

cuyos elementos son los números cuyos cuadrados tienen todos sus dígitos pares. Por ejemplo,

   λ> take 20 numerosConCuadradosConDigitosPares
   [0,2,8,20,22,68,78,80,92,162,168,200,202,220,262,298,478,492,498,668]

1 2	λ> take 20 numerosConCuadradosConDigitosPares [0,2,8,20,22,68,78,80,92,162,168,200,202,220,262,298,478,492,498,668]

Comprobar con QuickCheck que numerosConCuadradosConDigitosPares es infinita; es decir, para cualquier n posee algún elemento mayor que n.

Soluciones

import Test.QuickCheck

numerosConCuadradosConDigitosPares :: [Integer]
numerosConCuadradosConDigitosPares =
  filter tieneCuadradoConDigitosPares [0..]

-- (tieneCuadradoConDigitosPares n) se verifica si todos los dígitos de
-- n^2 son pares. Por ejemplo,
--    tieneCuadradoConDigitosPares 78  ==  True
--    tieneCuadradoConDigitosPares 76  ==  False
tieneCuadradoConDigitosPares :: Integer -> Bool
tieneCuadradoConDigitosPares n =
  tieneDigitosPares (n^2)

-- (tieneDigitosPares n) se verifica si todos los dígitos de n son
-- pares. Por ejemplo,
--    tieneDigitosPares 426  ==  True
--    tieneDigitosPares 436  ==  False
tieneDigitosPares :: Integer -> Bool
tieneDigitosPares n =
  all even (digitos n)

-- (digitos n) es la lista de los dígitos de n. Por ejemplo,
--    digitos 325  ==  [3,2,5]
digitos :: Integer -> [Int]
digitos n =
  [read [c] | c <- show n]

-- La propiedad es
prop_infinito :: Integer -> Bool
prop_infinito n =
  not (null (dropWhile (<= n) numerosConCuadradosConDigitosPares))

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

import Test.QuickCheck

numerosConCuadradosConDigitosPares :: [Integer]

numerosConCuadradosConDigitosPares =

filter tieneCuadradoConDigitosPares [0..]

-- (tieneCuadradoConDigitosPares n) se verifica si todos los dígitos de

-- n^2 son pares. Por ejemplo,

-- tieneCuadradoConDigitosPares 78 == True

-- tieneCuadradoConDigitosPares 76 == False

tieneCuadradoConDigitosPares :: Integer -> Bool

tieneCuadradoConDigitosPares n =

tieneDigitosPares (n^2)

-- (tieneDigitosPares n) se verifica si todos los dígitos de n son

-- pares. Por ejemplo,

-- tieneDigitosPares 426 == True

-- tieneDigitosPares 436 == False

tieneDigitosPares :: Integer -> Bool

tieneDigitosPares n =

all even (digitos n)

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

-- digitos 325 == [3,2,5]

digitos :: Integer -> [Int]

digitos n =

[read [c] | c <- show n]

-- La propiedad es

prop_infinito :: Integer -> Bool

prop_infinito n =

not (null (dropWhile (<= n) numerosConCuadradosConDigitosPares))

-- La comprobación es

-- λ> quickCheck prop_infinito

-- +++ 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>

6 Comentarios

numerosConCuadradosConDigitosPares :: [Integer]
numerosConCuadradosConDigitosPares = [n | n <- [0..], digitosPares (n^2)]

-- digitosPares n se verifica si el número n tiene todos sus dígitos pares. Por
-- ejemplo,
--    λ> digitosPares 24686420
--    True

digitosPares :: Integer -> Bool
digitosPares n = all even [read [x] | x <- show n]

-- Propiedad:
-- =========

propPares :: Integer -> Bool
propPares n = not (null [m | m <- [k+1..], digitosPares (m^2)])
  where k = abs n

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

numerosConCuadradosConDigitosPares :: [Integer]

numerosConCuadradosConDigitosPares = [n | n <- [0..], digitosPares (n^2)]

-- digitosPares n se verifica si el número n tiene todos sus dígitos pares. Por

-- ejemplo,

-- λ> digitosPares 24686420

-- True

digitosPares :: Integer -> Bool

digitosPares n = all even [read [x] | x <- show n]

-- Propiedad:

-- =========

propPares :: Integer -> Bool

propPares n = not (null [m | m <- [k+1..], digitosPares (m^2)])

where k = abs n

-- La comprobación es:

-- λ> quickCheck propPares

-- +++ OK, passed 100 tests.

Responder

import Data.List

--Vemos que todos los números tienen que ser pares, por lo tanto, para aumentar
--la eficiencia de numerosConCuadradosConDigitosPares hacemos que x recorra
--solo los números pares.

numerosConCuadradosConDigitosPares :: [Integer]
numerosConCuadradosConDigitosPares = [x | x<-[0,2..] , all (even) (digitos (x^2))]

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

propPares :: Integer -> Property
propPares n = n>=0 ==> [x | x <- [n+1..], all even (digitos x)] /= []

import Data.List

--Vemos que todos los números tienen que ser pares, por lo tanto, para aumentar

--la eficiencia de numerosConCuadradosConDigitosPares hacemos que x recorra

--solo los números pares.

numerosConCuadradosConDigitosPares :: [Integer]

numerosConCuadradosConDigitosPares = [x | x<-[0,2..] , all (even) (digitos (x^2))]

digitos :: Integer -> [Integer]

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

propPares :: Integer -> Property

propPares n = n>=0 ==> [x | x <- [n+1..], all even (digitos x)] /= []

Responder

import Data.List

--Vemos que todos los números tienen que ser pares, por lo tanto, para aumentar
--la eficiencia de numerosConCuadradosConDigitosPares hacemos que x recorra
--solo los números pares.

numerosConCuadradosConDigitosPares :: [Integer]
numerosConCuadradosConDigitosPares = [x | x<-[0,2..] , all (even) (digitos (x^2))]

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

propPares :: Integer -> Property
propPares n = n>=0 ==> [x | x <- [n+1..], all even (digitos (x^2))] /= []

import Data.List

--Vemos que todos los números tienen que ser pares, por lo tanto, para aumentar

--la eficiencia de numerosConCuadradosConDigitosPares hacemos que x recorra

--solo los números pares.

numerosConCuadradosConDigitosPares :: [Integer]

numerosConCuadradosConDigitosPares = [x | x<-[0,2..] , all (even) (digitos (x^2))]

digitos :: Integer -> [Integer]

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

propPares :: Integer -> Property

propPares n = n>=0 ==> [x | x <- [n+1..], all even (digitos (x^2))] /= []

Responder

import Data.List
import Test.QuickCheck 

numerosConCuadradosConDigitosPares :: [Integer]
numerosConCuadradosConDigitosPares = filter digitPar [0..]

-- digitPar x se verifica si todos los dígitos de x^2 son pares.
digitPar :: Integer -> Bool
digitPar x = all even [read [a] | a <- nub (show (x^2))]

propPares :: Integer -> Property
propPares n = n>=0 ==> [x | x <- [n+1..], digitPar x] /= []

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

import Data.List

import Test.QuickCheck

numerosConCuadradosConDigitosPares :: [Integer]

numerosConCuadradosConDigitosPares = filter digitPar [0..]

-- digitPar x se verifica si todos los dígitos de x^2 son pares.

digitPar :: Integer -> Bool

digitPar x = all even [read [a] | a <- nub (show (x^2))]

propPares :: Integer -> Property

propPares n = n>=0 ==> [x | x <- [n+1..], digitPar x] /= []

-- La comprobación es:

-- λ> quickCheck propPares

-- +++ OK, passed 100 tests.

Responder

import Test.QuickCheck

numerosConCuadradosConDigitosPares :: [Integer]
numerosConCuadradosConDigitosPares =
  [ n | n <- [0..], all even (digitos (n^2))]

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

propiedad :: Integer -> Bool
propiedad n =
   not (null ([x | x <- [(y+1)..], all even (digitos (x^2))]))
   where y = abs n

import Test.QuickCheck

numerosConCuadradosConDigitosPares :: [Integer]

numerosConCuadradosConDigitosPares =

[ n | n <- [0..], all even (digitos (n^2))]

digitos :: Integer -> [Integer]

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

propiedad :: Integer -> Bool

propiedad n =

not (null ([x | x <- [(y+1)..], all even (digitos (x^2))]))

where y = abs n

Responder

numerosConCuadradosConDigitosPares :: [Integer]
numerosConCuadradosConDigitosPares =
      [x | x <- [0,2..],
             null (dropWhile even (listaDigitos (x^2)))]

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

prop_cuadDigPar :: Integer -> Property
prop_cuadDigPar n = n > 0 ==> not $ null $ drop (fromIntegral n)
                                numerosConCuadradosConDigitosPares

-- λ> quickCheck prop_cuadDigPar
-- +++ OK, passed 100 tests.

numerosConCuadradosConDigitosPares :: [Integer]

numerosConCuadradosConDigitosPares =

[x | x <- [0,2..],

null (dropWhile even (listaDigitos (x^2)))]

listaDigitos :: Integer -> [Integer]

listaDigitos x = [read [x] ::Integer | x <- show x]

prop_cuadDigPar :: Integer -> Property

prop_cuadDigPar n = n > 0 ==> not $ null $ drop (fromIntegral n)

numerosConCuadradosConDigitosPares

-- λ> quickCheck prop_cuadDigPar

-- +++ OK, passed 100 tests.

Responder

Números con cuadrados con dígitos pares

Soluciones

Nuevas soluciones

6 Comentarios

Escribe tu soluciónCancel reply

Entradas recientes

Buscar

Correo electrónico

Soluciones

Nuevas soluciones

Se puede imprimir o compartir con

6 Comentarios

Escribe tu soluciónCancel reply

Entradas recientes

Buscar

Correo electrónico