Menu Close

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

José A. Alonso,

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. Responder
    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. Responder
    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. Responder
    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. Responder
    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. Responder
    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. Responder
    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.