Mayúsculas y minúsculas alternadas

PorJosé A. Alonso 4-diciembre-201712-diciembre-2017

Definir la función

   alternadas :: String -> (String,String)

1	alternadas :: String -> (String,String)

tal que (alternadas cs) es el par de cadenas (xs,ys) donde xs es la cadena obtenida escribiendo alternativamente en mayúscula o minúscula las letras de la palabra cs (que se supone que es una cadena de letras minúsculas) e ys se obtiene análogamente pero empezando en minúscula. Por ejemplo,

   λ> alternadas "salamandra"
   ("SaLaMaNdRa","sAlAmAnDrA")
   λ> alternadas "solosequenosenada"
   ("SoLoSeQuEnOsEnAdA","sOlOsEqUeNoSeNaDa")
   λ> alternadas (replicate 30 'a')
   ("AaAaAaAaAaAaAaAaAaAaAaAaAaAaAa","aAaAaAaAaAaAaAaAaAaAaAaAaAaAaA")

λ> alternadas "salamandra"

("SaLaMaNdRa","sAlAmAnDrA")

λ> alternadas "solosequenosenada"

("SoLoSeQuEnOsEnAdA","sOlOsEqUeNoSeNaDa")

λ> alternadas (replicate 30 'a')

("AaAaAaAaAaAaAaAaAaAaAaAaAaAaAa","aAaAaAaAaAaAaAaAaAaAaAaAaAaAaA")

Soluciones

import Data.Char (toUpper)

-- 1ª solución
alternadas :: String -> (String,String)
alternadas []     = ([],[])
alternadas (x:xs) = (toUpper x : zs, x : ys)
  where (ys,zs) = alternadas xs

-- 2ª solución
alternadas2 :: String -> (String,String)
alternadas2 xs =
  ( [f x | (f,x) <- zip (cycle [toUpper,id]) xs]
  , [f x | (f,x) <- zip (cycle [id,toUpper]) xs]
  )

-- Comparación de eficiencia
--    λ> import Data.List
--    λ> let (xs,ys) = alternadas (replicate (10^6) 'a') in nub (xs ++ ys)
--    "Aa"
--    (4.81 secs, 616,143,320 bytes)
--    λ> let (xs,ys) = alternadas2 (replicate (10^6) 'a') in nub (xs ++ ys)
--    "Aa"
--    (3.23 secs, 528,144,752 bytes)

import Data.Char (toUpper)

-- 1ª solución

alternadas :: String -> (String,String)

alternadas [] = ([],[])

alternadas (x:xs) = (toUpper x : zs, x : ys)

where (ys,zs) = alternadas xs

-- 2ª solución

alternadas2 :: String -> (String,String)

alternadas2 xs =

( [f x | (f,x) <- zip (cycle [toUpper,id]) xs]

, [f x | (f,x) <- zip (cycle [id,toUpper]) xs]

)

-- Comparación de eficiencia

-- λ> import Data.List

-- λ> let (xs,ys) = alternadas (replicate (10^6) 'a') in nub (xs ++ ys)

-- "Aa"

-- (4.81 secs, 616,143,320 bytes)

-- λ> let (xs,ys) = alternadas2 (replicate (10^6) 'a') in nub (xs ++ ys)

-- "Aa"

-- (3.23 secs, 528,144,752 bytes)

7 Comentarios

import Data.Char (toUpper)

alternadas :: String -> (String,String)
alternadas xs = (mayusIni xs,minusIni xs)
 
mayusIni :: String -> String
mayusIni (x:y:xs) = toUpper x : y : mayusIni xs
mayusIni [x]      = [toUpper x]
mayusIni _        = []
 
minusIni :: String -> String
minusIni (x:y:xs) = x : toUpper y : minusIni xs
minusIni [y]      = [y]
minusIni _        = []

import Data.Char (toUpper)

alternadas :: String -> (String,String)

alternadas xs = (mayusIni xs,minusIni xs)

mayusIni :: String -> String

mayusIni (x:y:xs) = toUpper x : y : mayusIni xs

mayusIni [x] = [toUpper x]

mayusIni _ = []

minusIni :: String -> String

minusIni (x:y:xs) = x : toUpper y : minusIni xs

minusIni [y] = [y]

minusIni _ = []

Responder

import Data.Char (toUpper)

alternadas :: String -> (String,String)
alternadas xs = (aux1 xs, aux2 xs)
  where aux1 []     = []
        aux1 (x:xs) = toUpper x : aux2 xs
        aux2 []     = []
        aux2 (x:xs) = x : aux1 xs

import Data.Char (toUpper)

alternadas :: String -> (String,String)

alternadas xs = (aux1 xs, aux2 xs)

where aux1 [] = []

aux1 (x:xs) = toUpper x : aux2 xs

aux2 [] = []

aux2 (x:xs) = x : aux1 xs

Si se añade un toLower en aux2 funciona también para mayúsculas.

Responder

Por compresión

import Data.Char (toUpper)

alternadas :: String -> (String, String)
alternadas xs =
  ( [f x y | (x,y) <- zip xs [0..]]
  , [f x y | (x,y) <- zip xs [1..]])
  where f x y | even y    = toUpper x
              | otherwise = x

import Data.Char (toUpper)

alternadas :: String -> (String, String)

alternadas xs =

( [f x y | (x,y) <- zip xs [0..]]

, [f x y | (x,y) <- zip xs [1..]])

where f x y | even y = toUpper x

| otherwise = x

Responder

Por recursión pero con una sola función auxiliar

import Data.Char (toUpper)

alternadas :: String -> (String, String)
alternadas (x:xs) = (aux (x:xs), (x:aux xs))
  where aux (y:z:ys) = toUpper y : z : aux ys
        aux [y]      = [toUpper y]
        aux []       = []

import Data.Char (toUpper)

alternadas :: String -> (String, String)

alternadas (x:xs) = (aux (x:xs), (x:aux xs))

where aux (y:z:ys) = toUpper y : z : aux ys

aux [y] = [toUpper y]

aux [] = []

Responder

import Data.Char (toUpper)

alternadas :: String -> (String,String)
alternadas xs =
  ( [f x | (f,x) <- zip (cycle [toUpper,id]) xs]
  , [f x | (f,x) <- zip (cycle [id,toUpper]) xs]
  )

import Data.Char (toUpper)

alternadas :: String -> (String,String)

alternadas xs =

( [f x | (f,x) <- zip (cycle [toUpper,id]) xs]

, [f x | (f,x) <- zip (cycle [id,toUpper]) xs]

)

Responder

import Data.Char (toUpper)

alternadas :: String -> (String,String)
alternadas xs =
  ( zipWith ($) (cycle [toUpper,id]) xs
  , zipWith ($) (cycle [id,toUpper]) xs )

import Data.Char (toUpper)

alternadas :: String -> (String,String)

alternadas xs =

( zipWith ($) (cycle [toUpper,id]) xs

, zipWith ($) (cycle [id,toUpper]) xs )

Responder

import Data.Char (toUpper)

alternadas :: String -> (String,String)
alternadas []     = ([],[])
alternadas (x:xs) = (toUpper x : zs, x : ys)
  where (ys,zs) = alternadas xs

import Data.Char (toUpper)

alternadas :: String -> (String,String)

alternadas [] = ([],[])

alternadas (x:xs) = (toUpper x : zs, x : ys)

where (ys,zs) = alternadas xs

Responder

Mayúsculas y minúsculas alternadas

Soluciones

7 Comentarios

Escribe tu soluciónCancel reply

Entradas recientes

Buscar

Correo electrónico

Soluciones

Se puede imprimir o compartir con

7 Comentarios

Escribe tu soluciónCancel reply

Entradas recientes

Buscar

Correo electrónico