Menu Close

Números colinas

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

3 soluciones de “Números colinas

  1. luipromor
    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
    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
    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.