Menu Close

Dígitos visibles y ocultos

Una cadena clave es una cadena que contiene dígitos visibles y ocultos. Los dígitos se ocultan mediante las primeras letras minúsculas: la ‘a’ oculta el ‘0’, la ‘b’ el ‘1’ y así sucesivamente hasta la ‘j’ que oculta el ‘9’. Los restantes símbolos de la cadena no tienen significado y se pueden ignorar.

Definir la función

   numeroOculto :: String -> Maybe Integer

tal que (numeroOculto cs) es justo el número formado por los dígitos visibles u ocultos de la cadena clave cs, si cs tiene dígitos y Nothing en caso contrario. Por ejemplo,

   numeroOculto "jihgfedcba"            ==  Just 9876543210
   numeroOculto "JIHGFEDCBA"            ==  Nothing
   numeroOculto "el 23 de Enero"        ==  Just 423344
   numeroOculto "El 23 de Enero"        ==  Just 23344
   numeroOculto "El 23 de enero"        ==  Just 233444
   numeroOculto "Todo para nada"        ==  Just 300030
   numeroOculto (replicate (10^6) 'A')  ==  Nothing

Soluciones

import Data.Char (isDigit, ord, chr)
 
numeroOculto :: String -> Maybe Integer
numeroOculto cs | null aux  = Nothing
                | otherwise = Just (read aux)
    where aux = filter isDigit (map visible cs)
 
visible :: Char -> Char
visible c | c `elem` ['a'..'j'] = chr (ord c - n)
          | otherwise           = c
          where n = ord 'a' - ord '0'

3 soluciones de “Dígitos visibles y ocultos

  1. josejuan
    import Data.Char
    import Data.Maybe
    import Control.Monad
    import Control.Applicative
     
    visible :: Char -> Maybe Char
    visible d = const d <$> guard (isDigit d)
     
    oculto :: Char -> Maybe Char
    oculto d = (const $ chr $ ord d - 49) <$> guard (d `elem` ['a'..'j'])
     
    numeroOculto :: String -> Maybe Integer
    numeroOculto = fmap fst . listToMaybe . reads . mapMaybe (d -> visible d <|> oculto d)
  2. fracruzam
    import Data.Char
     
    numeroOculto :: String -> Maybe Integer
    numeroOculto xs 
       | null (aux xs []) = Nothing
       | otherwise                  = Just (read (aux xs []))
       where 
         aux :: String -> String -> String
         aux [] ns                           = reverse ns
         aux (x:xs) ns | x `elem` ['0'..'9'] = aux xs (x:ns)
                       | x `elem` ['a'..'j'] = aux xs ((traduccion x):ns)
                       | otherwise           = aux xs ns
     
    -- Lista donde se da la relación entre los caracteres.
    eq :: [(Char,Char)]
    eq = zip ['a'..'j'] ['0'..'9']
     
    -- Función que traduce el valor de un caracter a su valor
    -- como caracter numérico.
    traduccion :: Char -> Char
    traduccion x = [y | y <- ['0'..'9'] , (x,y) `elem` eq] !! 0
  3. Chema Cortés
    import Data.Maybe (mapMaybe)
    import Text.Read  (readMaybe)
     
    numeroOculto :: String -> Maybe Integer
    numeroOculto cs = readMaybe $ mapMaybe (`lookup` zs) cs
        where zs = zip "0123456789abcdefghij"
                       "01234567890123456789"

Escribe tu solución

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