Menu Close

Números muy pares

Un entero positivo x es muy par si tanto x como x² sólo contienen cifras pares. Por ejemplo, 200 es muy par porque todas las cifras de 200 y 200² = 40000 son pares; pero 26 no lo es porque 26² = 676 tiene cifras impares.

Definir la función

   siguienteMuyPar :: Integer -> Integer

tal que (siguienteMuyPar x) es menor número mayor que x que es muy par. Por ejemplo,

   siguienteMuyPar 300           ==  668
   siguienteMuyPar 668           ==  680
   siguienteMuyPar 828268400000  ==  828268460602

Soluciones

siguienteMuyPar :: Integer -> Integer
siguienteMuyPar x = 
    head [n | n <- [y,y+2..], muyPar n]
    where y = siguientePar x
 
-- (siguientePar x) es el primer número mayor que x que es par. Por
-- ejemplo, 
--    siguientePar 3  ==  4
--    siguientePar 4  ==  6
siguientePar :: Integer -> Integer
siguientePar x | odd x     = x+1
               | otherwise = x+2
 
-- (muyPar x) se verifica si x es muy par. Por ejemplo,
--    muyPar 200           == True
--    muyPar 26            == False
muyPar :: Integer -> Bool
muyPar n = all even (digitos n) && all even (digitos (n*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 [d] | d <- show n]
Medio

10 soluciones de “Números muy pares

  1. fracruzam
    siguienteMuyPar :: Integer -> Integer
    siguienteMuyPar n 
        | even n = head [ x | x <- [n+2,n+4..], checkMuyPar x, checkMuyPar (x^2)]
        | odd  n = head [ x | x <- [n+1,n+3..], checkMuyPar x, checkMuyPar (x^2)]
     
    checkMuyPar :: Integer -> Bool
    checkMuyPar n = all (`elem` "02468") (show n)
     
    -- *Main> siguienteMuyPar 828268400000  ==  828268460602
    -- True
    -- (0.17 secs, 51,034,016 bytes)
  2. abrdelrod
    siguienteMuyPar :: Integer -> Integer
    siguienteMuyPar n = head [x | x <- [n+1..], muyPar x]
        where muyPar n = and [even x | x <- digitos n] && 
                         and [even x | x <- digitos (n^2)]
              digitos n = [read [c] | c <- show n]
  3. Marcos
    import Data.Foldable (all)
    import Data.Monoid ((<>))
     
    veryEven :: Integer -> Bool
    veryEven n
      | odd n     = False
      | otherwise = all even $ figures n <> figures (n * n)
     
    figures :: Integer -> [Integer]
    figures n
      | n < 0       = figures $ abs n
      | n < 10      = [n]
      | otherwise   = n `rem` 10 : figures (n `div` 10)
     
    nextVeryEven :: Integer -> Integer
    nextVeryEven n = x where (x:_) = filter veryEven [n..]
     
    -- λ| nextVeryEven 828268400000 == 828268460602
    -- True
    -- (0.21 secs, 91,300,256 bytes)
  4. manpende
    siguienteMuyPar :: Integer -> Integer
    siguienteMuyPar n = head (muyPares (n+1))
     
    muyPares :: Integer -> [Integer]
    muyPares n = [ x | x <- [n..], muyDivPor2 x && muyDivPor2 (x^2)]
     
    muyDivPor2 :: Integer -> Bool
    muyDivPor2 0 = True
    muyDivPor2 x | mod x 2 == 0 = muyDivPor2 (div x 10)
                 | otherwise = False
    • manpende
      Para mejorarla, cambiaríamos la definición de muyDivPor2 anterior por:
       
      muyDivPor2 :: Integer -> Bool
      muyDivPor2 0 = True
      muyDivPor2 x = mod x 2 == 0 && muyDivPor2 (div x 10)
  5. manvermor
    siguienteMuyPar :: Integer -> Integer
    siguienteMuyPar x = 
        head [n | n <- [x+1..], all even (digit n), 
                                all even (digit (n*n))]
        where digit n = [read [c] | c <- show n]
  6. Eduardo
    -- Creamos una función booleana que simplemente nos compruebe que se
    -- cumple la premisa de ser muy par:
    todoPar 0 = True
    todoPar x | even x = todoPar(div x 10) 
              | otherwise = False
    muyPar x = todoPar x && todoPar (x^2)
    -- Aquellos que cumplen ser muy par siempre tienen la cualidad de que
    -- terminan en 0,2 y 8. Aprovechamos esta circunstancia. Definimos una
    -- función que determina el último dígito, y otra que simplemente
    -- comprueba si es 0,2 u 8. 
    ultimoDigito x = x-(div x 10)*10
    cumple x =x==0 || x==2|| x==8
    -- Finalmente, la función pedida por recursión (que suele ser más
    -- eficiente que la comprensión):
     
    siguienteMuyPar x |even x = aux1 (x+2)
                      |odd x = aux2 (x+2)
        where
          aux1 y | cumple (ultimoDigito y) && muyPar y = y
                 | otherwise = siguienteMuyPar (y+2)
          aux2 y | cumple (ultimoDigito y) && muyPar y = y
                 | otherwise = siguienteMuyPar (y+1)
    -- *Main> siguienteMuyPar 828268400000
    -- 828268460602
    -- (0.17 secs, 26422112 bytes)
    • Eduardo

      Añadir que el ultimo dígito del número muyPar es 0,2,8 no sirve en esta forma de calcular “siguienteMuyPar”.

  7. Eduardo
    -- Creamos una función booleana que simplemente nos compruebe que se
    -- cumple la premisa de ser muy par:
    todoPar 0 = True
    todoPar x | even x = todoPar(div x 10) 
              | otherwise = False
    muyPar x = todoPar x && todoPar (x^2)
    -- Finalmente, la función pedida por recursión (que suele ser más
    -- eficiente que la comprensión):
     
    siguienteMuyPar x |even x = aux1 (x+2)
                      |odd x = aux2 (x+2)
        where
          aux1 y |  muyPar y = y
                 | otherwise = siguienteMuyPar (y+2)
          aux2 y | muyPar y = y
                 | otherwise = siguienteMuyPar (y+1)
    -- *Main> siguienteMuyPar 828268400000
    -- 828268460602
    -- (0.14 secs, 22334308 bytes)
  8. Eduardo
    --Corrección de la función:
    siguienteMuyPar x |even x = aux (x+2)
                      |odd x = aux (x+1)
        where
          aux y |  muyPar y =  y
                 | otherwise = siguienteMuyPar (y+2)
     
    --   *Main> siguienteMuyPar 828268400000
    -- 828268460602
    -- (0.12 secs, 22779060 bytes)

Escribe tu solución

Este sitio usa Akismet para reducir el spam. Aprende cómo se procesan los datos de tus comentarios.