Menu Close

Eliminación de espacios extremos

José A. Alonso,

Definir la función

   sinEspaciosExtremos :: String -> String

tal que (sinEspaciosExtremos cs) es la cadena obtenida eliminando los espacios blancos de los extremos de la cadena cs. Por ejemplo,

   λ> sinEspaciosExtremos "   El lunes a las 12:30.     "
   "El lunes a las 12:30."

Soluciones

import Data.Char (isSpace)
 
sinEspaciosExtremos :: String -> String
sinEspaciosExtremos = f . f
    where f = reverse . dropWhile isSpace
Inicial
, ,

13 soluciones de “Eliminación de espacios extremos”

  1. Responder
    carruirui3 
    sinEspaciosExtremos :: String -> String
sinEspaciosExtremos = sinEspaciosIniciales . sinEspaciosFinales
 
sinEspaciosIniciales :: String -> String
sinEspaciosIniciales "" = ""
sinEspaciosIniciales (' ':xs) = sinEspaciosIniciales xs
sinEspaciosIniciales xs = xs
 
sinEspaciosFinales :: String -> String
sinEspaciosFinales = reverse . sinEspaciosIniciales . reverse
  2. Responder
    Chema Cortés 
    sinEspaciosExtremos :: String -> String
sinEspaciosExtremos  = foldr aux [] . dropWhile (==' ')
    where aux ' ' [] = []
          aux x xs   = x:xs
  3. Responder
    fracruzam 
    import Data.List
 
sinEspaciosExtremos :: String -> String
sinEspaciosExtremos = concat . tail . init . group
    • Responder
      fracruzam 
      -- La definición anterior falla con ejemplos como:
-- *Main> sinEspaciosExtremos "SinEspacios"
-- "inEspacio"
 
import Data.List
 
sinEspaciosExtremos2 :: String -> String
sinEspaciosExtremos2 = concat . aux . group
  where aux :: [String] -> [String]
        aux (x:xs) | elem ' ' x && elem ' ' ls = init    xs
                   | elem ' ' x                =         xs
                   |               elem ' ' ls = init (x:xs)
                   | otherwise                 =      (x:xs)
          where ls = last xs
      • Responder
        fracruzam 
        --Mejora de la eficiencia
 
import Data.List
 
sinEspaciosExtremos3 :: String -> String
sinEspaciosExtremos3 = concat . aux . group
  where aux :: [String] -> [String]
        aux ys@((x:xs):xss) | ' ' == x && ' ' == l = init xss
                            | ' ' == x             =      xss
                            |             ' ' == l = init ys
                            | otherwise            =      ys
          where (l:ls) = last xss
  4. Responder
    guache 
    import Data.Char
sinEspaciosExtremos :: String -> String
sinEspaciosExtremos = f . f
   where f = reverse . dropWhile isSpace
  5. Responder
    guache 
    sinEspaciosExtremos :: String -> String
sinEspaciosExtremos = f . f
   where f = reverse . dropWhile (==' ')
  6. Responder
    juamorrom1 
    sinEspaciosExtremos :: String -> String
sinEspaciosExtremos cs = reverse $ drop (espaciosFinales cs) ( reverse (drop (espaciosIniciales cs) cs) )
 
espaciosIniciales [] = 0
espaciosIniciales (c:cs) | c == ' ' = 1 + espaciosIniciales cs
                                     | otherwise = espaciosIniciales []
 
espaciosFinales cs = espaciosIniciales (reverse cs)
    • Responder
      juamorrom1 
      -- La definición de espaciosIniciales se puede mejorar así:
espaciosIniciales :: Num a => [Char] -> a
espaciosIniciales (' ':xs) = 1 + espaciosIniciales xs
espaciosIniciales       _  = 0
  7. Responder
    alvalvdom1 
    sinEspaciosExtremos :: String -> String
sinEspaciosExtremos cs = 
    reverse (dropWhile isSpace (reverse (dropWhile isSpace cs)))
    • Responder
      alvalvdom1 
      import Data.Char
 
sinEspaciosExtremos :: String -> String
sinEspaciosExtremos cs = 
    reverse (dropWhile isSpace (reverse (dropWhile isSpace cs)))
  8. Responder
    blaruiher 
     
sinEspaciosExtremos :: String -> String
sinEspaciosExtremos xs = g(f (==' ') (g(f(==' ')  xs)))
                         where f = dropWhile
                               g = reverse
  9. Responder
    manvermor 
    import Data.List
 
sinEspaciosExtremos :: String -> String
sinEspaciosExtremos cs | isSpace d && isSpace e = concat $ init $ tail $ group cs
                       | isSpace d = concat $ tail $ group cs
                       | isSpace e = concat $ init $ group cs
                       | otherwise = cs
                                     where d = head cs
                                           e = last cs

Escribe tu solución

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