Pandigitales múltiplos de un número por una lista de números

Un número pandigital es un número que contiene todos los dígitos del 1 al 9 sólo una vez. Por ejemplo, 192384576 es un número pandigital.

El producto de un número natural x por una lista de números naturales ys es el número obtenido concatenando los productos de x por cada uno de los elementos de ys. Por ejemplo, el producto de 2 por [3,2,5] es 6410.

Un número pandigital x es un múltiplo si existe un y y un n > 1 tales que x es el producto de y por [1,2,3,…,n]. Por ejemplo, 192384576 es un pandigital múltiplo ya que

   192 × 1 = 192
   192 × 2 = 384
   192 × 3 = 576

192 × 1 = 192

192 × 2 = 384

192 × 3 = 576

por tanto, 192384576 es el producto de 192 por [1,2,3]. Otro pandgital múltiplo es el 918273645 ya que es el producto de 9 por [1,2,3,4,5].

Definir la sucesión

   pandigitalesMultiplos :: [Integer]

1	pandigitalesMultiplos :: [Integer]

tal que sus elementos son los números pandigitales múltiplos. Por ejemplo,

   ghci> take 5 pandigitalesMultiplos
   [123456789,192384576,219438657,273546819,327654981]

1 2	ghci> take 5 pandigitalesMultiplos [123456789,192384576,219438657,273546819,327654981]

Soluciones

import Data.List (sort)

pandigitalesMultiplos :: [Integer]
pandigitalesMultiplos =
    sort [y | x <- [1..a],
              y <- productosCon9Digitos x,
              esPandigital y]
    where a = head [x | x <- [1..], producto x [1,2] > 987654321]

-- (productosCon9Digitos x) es la lista de los productos de x por una
-- lista [1,2,...,n] (con n > 1) que tienen 9 dígitos, Por ejemplo, 
--    productosCon9Digitos 3  ==  [369121518]
--    productosCon9Digitos 2  ==  []
productosCon9Digitos :: Integer -> [Integer]
productosCon9Digitos x | numeroDeDigitos z == 9 = [z]
                       | otherwise              = []
    where z = head [y | n <- [2..], 
                        let y = producto x [1..n], 
                        numeroDeDigitos y >= 9]

-- (producto x ys) es el producto de x por ys. Por ejemplo,
--    producto 2 [3,2,5]  ==  6410
producto :: Integer -> [Integer] -> Integer
producto x = read . concatMap (show . (x*))

-- (numeroDeDigitos x) es el número de dígitos de x. Por ejemplo,
--    numeroDeDigitos 425  ==  3
numeroDeDigitos :: Integer -> Int
numeroDeDigitos = length . show

-- (esPandigital x) se verifica si x es pandigital. Por ejemplo,
--    esPandigital 192384576   ==  True
--    esPandigital 192314576   ==  False
--    esPandigital 1923145761  ==  False
esPandigital :: Integer -> Bool
esPandigital n = sort (show n) == "123456789"

-- La lista de los pandigitales múltiplos se calcula por
--    ghci> pandigitalesMultiplos
--    [123456789, 192384576, 219438657, 273546819, 327654981, 672913458,
--     679213584, 692713854, 726914538, 729314586, 732914658, 769215384,
--     792315846, 793215864, 918273645, 926718534, 927318546, 932718654]

import Data.List (sort)

pandigitalesMultiplos :: [Integer]

pandigitalesMultiplos =

sort [y | x <- [1..a],

y <- productosCon9Digitos x,

esPandigital y]

where a = head [x | x <- [1..], producto x [1,2] > 987654321]

-- (productosCon9Digitos x) es la lista de los productos de x por una

-- lista [1,2,...,n] (con n > 1) que tienen 9 dígitos, Por ejemplo,

-- productosCon9Digitos 3 == [369121518]

-- productosCon9Digitos 2 == []

productosCon9Digitos :: Integer -> [Integer]

productosCon9Digitos x | numeroDeDigitos z == 9 = [z]

| otherwise = []

where z = head [y | n <- [2..],

let y = producto x [1..n],

numeroDeDigitos y >= 9]

-- (producto x ys) es el producto de x por ys. Por ejemplo,

-- producto 2 [3,2,5] == 6410

producto :: Integer -> [Integer] -> Integer

producto x = read . concatMap (show . (x*))

-- (numeroDeDigitos x) es el número de dígitos de x. Por ejemplo,

-- numeroDeDigitos 425 == 3

numeroDeDigitos :: Integer -> Int

numeroDeDigitos = length . show

-- (esPandigital x) se verifica si x es pandigital. Por ejemplo,

-- esPandigital 192384576 == True

-- esPandigital 192314576 == False

-- esPandigital 1923145761 == False

esPandigital :: Integer -> Bool

esPandigital n = sort (show n) == "123456789"

-- La lista de los pandigitales múltiplos se calcula por

-- ghci> pandigitalesMultiplos

-- [123456789, 192384576, 219438657, 273546819, 327654981, 672913458,

-- 679213584, 692713854, 726914538, 729314586, 732914658, 769215384,

-- 792315846, 793215864, 918273645, 926718534, 927318546, 932718654]

4 Comentarios

pandigitalesMultiplos :: [Integer]
pandigitalesMultiplos = [x | x <- listaPandigitales, pandEsMultiplo x]

listaPandigitales :: [Integer]
listaPandigitales = [x | x <- [123456789..987654321], esPandigital x]

esPandigital :: Integer -> Bool
esPandigital x = show x \\ "123456789" == []

pandEsMultiplo :: Integer -> Bool
pandEsMultiplo x = or [x == producto y [1..n] | y <- [1..10000], n <- [2..9]]

producto :: Integer -> [Integer] -> Integer
producto x ys = read (concat (aux x ys))
    where aux _ []     = []
          aux x (y:ys) = show (x*y) : aux x ys

pandigitalesMultiplos :: [Integer]

pandigitalesMultiplos = [x | x <- listaPandigitales, pandEsMultiplo x]

listaPandigitales :: [Integer]

listaPandigitales = [x | x <- [123456789..987654321], esPandigital x]

esPandigital :: Integer -> Bool

esPandigital x = show x \\ "123456789" == []

pandEsMultiplo :: Integer -> Bool

pandEsMultiplo x = or [x == producto y [1..n] | y <- [1..10000], n <- [2..9]]

producto :: Integer -> [Integer] -> Integer

producto x ys = read (concat (aux x ys))

where aux _ [] = []

aux x (y:ys) = show (x*y) : aux x ys

Responder

isPandi xs = not ('0' `elem` xs) && length (nub xs) == length xs
isCompleto xs = isPandi xs && length xs == 9
grow y = filter isCompleto $ map ((show y++).concat) $ inits $ takeWhile isPandi [show (k * y) | k <- [2..]]
pandigitalesMultiplos = concatMap grow $ filter (isPandi . show) [1..9999]

isPandi xs = not ('0' `elem` xs) && length (nub xs) == length xs

isCompleto xs = isPandi xs && length xs == 9

grow y = filter isCompleto $ map ((show y++).concat) $ inits $ takeWhile isPandi [show (k * y) | k <- [2..]]

pandigitalesMultiplos = concatMap grow $ filter (isPandi . show) [1..9999]

Responder

pandigitalesMultiplos :: [Integer]
pandigitalesMultiplos = filter esMultiplo pandigitales
 
pandigitales :: [Integer]
pandigitales = map read (permutations "123456789")
 
esMultiplo :: Integer -> Bool
esMultiplo x = any aux [[1..n] | n <- [2..9]]
     where aux xs = last (takeWhile (<=x) $ map (`producto` xs) [1..9999]) == x

producto :: Integer -> [Integer] -> Integer
producto x = read . concatMap (show . (x*))

pandigitalesMultiplos :: [Integer]

pandigitalesMultiplos = filter esMultiplo pandigitales

pandigitales :: [Integer]

pandigitales = map read (permutations "123456789")

esMultiplo :: Integer -> Bool

esMultiplo x = any aux [[1..n] | n <- [2..9]]

where aux xs = last (takeWhile (<=x) $ map (`producto` xs) [1..9999]) == x

producto :: Integer -> [Integer] -> Integer

producto x = read . concatMap (show . (x*))

Responder

import qualified Data.Set as S
import Data.List 

producto :: Integer -> [Integer] -> Integer
producto x = read . concatMap (show . (x*))

pandigitalesMultiplos :: [Integer]
pandigitalesMultiplos = 
 sort [x | y <- [1..9999], n <- [2..9`div`genericLength (show y)],
 let x = producto y [1..n],  esPandigital x]
  where esPandigital n = length (show n) == 9 &&
                         S.fromList (show n) == S.fromList "123456789"

import qualified Data.Set as S

import Data.List

producto :: Integer -> [Integer] -> Integer

producto x = read . concatMap (show . (x*))

pandigitalesMultiplos :: [Integer]

pandigitalesMultiplos =

sort [x | y <- [1..9999], n <- [2..9`div`genericLength (show y)],

let x = producto y [1..n], esPandigital x]

where esPandigital n = length (show n) == 9 &&

S.fromList (show n) == S.fromList "123456789"

Responder

Pandigitales múltiplos de un número por una lista de números

Soluciones

4 Comentarios

Escribe tu soluciónCancel reply

Entradas recientes

Buscar

Correo electrónico

Soluciones

Se puede imprimir o compartir con

4 Comentarios

Escribe tu soluciónCancel reply

Entradas recientes

Buscar

Correo electrónico