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

PorJosé A. Alonso 5-noviembre-201525-abril-2021

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]

1	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]

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

import Data.List

capicuasP2N2D :: [Int]

capicuasP2N2D = [x | x <- productos, esCapicua x]

-- productos es la lista de números menores 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

8 Comentarios

-- 10.000 checks
capicuasP2N2D :: [Int]
capicuasP2N2D = nub [c | a <- [10..99], b <- [a..99], let c = a * b, show c == reverse (show c)]

-- 200 checks
capicuasP2N2D' :: [Int]
capicuasP2N2D' = [c | c <- concat [[1000*a+100*b+10*b+a, 100*a+10*b+a] | a <- [1..9], b <- [0..9]]
                   , any ((0==).mod c) [max 10 (ceiling (fromIntegral c / 99)) .. min 99 (c `div` 10)]]

-- 10.000 checks

capicuasP2N2D :: [Int]

capicuasP2N2D = nub [c | a <- [10..99], b <- [a..99], let c = a * b, show c == reverse (show c)]

-- 200 checks

capicuasP2N2D' :: [Int]

capicuasP2N2D' = [c | c <- concat [[1000*a+100*b+10*b+a, 100*a+10*b+a] | a <- [1..9], b <- [0..9]]

, any ((0==).mod c) [max 10 (ceiling (fromIntegral c / 99)) .. min 99 (c `div` 10)]]

Responder

--El resultado puede ser producto de dos numeros contenidos en el rango
--[10..99], por ello lo resolveremos mediante fuerza bruta(considerando
--fuerza bruta la comprension) al ser un
--intervalo tan pequeño.

--Primero definimos una funcion que nos determine si un numero factoriza
--como producto de dos numeros de dos digitos:
div2elem x = aux x y
    where 
          y = head [t|t<-[div x 100..x],length(show t)==2] 
              --Tomamos como inicio de la
              --recursion un numero de dos cifras.
          aux x y | y > 99 = False
                  | x `mod` y == 0 && length (show (div x y))==2 =True
                  | otherwise = aux x (y+1)
--Eliminamos los casos en los que y alcance un valor que tenga mas de dos digitos.
--Se determina si el multiplo de y tambien tiene dos digitos.
--Si no se verifica se itera con y +1.
-- Determinamos cuando un numero es capicua:
capicua x |show x==reverse(show x) =True
          | otherwise= False
--Generamos todos los numeros y coleccionamos
--aquellos que verifican ser div2elem y capicua:
capicuasP2N2D :: [Int]
capicuasP2N2D = [x|x<-[100..9801],capicua x,div2elem x==True]

--El resultado puede ser producto de dos numeros contenidos en el rango

--[10..99], por ello lo resolveremos mediante fuerza bruta(considerando

--fuerza bruta la comprension) al ser un

--intervalo tan pequeño.

--Primero definimos una funcion que nos determine si un numero factoriza

--como producto de dos numeros de dos digitos:

div2elem x = aux x y

where

y = head [t|t<-[div x 100..x],length(show t)==2]

--Tomamos como inicio de la

--recursion un numero de dos cifras.

aux x y | y > 99 = False

| x `mod` y == 0 && length (show (div x y))==2 =True

| otherwise = aux x (y+1)

--Eliminamos los casos en los que y alcance un valor que tenga mas de dos digitos.

--Se determina si el multiplo de y tambien tiene dos digitos.

--Si no se verifica se itera con y +1.

-- Determinamos cuando un numero es capicua:

capicua x |show x==reverse(show x) =True

| otherwise= False

--Generamos todos los numeros y coleccionamos

--aquellos que verifican ser div2elem y capicua:

capicuasP2N2D :: [Int]

capicuasP2N2D = [x|x<-[100..9801],capicua x,div2elem x==True]

Responder

capicuasP2N2D :: [Int]
capicuasP2N2D = [x | x <- [1..9801], capicua x, esProducto x ]
    where capicua x = show (x) == reverse (show (x))
          esProducto x = or [x == a*b | a <- [10..99], b <- [10..99]]

capicuasP2N2D :: [Int]

capicuasP2N2D = [x | x <- [1..9801], capicua x, esProducto x ]

where capicua x = show (x) == reverse (show (x))

esProducto x = or [x == a*b | a <- [10..99], b <- [10..99]]

Responder

import Data.List

capicuasP2N2D :: [Int]
capicuasP2N2D =
    sort (nub [a*b | a <- [11..99], 
                     b <- [a..99], 
                     show (a*b) == reverse (show (a*b))])

import Data.List

capicuasP2N2D :: [Int]

capicuasP2N2D =

sort (nub [a*b | a <- [11..99],

b <- [a..99],

show (a*b) == reverse (show (a*b))])

Responder

import Data.List

capicuasP2N2D :: [Int]
capicuasP2N2D = filter (\x -> show x == reverse (show x)) producto
    where producto = (nub . sort) [a*b | a <- [10..99], b <- [a..99]]

import Data.List

capicuasP2N2D :: [Int]

capicuasP2N2D = filter (\x -> show x == reverse (show x)) producto

where producto = (nub . sort) [a*b | a <- [10..99], b <- [a..99]]

Responder

import Data.List

capicuasP2N2D :: [Int]
capicuasP2N2D = 
    nub (sort [x * y | x <- [10..99], 
                       y <- [10..99], 
                       show (x*y) == reverse (show (x*y))])

import Data.List

capicuasP2N2D :: [Int]

capicuasP2N2D =

nub (sort [x * y | x <- [10..99],

y <- [10..99],

show (x*y) == reverse (show (x*y))])

Responder

capicuasP2N2D :: [Int]
capicuasP2N2D = [x | x <- capicuas, aux x]

aux x = or [dosCifras (div x n) | n <- [10..99], mod x n == 0] 
        where dosCifras x = length (show x) == 2

capicuas = [x | x <- [121..9009], show x == reverse (show x)]

capicuasP2N2D :: [Int]

capicuasP2N2D = [x | x <- capicuas, aux x]

aux x = or [dosCifras (div x n) | n <- [10..99], mod x n == 0]

where dosCifras x = length (show x) == 2

capicuas = [x | x <- [121..9009], show x == reverse (show x)]

Responder

En lugar de buscar capicúas entre los productos de números de dos cifras, realizo el proceso contrario: buscar entre los capicúas posibles los que sean productos de números de dos cifras. Tiene la ventaja de no necesitar de una ordenación y un deduplicado posterior:

capicuasP2N2D :: [Int]
capicuasP2N2D = filter esP2N2D capicuas

-- Chequea si un número es factorizable en dos números de dos cifras cada uno
esP2N2D :: Int -> Bool
esP2N2D x = (not.null) [ j | i <- [10..99]
                           , x `mod` i == 0
                           , let j = x `div` i
                           , 9 < j && j < 99  ]

-- Obtención de todos los capicúas "candidatos", ordenados y sin duplicados.
capicuas :: [Int]
capicuas =  [ read [a,b,a]   | a <- ['1'..'9'], b <- ['0'..'9'] ]
         ++ [ read [a,b,b,a] | a <- ['1'..'9'], b <- ['0'..'9'] ]

capicuasP2N2D :: [Int]

capicuasP2N2D = filter esP2N2D capicuas

-- Chequea si un número es factorizable en dos números de dos cifras cada uno

esP2N2D :: Int -> Bool

esP2N2D x = (not.null) [ j | i <- [10..99]

, x `mod` i == 0

, let j = x `div` i

, 9 < j && j < 99 ]

-- Obtención de todos los capicúas "candidatos", ordenados y sin duplicados.

capicuas :: [Int]

capicuas = [ read [a,b,a] | a <- ['1'..'9'], b <- ['0'..'9'] ]

++ [ read [a,b,b,a] | a <- ['1'..'9'], b <- ['0'..'9'] ]

Responder

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

Soluciones

8 Comentarios

Escribe tu soluciónCancel reply

Entradas recientes

Buscar

Correo electrónico

Soluciones

Se puede imprimir o compartir con

8 Comentarios

Escribe tu soluciónCancel reply

Entradas recientes

Buscar

Correo electrónico