Números alternados

Decimos que un número es alternado si no tiene dos cifras consecutivas iguales ni tres cifras consecutivas en orden creciente no estricto o decreciente no estricto. Por ejemplo, los números 132425 y 92745 son alternados, pero los números 12325 y 29778 no. Las tres primeras cifras de 12325 están en orden creciente y 29778 tiene dos cifras iguales consecutivas.

Definir la constante

   alternados :: [Integer]

1	alternados :: [Integer]

cuyo valor es la lista infinita de los números alternados. Por ejemplo,

   take 10 alternados                      ==  [0,1,2,3,4,5,6,7,8,9]
   length (takeWhile (< 1000) alternados)  ==  616
   alternados !! 1234567                   ==  19390804

take 10 alternados == [0,1,2,3,4,5,6,7,8,9]

length (takeWhile (< 1000) alternados) == 616

alternados !! 1234567 == 19390804

Soluciones

import Data.Char (digitToInt)

-- 1ª definición
-- =============

-- (cifras n) es la lista de las cifras de n. Por ejemplo.
--    cifras 325  ==  [3,2,5]
cifras :: Integer -> [Int]
cifras n = map digitToInt (show n)

-- (cifrasAlternadas xs) se verifica si las lista de cifras xs es
-- alternada. Por ejemplo,
--    cifrasAlternadas [1,3,2,4,2,5]  ==  True
--    cifrasAlternadas [9,2,7,4,5]    ==  True
--    cifrasAlternadas [1,2,3,2,5]    ==  False
--    cifrasAlternadas [2,9,7,7,8]    ==  False
cifrasAlternadas :: [Int] -> Bool
cifrasAlternadas [x1,x2] = x1 /= x2
cifrasAlternadas (x1:x2:x3:xs) =
    not (((x1 <= x2) && (x2 <= x3)) || ((x1 >= x2) && (x2 >= x3))) &&
    cifrasAlternadas (x2:x3:xs)
cifrasAlternadas _ = True

-- (alternado n) se verifica si n es un número alternado. Por ejemplo,
--    alternado 132425  ==  True
--    alternado 92745   ==  True
--    alternado 12325   ==  False
--    alternado 29778   ==  False
alternado :: Integer -> Bool
alternado n = cifrasAlternadas (cifras n)

alternados1 :: [Integer]
alternados1 = filter alternado [0..]

-- 2ª definición
-- =============

-- (extiendeAlternado n) es la lista de números alternados que se pueden
-- obtener añadiendo una cifra al final del número alternado n. Por
-- ejemplo,
--    extiendeAlternado 7   ==  [70,71,72,73,74,75,76,78,79]
--    extiendeAlternado 24  ==  [240,241,242,243]
--    extiendeAlternado 42  ==  [423,424,425,426,427,428,429]
extiendeAlternado :: Integer -> [Integer]
extiendeAlternado n 
    | n < 10    = [n*10+h | h <- [0..n-1]++[n+1..9]]
    | d < c     = [n*10+h | h <- [0..c-1]]
    | otherwise = [n*10+h | h <- [c+1..9]]
    where c = n `mod` 10
          d = (n `mod` 100) `div` 10

alternados2 :: [Integer]
alternados2 = concat (iterate (concatMap extiendeAlternado) [0])

import Data.Char (digitToInt)

-- 1ª definición

-- =============

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

-- cifras 325 == [3,2,5]

cifras :: Integer -> [Int]

cifras n = map digitToInt (show n)

-- (cifrasAlternadas xs) se verifica si las lista de cifras xs es

-- alternada. Por ejemplo,

-- cifrasAlternadas [1,3,2,4,2,5] == True

-- cifrasAlternadas [9,2,7,4,5] == True

-- cifrasAlternadas [1,2,3,2,5] == False

-- cifrasAlternadas [2,9,7,7,8] == False

cifrasAlternadas :: [Int] -> Bool

cifrasAlternadas [x1,x2] = x1 /= x2

cifrasAlternadas (x1:x2:x3:xs) =

not (((x1 <= x2) && (x2 <= x3)) || ((x1 >= x2) && (x2 >= x3))) &&

cifrasAlternadas (x2:x3:xs)

cifrasAlternadas _ = True

-- (alternado n) se verifica si n es un número alternado. Por ejemplo,

-- alternado 132425 == True

-- alternado 92745 == True

-- alternado 12325 == False

-- alternado 29778 == False

alternado :: Integer -> Bool

alternado n = cifrasAlternadas (cifras n)

alternados1 :: [Integer]

alternados1 = filter alternado [0..]

-- 2ª definición

-- =============

-- (extiendeAlternado n) es la lista de números alternados que se pueden

-- obtener añadiendo una cifra al final del número alternado n. Por

-- ejemplo,

-- extiendeAlternado 7 == [70,71,72,73,74,75,76,78,79]

-- extiendeAlternado 24 == [240,241,242,243]

-- extiendeAlternado 42 == [423,424,425,426,427,428,429]

extiendeAlternado :: Integer -> [Integer]

extiendeAlternado n

| n < 10 = [n*10+h | h <- [0..n-1]++[n+1..9]]

| d < c = [n*10+h | h <- [0..c-1]]

| otherwise = [n*10+h | h <- [c+1..9]]

where c = n `mod` 10

d = (n `mod` 100) `div` 10

alternados2 :: [Integer]

alternados2 = concat (iterate (concatMap extiendeAlternado) [0])

3 Comentarios

alternados :: [Integer]
alternados = filter alternado [0..]

alternado :: Integer -> Bool
alternado = aux.show
    where aux xs = and (zipWith3 f xs (drop 1 xs) (drop 2 xs)) &&
                   and (zipWith (/=) xs (drop 1 xs))
          f a b c = not $ (a<=b && b<=c) || (a>=b && b>=c)

alternados = filter alternado [0..]

alternado = aux.show

where aux xs = and (zipWith3 f xs (drop 1 xs) (drop 2 xs)) &&

and (zipWith (/=) xs (drop 1 xs))

f a b c = not $ (a<=b && b<=c) || (a>=b && b>=c)

Responder

alternados :: [Integer]
alternados = filter (alternado . show) [0..]
    where alternado (x:y:z:zs) = and [x /= y,
                                      not (x < y && y < z),
                                      not (x > y && y > z),
                                      alternado (y:z:zs)]
          alternado [x,y]      = x /= y
          alternado _          = True

alternados = filter (alternado . show) [0..]

where alternado (x:y:z:zs) = and [x /= y,

not (x < y && y < z),

not (x > y && y > z),

alternado (y:z:zs)]

alternado [x,y] = x /= y

alternado _ = True

type BinOp a = a -> a -> Bool

-- aplica indefinidamente la operación binaria, intercambiando los argumentos (flip)
-- por ejemplo, (alterna (>)) equivale a [(>),(<),(>),....]
alterna :: BinOp a -> [a] -> [a] -> Bool
alterna binOp xs ys = and $ zipWith3 id (iterate flip binOp) xs ys

alternados :: [Integer]
alternados = filter (alternado.show) [0..]
    where alternado (x:y:xs) | x > y     = alterna (<) (y:xs) xs
                             | x < y     = alterna (>) (y:xs) xs
                             | otherwise = False
          alternado _ = True

type BinOp a = a -> a -> Bool

-- aplica indefinidamente la operación binaria, intercambiando los argumentos (flip)

-- por ejemplo, (alterna (>)) equivale a [(>),(<),(>),....]

alterna :: BinOp a -> [a] -> [a] -> Bool

alterna binOp xs ys = and $ zipWith3 id (iterate flip binOp) xs ys

where alternado (x:y:xs) | x > y = alterna (<) (y:xs) xs

| x < y = alterna (>) (y:xs) xs

| otherwise = False

Números alternados

Soluciones

3 Comentarios

Escribe tu soluciónCancel reply

Entradas recientes

Buscar

Correo electrónico

Soluciones

Se puede imprimir o compartir con

3 Comentarios

Escribe tu soluciónCancel reply

Entradas recientes

Buscar

Correo electrónico