Menu Close

Cadenas opuestas

José A. Alonso,

La opuesta de una cadena de letras es la cadena obtenida cambiando las minúsculas por mayúsculas y las minúsculas por mayúsculas. Por ejemplo, la opuesta de “SeViLLa” es “sEvIllA”.

Definir la función

   esOpuesta :: String -> String -> Bool

tal que (esOpuesta s1 s2) se verifica si las cadenas de letras s1 y s2 son opuestas. Por ejemplo,

   esOpuesta "ab" "AB"      `== True
   esOpuesta "aB" "Ab"      `== True
   esOpuesta "aBcd" "AbCD"  `== True
   esOpuesta "aBcde" "AbCD" `== False
   esOpuesta "AB" "Ab"      `== False
   esOpuesta "" ""          `== True

Soluciones

import Data.Char (isLower, isUpper, ord, toLower, toUpper)
 
-- 1ª solución (por comprensión)
-- =============================
 
esOpuesta1 :: String -> String -> Bool
esOpuesta1 s1 s2 = [opuesto c | c <- s1] == s2
 
opuesto :: Char -> Char
opuesto c
  | isLower c = toUpper c
  | otherwise = toLower c
 
-- 2ª solución (con map)
-- =====================
 
esOpuesta2 :: String -> String -> Bool
esOpuesta2 s1 s2 = map opuesto s1 == s2
 
-- 3ª solución (por recursión)
-- ===========================
 
esOpuesta3 :: String -> String -> Bool
esOpuesta3 "" ""           = True
esOpuesta3 (c1:s1) (c2:s2) = esOpuesto c1 c2 && esOpuesta3 s1 s2
esOpuesta3 _ _             = False
 
esOpuesto :: Char -> Char -> Bool
esOpuesto c1 c2 = abs (ord c1 - ord c2) == 32
Inicial
, , , , , , , ,

8 soluciones de “Cadenas opuestas”

  1. Responder
    angruicam1 
    import Data.Char (isUpper,toLower,toUpper)
 
esOpuesta :: String -> String -> Bool
esOpuesta (s:s1) (r:s2)
  | isUpper s   = toLower s == r && esOpuesta s1 s2
  | otherwise   = toUpper s == r && esOpuesta s1 s2
esOpuesta [] [] = True
esOpuesta _ _   = False
  2. Responder
    antnavoro 
    import Data.Char (ord)
 
esOpuesta :: String -> String -> Bool
esOpuesta "" ""         = True
esOpuesta (s:s1) (r:s2) = abs (ord s - ord r) == 32 && esOpuesta s1 s2
esOpuesta _ _           = False
  3. Responder
    alerodrod5 
     
import Data.Char
 
esOpuesta :: String -> String -> Bool
esOpuesta xs ys = opuesta xs == ys
 
opuesta :: String -> String
opuesta (x:xs) | isLower x = toUpper x : opuesta xs
               | otherwise = toLower x : opuesta xs
opuesta _ = []
  4. Responder
    albcarcas1 
    import Data.Char
 
esOpuesta :: String -> String -> Bool
esOpuesta xs ys =
  and [x == contrario y |(x,y) <- zip xs ys] && length xs == length ys
  where contrario y | isUpper y = toLower y
                    | otherwise = toUpper y
  5. Responder
    rocruimon 
    import Data.Char
 
esOpuesta :: String -> String -> Bool
esOpuesta xs ys = opuesta xs == ys
 
opuesta :: String -> String
opuesta xs = [opuestas x | x <- xs]
 
opuestas :: Char -> Char
opuestas c | isLower c = toUpper c
           | otherwise = toLower c
  6. Responder
    menvealer 
    esOpuesta :: String -> String -> Bool
esOpuesta xs ys = map (opuestas) xs == ys
 
opuestas :: Char -> Char
opuestas x | isLower x = toUpper x
           | otherwise = toLower x
  7. Responder
    canongoo72 
    import Data.Char (toUpper, toLower)
 
letraOpuesta x = if elem x ['a'..'z'] then toUpper x else toLower x
 
cadenaOpuesta = map letraOpuesta
 
esOpuesta :: String -> String -> Bool
esOpuesta xs ys = cadenaOpuesta xs == ys
  8. Responder
    esppercab 
    esOpuesta :: String -> String -> Bool
esOpuesta "" "" = True
esOpuesta _ "" = False
esOpuesta "" _ = False
esOpuesta (s:s1) (a:s2) | isUpper s == isLower a   = True && esOpuesta s1 s2
                        | isLower s == isUpper a   = True && esOpuesta s1 s2
                        |otherwise                 = False

Escribe tu solución

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