Eliminación de espacios extremos

PorJosé A. Alonso 10-febrero-201617-febrero-2016

Definir la función

   sinEspaciosExtremos :: String -> String

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

1 2	λ> 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

import Data.Char (isSpace)

sinEspaciosExtremos :: String -> String

sinEspaciosExtremos = f . f

where f = reverse . dropWhile isSpace

13 Comentarios

sinEspaciosExtremos :: String -> String
sinEspaciosExtremos = sinEspaciosIniciales . sinEspaciosFinales

sinEspaciosIniciales :: String -> String
sinEspaciosIniciales "" = ""
sinEspaciosIniciales (' ':xs) = sinEspaciosIniciales xs
sinEspaciosIniciales xs = xs

sinEspaciosFinales :: String -> String
sinEspaciosFinales = reverse . sinEspaciosIniciales . reverse

sinEspaciosExtremos :: String -> String

sinEspaciosExtremos = sinEspaciosIniciales . sinEspaciosFinales

sinEspaciosIniciales :: String -> String

sinEspaciosIniciales "" = ""

sinEspaciosIniciales (' ':xs) = sinEspaciosIniciales xs

sinEspaciosIniciales xs = xs

sinEspaciosFinales :: String -> String

sinEspaciosFinales = reverse . sinEspaciosIniciales . reverse

Responder

sinEspaciosExtremos :: String -> String
sinEspaciosExtremos  = foldr aux [] . dropWhile (==' ')
    where aux ' ' [] = []
          aux x xs   = x:xs

sinEspaciosExtremos :: String -> String

sinEspaciosExtremos = foldr aux [] . dropWhile (==' ')

where aux ' ' [] = []

aux x xs = x:xs

Responder

import Data.List

sinEspaciosExtremos :: String -> String
sinEspaciosExtremos = concat . tail . init . group

import Data.List

sinEspaciosExtremos :: String -> String

sinEspaciosExtremos = concat . tail . init . group

Responder

-- 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

-- 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

--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

--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

Responder

guache dice:

10-febrero-2016 a las 15:41

Haskell

import Data.Char sinEspaciosExtremos :: String -> String sinEspaciosExtremos = f . f where f = reverse . dropWhile isSpace

1
2
3
4

import Data.Char
sinEspaciosExtremos :: String -> String
sinEspaciosExtremos = f . f
where f = reverse . dropWhile isSpace

Responder
guache dice:

10-febrero-2016 a las 15:45

Haskell

sinEspaciosExtremos :: String -> String sinEspaciosExtremos = f . f where f = reverse . dropWhile (==' ')

1
2
3

sinEspaciosExtremos :: String -> String
sinEspaciosExtremos = f . f
where f = reverse . dropWhile (==' ')

Responder

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)

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

-- La definición de espaciosIniciales se puede mejorar así:
espaciosIniciales :: Num a => [Char] -> a
espaciosIniciales (' ':xs) = 1 + espaciosIniciales xs
espaciosIniciales       _  = 0

-- La definición de espaciosIniciales se puede mejorar así:

espaciosIniciales :: Num a => [Char] -> a

espaciosIniciales (' ':xs) = 1 + espaciosIniciales xs

espaciosIniciales _ = 0

Responder

alvalvdom1 dice:

10-febrero-2016 a las 16:42

Haskell

sinEspaciosExtremos :: String -> String sinEspaciosExtremos cs = reverse (dropWhile isSpace (reverse (dropWhile isSpace cs)))

1
2
3

sinEspaciosExtremos :: String -> String
sinEspaciosExtremos cs =
reverse (dropWhile isSpace (reverse (dropWhile isSpace cs)))

Responder
1. alvalvdom1 dice:
  
  12-febrero-2016 a las 16:42
  
  Haskell
  
  import Data.Char sinEspaciosExtremos :: String -> String sinEspaciosExtremos cs = reverse (dropWhile isSpace (reverse (dropWhile isSpace cs)))
  
  1
  2
  3
  4
  5
  
  import Data.Char
  
  sinEspaciosExtremos :: String -> String
  sinEspaciosExtremos cs =
  reverse (dropWhile isSpace (reverse (dropWhile isSpace cs)))
  
  Responder

sinEspaciosExtremos :: String -> String
sinEspaciosExtremos xs = g(f (==' ') (g(f(==' ')  xs)))
                         where f = dropWhile
                               g = reverse

sinEspaciosExtremos :: String -> String

sinEspaciosExtremos xs = g(f (==' ') (g(f(==' ') xs)))

where f = dropWhile

g = reverse

Responder

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

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

Responder

Eliminación de espacios extremos

Soluciones

13 Comentarios

Leave a Reply to guacheCancel reply

Entradas recientes

Buscar

Correo electrónico

Soluciones

Se puede imprimir o compartir con

13 Comentarios

Leave a Reply to guacheCancel reply

Entradas recientes

Buscar

Correo electrónico