Menu Close

Números colinas

José A. Alonso,

Se dice que un número natural n es una colina si su primer dígito es igual a su último dígito, los primeros dígitos son estrictamente creciente hasta llegar al máximo, el máximo se puede repetir y los dígitos desde el máximo al final son estrictamente decrecientes.

Definir la función

   esColina :: Integer -> Bool

tal que (esColina n) se verifica si n es un número colina. Por ejemplo,

   esColina 12377731  ==  True
   esColina 1237731   ==  True
   esColina 123731    ==  True
   esColina 122731    ==  False
   esColina 12377730  ==  False
   esColina 12377730  ==  False
   esColina 10377731  ==  False
   esColina 12377701  ==  False
   esColina 33333333  ==  True

Soluciones

import Data.Char (digitToInt)
 
-- 1ª definición
-- =============
 
esColina :: Integer -> Bool
esColina n =
  head ds == last ds &&
  esCreciente xs &&
  esDecreciente ys
  where ds = digitos n
        m  = maximum ds
        xs = takeWhile (<m) ds
        ys = dropWhile (==m) (dropWhile (<m) ds)
 
-- (digitos n) es la lista de los dígitos de n. Por ejemplo,
--    digitos 425  ==  [4,2,5]
digitos :: Integer -> [Int]
digitos n = map digitToInt (show n)
 
-- (esCreciente xs) se verifica si la lista xs es estrictamente
-- creciente. Por ejemplo,
--    esCreciente [2,4,7]  ==  True
--    esCreciente [2,2,7]  ==  False
--    esCreciente [2,1,7]  ==  False
esCreciente :: [Int] -> Bool
esCreciente xs = and [x < y | (x,y) <- zip xs (tail xs)]
 
-- (esDecreciente xs) se verifica si la lista xs es estrictamente
-- decreciente. Por ejemplo,
--    esDecreciente [7,4,2]  ==  True
--    esDecreciente [7,2,2]  ==  False
--    esDecreciente [7,1,2]  ==  False
esDecreciente :: [Int] -> Bool
esDecreciente xs = and [x > y | (x,y) <- zip xs (tail xs)]
 
-- 2ª definición
-- =============
 
esColina2 :: Integer -> Bool
esColina2 n =
  head ds == last ds &&
  null (dropWhile (==(-1)) (dropWhile (==0) (dropWhile (==1) xs)))
  where ds = digitos n
        xs = [signum (y-x) | (x,y) <- zip ds (tail ds)] 
 
-- Equivalencia
-- ============
 
-- La propiedad de equivalencia es
prop_esColina :: Integer -> Property
prop_esColina n =
  n >= 0 ==> esColina n == esColina2 n 
 
-- La comprobación es
--    λ> quickCheck prop_esColina
--    +++ OK, passed 100 tests.

Referencia

Basado en el problema Is this number a hill number? de Code Golf

Pensamiento

Si me tengo que morir
poco me importa aprender.
Y si no puedo saber,
poco me importa vivir.

Antonio Machado

Posted in Medio
Tagged , , , , , , , , , , , , ,

3 Comments

  1. luipromor
    Responder 
    import Data.List (nub)
 
esColina :: Integer -> Bool
esColina x =
  head xs == last xs
  && creciente (takeWhile (<y) xs)
  && creciente (takeWhile (<y) (reverse xs))
  && (length . nub) (dropWhile (<y) (reverse (dropWhile (<y) xs) )) == 1
  where xs            = show x
        y             = maximum xs
        creciente ys  = and [e < z | (e,z) <-  adyacentes ys]
        adyacentes zs = zip zs (tail zs)
  2. lucsanand
    Responder 
    import Data.List
 
esColina :: Integer -> Bool
esColina n =
  head x == last x &&
  creciente (takeWhile (<y) x) &&
  decreciente (dropWhile (==y) (dropWhile (<y) x))
  where x = digitos n
        y = maximum x
 
digitos :: Integer -> [Integer]
digitos n = [read [x] | x <- show n]
 
creciente :: [Integer] -> Bool
creciente xs = and [x < y | (x,y) <- zip xs (tail xs)]
 
decreciente :: [Integer] -> Bool
decreciente xs = and [x > y | (x,y) <- zip xs (tail xs)]
  3. frahidzam
    Responder 
    esColina :: Integer -> Bool
esColina n =
  head (digitos n) == last (digitos n) &&
  colina1 (digitos n)
 
digitos :: Integer -> [Integer]
digitos n = [read [x] | x <- show n]
 
colina1 :: [Integer] -> Bool
colina1 (a:b:xs) | a <= b    = colina1 (b:xs)
                 | otherwise = colina2 (b:xs)
colina1 _ = True
 
colina2 :: [Integer] -> Bool
colina2 (a:b:xs) | a >= b    = colina2 (b:xs)
                 | otherwise = False
colina2 _ = True

Escribe tu solución

Este sitio usa Akismet para reducir el spam. Aprende cómo se procesan los datos de tus comentarios.