Otra curiosa propiedad del 123 en Haskell

La relación anterior se basaba en el artículo Una curiosa propiedad del 123 publicado en Gaussianos. Otra curiosa propiedad del 123 se presenta en el artículo Tres productos todos los dígitos publicado esta semana en Números y algo más. A partir del último artículo he elaborado la siguiente relación de ejercicios de Haskell para la asignatura de Informática de 1º del Grado en Matemáticas.

-- ---------------------------------------------------------------------
-- Librerías auxiliares                                               --
-- ---------------------------------------------------------------------

import Data.List

-- ---------------------------------------------------------------------
-- Ejercicio 1. Definir la función
--    cifras :: Int -> [Int]
-- tal que (cifras n) es la lista de las cifras de n. Por ejemplo,
--    cifras 1021052  ==  [1,0,2,1,0,5,2]
-- ---------------------------------------------------------------------

cifras :: Int -> [Int]
cifras n = [read [d] | d <- show n]

-- ---------------------------------------------------------------------
-- Ejercicio 2. Definir la función
--    elementosDistintosNoNulos :: [Int] -> Int
-- tal que (elementosDistintosNoNulos xs) es el número de elementos
-- distintos y no nulos de la lista xs. Por ejemplo,
--    elementosDistintosNoNulos [1,0,2,1,0,5,2]  ==  3
-- --------------------------------------------------------------------- 

elementosDistintosNoNulos :: [Int] -> Int
elementosDistintosNoNulos [] = 0
elementosDistintosNoNulos (x:xs) 
  | x == 0 || elem x xs  = elementosDistintosNoNulos xs
  | otherwise            = 1 + elementosDistintosNoNulos xs

-- ---------------------------------------------------------------------
-- Ejercicio 3. Definir la función
--    cifrasDistintasNoNulas :: Int -> Int
-- tal que (cifrasDistintasNoNulas n) es el número de cifras distintas y
-- no nulas del número n. Por ejemplo,
--    cifrasDistintasNoNulas 1021052  ==  3
-- --------------------------------------------------------------------- 

cifrasDistintasNoNulas :: Int -> Int
cifrasDistintasNoNulas = elementosDistintosNoNulos . cifras

-- ---------------------------------------------------------------------
-- Ejercicio 4. Definir la función
--    factores :: Int -> [(Int,Int,Int)]
-- tal que (factores n) es la lista de ternas de dígitos (x,y,z) talea
-- que n*x, n*y y n*z son tres números de tres cifras que entre los tres
-- tienen los nueve dígitos del uno al nueve sin que se repita ninguno. 
-- Por ejemplo,
--    factores 107  ==  [(3,7,8)]
-- ya que 
--    107*3 = 321, 
--    107*7 = 749 y 
--    107*8 = 856.
-- ---------------------------------------------------------------------

factores :: Int -> [(Int,Int,Int)]
factores n = 
  [(x,y,z) | 
   x <- [1..m],   cifrasDistintasNoNulas (n*x) == 3,
   y <- [x+1..m], cifrasDistintasNoNulas (n*(10^3*x+y)) == 6,
   z <- [y+1..m], cifrasDistintasNoNulas (n*(10^6*x+10^3*y+z)) == 9]
  where m = 999 `div` n

-- ---------------------------------------------------------------------
-- Ejercicio 5. Un número n es completo si tiene 3 cifras y existen 3
-- factores (x,y,z) tales que n*x, n*y y n*z son números de 3 cifras y
-- entre los tres tienen los nueve dígitos del uno al nueve sin que se
-- repita ninguno.  
-- 
-- Definir la constante        
--    completos :: [Int]
-- tal que completos es la lista de los números completos.
--         
-- Calcular todos los números completos.        
-- ---------------------------------------------------------------------

completos :: [Int]
completos = [n | n <- [100..999], not (null (factores n))]

-- El cálculo es
--    ghci> completos
--    [107,109,123,129,192,219,273,327]

-- ---------------------------------------------------------------------
-- Ejercicio 6. Definir la función
--    comunes :: Int -> Int -> Int
-- tal que (comunes x y) es número de las cifras comunes de los
-- números x e y. Por ejemplo,
--    comunes 6563 163479  ==  2
-- ---------------------------------------------------------------------

comunes :: Int -> Int -> Int
comunes x y = length (nub (intersect (cifras x) (cifras y)))

-- ---------------------------------------------------------------------
-- Ejercicio 7. Un número n es completo especial si tiene 3 cifras y 
-- existen 3 factores (x,y,z) tales que n*x, n*y y n*z son números de 3 
-- cifras tales que entre los tres tienen los nueve dígitos del uno al
-- nueve sin que se repita ninguno y, además, n tiene un dígito suyo en
-- cada producto uno de los productos n*x, n*y y n*z.
-- 
-- Definir la constante        
--    completosEspeciales :: [Int]
-- tal que completosEspeciales es la lista de los números completos
-- especiales. 
--         
-- Calcular todos los números completos especiales.       
-- ---------------------------------------------------------------------

completosEspeciales :: [Int]
completosEspeciales =
  [n | n <- completos,
       (x,y,z) <- factores n,
       and [comunes n (n*d) == 1 | d <- [x,y,z]]]

-- El cálculo es
--    ghci> completosEspeciales
--    [123]

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

-- ---------------------------------------------------------------------

-- Librerías auxiliares --

-- ---------------------------------------------------------------------

import Data.List

-- ---------------------------------------------------------------------

-- Ejercicio 1. Definir la función

-- cifras :: Int -> [Int]

-- tal que (cifras n) es la lista de las cifras de n. Por ejemplo,

-- cifras 1021052 == [1,0,2,1,0,5,2]

-- ---------------------------------------------------------------------

cifras :: Int -> [Int]

cifras n = [read [d] | d <- show n]

-- ---------------------------------------------------------------------

-- Ejercicio 2. Definir la función

-- elementosDistintosNoNulos :: [Int] -> Int

-- tal que (elementosDistintosNoNulos xs) es el número de elementos

-- distintos y no nulos de la lista xs. Por ejemplo,

-- elementosDistintosNoNulos [1,0,2,1,0,5,2] == 3

-- ---------------------------------------------------------------------

elementosDistintosNoNulos :: [Int] -> Int

elementosDistintosNoNulos [] = 0

elementosDistintosNoNulos (x:xs)

| x == 0 || elem x xs = elementosDistintosNoNulos xs

| otherwise = 1 + elementosDistintosNoNulos xs

-- ---------------------------------------------------------------------

-- Ejercicio 3. Definir la función

-- cifrasDistintasNoNulas :: Int -> Int

-- tal que (cifrasDistintasNoNulas n) es el número de cifras distintas y

-- no nulas del número n. Por ejemplo,

-- cifrasDistintasNoNulas 1021052 == 3

-- ---------------------------------------------------------------------

cifrasDistintasNoNulas :: Int -> Int

cifrasDistintasNoNulas = elementosDistintosNoNulos . cifras

-- ---------------------------------------------------------------------

-- Ejercicio 4. Definir la función

-- factores :: Int -> [(Int,Int,Int)]

-- tal que (factores n) es la lista de ternas de dígitos (x,y,z) talea

-- que n*x, n*y y n*z son tres números de tres cifras que entre los tres

-- tienen los nueve dígitos del uno al nueve sin que se repita ninguno.

-- Por ejemplo,

-- factores 107 == [(3,7,8)]

-- ya que

-- 107*3 = 321,

-- 107*7 = 749 y

-- 107*8 = 856.

-- ---------------------------------------------------------------------

factores :: Int -> [(Int,Int,Int)]

factores n =

[(x,y,z) |

x <- [1..m], cifrasDistintasNoNulas (n*x) == 3,

y <- [x+1..m], cifrasDistintasNoNulas (n*(10^3*x+y)) == 6,

z <- [y+1..m], cifrasDistintasNoNulas (n*(10^6*x+10^3*y+z)) == 9]

where m = 999 `div` n

-- ---------------------------------------------------------------------

-- Ejercicio 5. Un número n es completo si tiene 3 cifras y existen 3

-- factores (x,y,z) tales que n*x, n*y y n*z son números de 3 cifras y

-- entre los tres tienen los nueve dígitos del uno al nueve sin que se

-- repita ninguno.

-- Definir la constante

-- completos :: [Int]

-- tal que completos es la lista de los números completos.

-- Calcular todos los números completos.

-- ---------------------------------------------------------------------

completos :: [Int]

completos = [n | n <- [100..999], not (null (factores n))]

-- El cálculo es

-- ghci> completos

-- [107,109,123,129,192,219,273,327]

-- ---------------------------------------------------------------------

-- Ejercicio 6. Definir la función

-- comunes :: Int -> Int -> Int

-- tal que (comunes x y) es número de las cifras comunes de los

-- números x e y. Por ejemplo,

-- comunes 6563 163479 == 2

-- ---------------------------------------------------------------------

comunes :: Int -> Int -> Int

comunes x y = length (nub (intersect (cifras x) (cifras y)))

-- ---------------------------------------------------------------------

-- Ejercicio 7. Un número n es completo especial si tiene 3 cifras y

-- existen 3 factores (x,y,z) tales que n*x, n*y y n*z son números de 3

-- cifras tales que entre los tres tienen los nueve dígitos del uno al

-- nueve sin que se repita ninguno y, además, n tiene un dígito suyo en

-- cada producto uno de los productos n*x, n*y y n*z.

-- Definir la constante

-- completosEspeciales :: [Int]

-- tal que completosEspeciales es la lista de los números completos

-- especiales.

-- Calcular todos los números completos especiales.

-- ---------------------------------------------------------------------

completosEspeciales :: [Int]

completosEspeciales =

[n | n <- completos,

(x,y,z) <- factores n,

and [comunes n (n*d) == 1 | d <- [x,y,z]]]

-- El cálculo es

-- ghci> completosEspeciales

-- [123]

Se puede imprimir o compartir con