Menu Close

Capicúas productos de dos números de dos dígitos

El número 9009 es capicúa y es producto de dos números de dos dígitos, pues 9009 = 91×99.

Definir la lista

   capicuasP2N2D :: [Int]

cuyos elementos son los números capicúas que son producto de 2 números de dos dígitos. Por ejemplo,

   take 5  capicuasP2N2D  ==  [121,242,252,272,323]
   length  capicuasP2N2D  ==  74
   drop 70 capicuasP2N2D  ==  [8008,8118,8448,9009]

Soluciones

import Data.List
 
capicuasP2N2D :: [Int]
capicuasP2N2D = [x | x <- productos, esCapicua x]
 
-- productos es la lista de números que son productos de 2 números de
-- dos dígitos.   
productos :: [Int]
productos = sort (nub [x*y | x <- [10..99], y <- [x..99]])
 
-- (esCapicua x) se verifica si x es capicúa.
esCapicua :: Int -> Bool
esCapicua x = xs == reverse xs
  where xs = show x

Pensamiento

Ayudadme a comprender lo que os digo, y os lo explicaré más despacio.

Antonio Machado

Medio

6 soluciones de “Capicúas productos de dos números de dos dígitos

  1. frahidzam
    import Data.List (nub, sort)
     
    capicuasP2N2D :: [Int]
    capicuasP2N2D =
      sort (nub [a*b | a <- [10..99]
                     , b <- [10..99]
                     , esCapicua (a*b)])
     
    esCapicua :: Int -> Bool
    esCapicua n = dig == reverse dig
      where dig = show n
  2. luipromor
    import Data.List (nub, sort)
     
    capicuasP2N2D :: [Int]
    capicuasP2N2D =
      (sort . nub) [z*y | z <- [10..99]
                        , y <- [10..99]
                        , z*y == (read . reverse . show) (z*y)]
  3. sermurgar
    import Data.List (nub, sort)
     
    capicuasP2N2D :: [Int]
    capicuasP2N2D =
      (sort . nub) [a*b | a <- [10..99]
                        , b <- [10..99]
                        , capicua (a*b) ]
     
    capicua :: Integer -> Bool
    capicua m = show m == reverse (show m)
     
    -- λ> :set +s 
    -- λ> capicuasP2N2D
    -- (0.00 secs, 368,488 bytes)
    -- 
    -- λ> map (^2) capicuasP2N2D
    -- (0.00 secs, 592,456 bytes)
    -- 
    -- λ> drop 70 capicuasP2N2D2
    -- (0.00 secs, 144,616 bytes)
    -- 
    -- Podemos ver que se puede trabajar con esta definición.
  4. lucsanand
    import Data.List (nub, sort)
     
    capicuasP2N2D :: [Int]
    capicuasP2N2D =
      sort (nub [a*b | a <- [10..99]
                     , b <- [10..99]
                     , capicua (a*b)])
     
    capicua :: Int -> Bool
    capicua n = n == inverso n
     
    inverso :: Int -> Int
    inverso n = vueltaNumero (reverse (digitos n))
     
    digitos :: Int -> [Int]
    digitos n = [read [x] | x <- show n]
     
    vueltaNumero :: [Int] -> Int
    vueltaNumero xs = sum [y*10^n | (y,n) <- zip (reverse xs) [0..]]
  5. berarcmat
    import Data.List (nub, sort)
     
    capicuasP2N2D :: [Int]
    capicuasP2N2D =
      sort (nub [x*y | (x,y) <- pares 99 10
                     , esCapicua (x*y)])
     
    pares :: Int -> Int -> [(Int,Int)]
    pares a b = [(x,y) | x <- [a,a-1..b]
                       , y <- [a,a-1..x]]
     
    esCapicua :: Int -> Bool
    esCapicua n = dig == reverse dig
      where dig = show n
  6. javmarcha1
    import Data.List (nub)
     
    capicuasP2N2D :: [Int]
    capicuasP2N2D =
      [x | x <- capicuas
         , elem x producto2digitos]
     
    capicuas :: [Int]
    capicuas =
      [x | x <- [10*10..99*99]
         , and [a == b | (a,b) <- (zip (show x) (reverse (show x)))]]
     
    producto2digitos :: [Int]  
    producto2digitos = nub [x*y | x <- [10..99], y <- [10..99]]

Escribe tu solución

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