Menu Close

Dígitos visibles y ocultos

José A. Alonso,

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'
Medio
, , , , , , , , , ,

3 soluciones de “Dígitos visibles y ocultos”

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