Menu Close

Repeticiones consecutivas

Se dice que una palabra tiene una repetición en una frase si es igual a una, o más, de las palabras consecutivas sin distinguir mayúsculas de minúsculas.

Definir la función

   nRepeticionesConsecutivas :: String ->Int

tal que (nRepeticionesConsecutivas cs) es el número de repeticiones de palabras consecutivas de la cadena cs. Por ejemplo,

   nRepeticionesConsecutivas "oso rana"                    == 0      
   nRepeticionesConsecutivas "oso rana oso"                == 0
   nRepeticionesConsecutivas "oso oSo rana"                == 1
   nRepeticionesConsecutivas "oso oso oso rana"            == 1
   nRepeticionesConsecutivas "coronavirus virus oso rana"  == 0
   nRepeticionesConsecutivas "virus     virus oso rana"    == 1
   nRepeticionesConsecutivas "virus oso virus oso rana"    == 0
   nRepeticionesConsecutivas "oso oso oso oso oso oso"     == 1
   nRepeticionesConsecutivas "oso oso oso oso rana rana"   == 2
   nRepeticionesConsecutivas "rana rana oso oso rana rana" == 3

Soluciones

import Data.List (group)
import Data.Char (toUpper)
 
-- 1ª solución
nRepeticionesConsecutivas :: String ->Int
nRepeticionesConsecutivas = aux . words . map toUpper 
  where aux (x:y:zs) | x == y    = 1 + aux (dropWhile (== x) zs)
                     | otherwise = aux (y:zs)
        aux _ = 0
 
-- 2ª solución
nRepeticionesConsecutivas2 :: String ->Int
nRepeticionesConsecutivas2 cs =
  length [xs | xs <- group (words (map toUpper cs)), length xs > 1]
 
-- 3ª solución
nRepeticionesConsecutivas3 :: String ->Int
nRepeticionesConsecutivas3 =
  length . filter ((>1) . length) . group . words . map toUpper

Otras soluciones

  • Se pueden escribir otras soluciones en los comentarios.
  • El código se debe escribir entre una línea con <pre lang="haskell"> y otra con </pre>

Pensamiento

“En el campo de la computación, el momento de la verdad es la ejecución de un programa; todo lo demás es profecía.”

Herbert A. Simon.

3 soluciones de “Repeticiones consecutivas

  1. melgonaco
    import Data.Char (toLower)
     
    nRepeticionesConsecutivas :: String -> Int
    nRepeticionesConsecutivas  = nRepeticiones . words
     
    nRepeticiones :: [[Char]] -> Int
    nRepeticiones (x:y:ys)
      | minuscula x == minuscula y = 1 + nRepeticiones (dropWhile (== x) ys)
      | otherwise                  = nRepeticiones (y:ys)
    nRepeticiones _ = 0
     
    minuscula :: [Char] -> [Char]
    minuscula xs = map toLower xs
  2. juabaerui
    import Data.Char (toLower)
     
    nRepeticionesConsecutivas :: String ->Int
    nRepeticionesConsecutivas = repetidas . words . map toLower
      where repetidas (x:y:xs) | x == y    = 1 + repetidas (dropWhile (== x) xs)
                               | otherwise = repetidas (y:xs)
            repetidas _ = 0
  3. javjimord
    import Data.Char (toLower)
    import Data.List (genericLength,group)
     
    nRepeticionesConsecutivas :: String -> Int
    nRepeticionesConsecutivas cs =
      sum [1 | ys <- group (words ds), genericLength ys > 1]
      where ds = map toLower cs

Leave a Reply

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