Pandigitales tridivisibles

4 Comentarios

1. Solo hay seis números con esta propiedad.

   Haskell

   pandigitalesTridivisibles :: [Integer] pandigitalesTridivisibles = map read [n:x|n<-['0'..'9'],x<-xs,pandigital (n:x)] where xs = numero multiplos multiplos :: [[[Char]]] multiplos =map (map (convierte.show) . multiplo) [2,3,5,7,11,13,17] where multiplo n = dropWhile (<10) $ takeWhile (<1000) [n*x|x<-[1..]] convierte xs = if length xs == 2 then '0':xs else xs numero :: [[[Char]]] -> [[Char]] numero (xs:ys:xss) =numero([x ++[last y]|x<-xs,y<-ys,drop (length x -2) x == take 2 y]:xss) numero [xs] = xs pandigital :: [Char] -> Bool pandigital n = sort n == "0123456789"

   1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

   pandigitalesTridivisibles :: [Integer] pandigitalesTridivisibles = map read [n:x|n<-['0'..'9'],x<-xs,pandigital (n:x)]                     where xs = numero multiplos   multiplos :: [[[Char]]] multiplos =map (map (convierte.show) . multiplo) [2,3,5,7,11,13,17]    where multiplo n = dropWhile (<10) $ takeWhile (<1000) [n*x|x<-[1..]]          convierte xs = if length xs == 2 then '0':xs else xs        numero :: [[[Char]]] -> [[Char]] numero (xs:ys:xss) =numero([x ++[last y]|x<-xs,y<-ys,drop (length x -2) x == take 2 y]:xss) numero [xs] = xs      pandigital :: [Char] -> Bool pandigital n = sort n == "0123456789"

   Responder

2. Más eficiente:

   Haskell

   import Data.List ((\\), isSuffixOf) import Data.Numbers.Primes import Control.Monad.State -- Los múltiplos de n como String de 3 letras multiplosDe3C :: Int -> [String] multiplosDe3C n = [show3C (n*i) | i <- [1..div 987 n]] where show3C k = replicate (3 - length (show k)) '0' ++ show k -- Un estado está formado por (Cáracteres sin usar, Sufijo, Índice del primo) -- tomaPT genera posibles cifras a partir de un estado y sus correspondientes nuevos estados tomaPT :: StateT (String, String, Int) [] String tomaPT = StateT $ \(ds, sf, i) -> [(n, (ds \\ n, [a,b], i-1)) | n@[a,b,_] <- multiplosDe3C (primes!!i), null (n \\ (sf ++ ds)), sf `isSuffixOf` n] pandigitalesTridivisibles :: [Integer] pandigitalesTridivisibles = map transf $ runStateT (replicateM 7 tomaPT) ("0123456789","",6) where transf (xs,(a,_,_)) = read (a ++ last xs ++ map last (reverse (init xs)))

   1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19

   import Data.List ((\\), isSuffixOf) import Data.Numbers.Primes import Control.Monad.State   -- Los múltiplos de n como String de 3 letras multiplosDe3C :: Int -> [String] multiplosDe3C n = [show3C (n*i) | i <- [1..div 987 n]]   where show3C k = replicate (3 - length (show k)) '0' ++ show k   -- Un estado está formado por (Cáracteres sin usar, Sufijo, Índice del primo) -- tomaPT genera posibles cifras a partir de un estado y sus correspondientes nuevos estados tomaPT :: StateT (String, String, Int) [] String tomaPT = StateT $ \(ds, sf, i) ->           [(n, (ds \\ n, [a,b], i-1)) | n@[a,b,_] <- multiplosDe3C (primes!!i),                                         null (n \\ (sf ++ ds)), sf `isSuffixOf` n]   pandigitalesTridivisibles :: [Integer] pandigitalesTridivisibles = map transf $ runStateT (replicateM 7 tomaPT) ("0123456789","",6)   where transf (xs,(a,_,_)) = read (a ++ last xs ++ map last (reverse (init xs)))

   Responder

3. Haskell

   import Data.List import Data.Numbers.Primes pandigitalesTridivisibles :: [Integer] pandigitalesTridivisibles = [ read xs | xs <- pandigitales , tridivisible xs ] where pandigitales = permutations "0123456789" trocea xs = [(read . take 3 .drop n) xs | n <- [1..7] ] tridivisible xs = and [ n `mod` p == 0 | (n,p) <- zip (trocea xs) primes] -- optimización aplicando reglas de divisibilidad sencillas para el 2 y el 5 pandigitalesTridivisibles2 :: [Integer] pandigitalesTridivisibles2 = [ read xs | xs <- pandigitales' , tridivisible' xs ] where pandigitales = permutations "0123456789" pandigitales' = [xs | xs <- pandigitales , xs!!3 `elem` "02468" , xs!!5 `elem` "05" ] trocea xs = [(read . take 3 .drop n) xs | n <- [1..7] ] tridivisible' xs = and [ n `mod` p == 0 | (n,p) <- zip (trocea xs) primes , p /= 2 , p /= 5 ]

   1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22

   import Data.List import Data.Numbers.Primes   pandigitalesTridivisibles :: [Integer] pandigitalesTridivisibles = [ read xs | xs <- pandigitales                                       , tridivisible xs ]     where pandigitales = permutations "0123456789"           trocea xs = [(read . take 3 .drop n) xs | n <- [1..7] ]           tridivisible xs = and [ n `mod` p == 0 | (n,p) <- zip (trocea xs) primes]   -- optimización aplicando reglas de divisibilidad sencillas para el 2 y el 5 pandigitalesTridivisibles2 :: [Integer] pandigitalesTridivisibles2 = [ read xs | xs <- pandigitales'                                        , tridivisible' xs ]     where pandigitales = permutations "0123456789"           pandigitales' = [xs | xs <- pandigitales                               , xs!!3 `elem` "02468"                               , xs!!5 `elem` "05" ]           trocea xs = [(read . take 3 .drop n) xs | n <- [1..7] ]           tridivisible' xs = and [ n `mod` p == 0 | (n,p) <- zip (trocea xs) primes                                                  , p /= 2                                                  , p /= 5 ]

   Responder

4. pre lang=”haskell”

   import Data.Numbers.Primes

   import Data.List

   pandigitalesTridivisibles ::[Integer]
   pandigitalesTridivisibles = [read x |x<- pandigitales,esTridivisible x]

   pandigitales :: [[Char]]
   pandigitales = [xs|xs Bool
   esTridivisible (x:xs) = tridivisible xs primes

   tridivisible :: [Char] -> [Int] -> Bool
   tridivisible [a,b] _= True
   tridivisible (x:xs) (y:ys) = mod z y == 0 && tridivisible xs ys
   where z = (read (take 3 (x:xs))::Int)

   /pre

   Responder