¡EL 22 DE OCTUBRE ES EL DÍA INTERNACIONAL DE BLOQUEO DE MAYÚSCULAS ! Desafortunadamente, algunos no reconocen la gloria del bloqueo de mayúsculas. Dicen que parece "desagradable" o "como gritar" o alguna tontería. PARA CONFORMAR CON ESTAS QUEJAS OBVIAMENTE ILÓGICAS E INANES, POR FAVOR ESCRIBA UN PROGRAMA QUE CONVIERTE EL TEXTO NORMAL EN TEXTO "SENSIBLE" O "RAZONABLE" PARA HACER QUE LA GENTE DEJEN DE QUEJARSE.

Descripción

La entrada y la salida de su solución serán cadenas que contienen solo caracteres ASCII imprimibles.

La cadena de entrada contendrá cero o más ejecuciones de bloqueo de mayúsculas . Una ejecución de bloqueo de mayúsculas (o CLR para abreviar) se define de la siguiente manera:

• El CLR no debe contener letras minúsculas ( a-z), excepto como el primer carácter de una palabra .

  • Una palabra , para los propósitos de este desafío, es una secuencia de no espacios. Así, PPCG, correcthorsebatterystaple, y jkl#@_>00()@#__f-023\f[son todos considerados palabra s.

• El CLR también debe contener al menos un espacio; por lo tanto, debe tener al menos dos palabras s.

• Cada una de las palabras s en el CLR debe contener al menos dos letras ( A-Za-z).

  • Tenga en cuenta que esto se refiere al CLR tomado por sí mismo, sin ningún carácter circundante que no haya sido incluido en el CLR. Por ejemplo, no es un CLR porque la cadena por sí sola tiene la palabra s con menos de dos letras.foO BarO B

Los CLR deben analizarse "con avidez", es decir, siempre debe encontrar los CLR más largos posibles.

Una vez que haya identificado todos los CLR en la cadena de entrada, cambie el caso de todas las letras dentro de los CLR y envíe la cadena resultante.

Casos de prueba

La primera línea es de entrada y la segunda es de salida. Las partes en negrita de la entrada son subcadenas que se consideran CLR.

CAPS LOCK IS THE BEST!
caps lock is the best!

I really LOVE pROGRAMMING pUZZLES AND cOde Golf!
I really love Programming Puzzles and Code Golf!

This is a challenge on PPCG. This is a test CASE. TEST
This is a challenge on PPCG. This is a test case. test

LorEM iPSUM DOLoR sIT amet, conSECTETur ADIPISciNG eLIT. MAECENAS iD orci
Lorem Ipsum doloR sIT amet, conSECTETur ADIPIScing Elit. maecenas Id orci

;'>}{/[]'"A*(389971(*(#$&B#@*(% c'>#{@D#$! :,>/;[e.[{$893F
;'>}{/[]'"a*(389971(*(#$&b#@*(% C'>#{@d#$! :,>/;[e.[{$893F

iT'S cAPS lOCK DAY!!! cELebraTE THis WONDERFUL key
It's Caps Lock day!!! Celebrate this WONDERFUL key

aBcDE fGHIj KLmNO pQrST (uVwXY) ZZ___Zz__Z
aBcde Fghij KLmno PqrST (uVwxy) zz___zz__Z

#aA# aA
#aA# aA

Reglas

• Puede suponer que la entrada nunca contendrá dos o más espacios en una fila, y que nunca contendrá un espacio inicial o final.

• 20% de bonificación (multiplique la longitud de su código por .8) si todo su código es un CLR. ;) (principalmente solo por diversión, ya que es poco probable que la presentación ganadora tenga este bono)

• Este es el código de golf , por lo que gana el código más corto en bytes.

CJam, 100 86 83 81 bytes

Ml{_,),{1$<_S/(4$!>\1f>s+_eu=*S%_{'[,_el^:Af&s,2<},!*1>},_{W=/(AA26m>er}{;(}?\s}h

Pruebe este violín en el intérprete de CJam o verifique todos los casos de prueba a la vez .

Algoritmo

1. Identifique el CLR más largo posible que comienza con el primer carácter.

2. Si existe, cambie su caso, imprímalo y quítelo desde el principio de la cadena.

   De lo contrario, elimine un solo carácter desde el principio de la cadena e imprímalo sin modificaciones.

3. Si quedan más caracteres, regrese al paso 1.

Cómo funciona

Ml         e# Push an empty string and a line from STDIN.
{          e# Do:
  _,       e#   Copy the string on the stack and compute its length (L).
  ),       e#   Push [0 ... L].
  {        e#   Filter; for each integer I in that array:
    1$<    e#     Copy the string and keep its first I characters.
    _S/    e#     Push a copy and split at spaces.
    (      e#     Shift out the first word.
    4$!    e#     Push the logical NOT of the fifth topmost item of the stack.
           e#     This pushes 1 for the empty string on the bottom, and 0
           e#     for non-empty strings and printable characters.
    >      e#     Remove that many characters from the beginning of the first word.
           e#     This will remove the first character iff the string on the
           e#     stack is the entire input. This is to account for the fact that
           e#     the first word is not preceded by a space.
    \1f>   e#     Remove the first character of all remaining words.
    s+     e#     Concatenate all of them.
    _eu=   e#     Convert a copy to uppercase and check for equality.
    *      e#     Repeat the I characters 1 or 0 times.
    S%_    e#     Split at runs of spaces, and push a copy.
    {      e#     Filter; for each non-empty word:
      '[,  e#       Push the string of all ASCII characters up to 'Z'.
      _el  e#       Push a copy and convert to lowercase.
      ^    e#       Perform symmetric difference, pushing all letters (both cases).
      :A   e#       Store the result in A.
      f&s  e#       Intersect A with each character of the word. Cast to string.
      s    e#       This removes all non-letters from the word.
      ,2<  e#       Count the letters, and compare the result to 2.
    },     e#     If there are less than 2 letters, keep the word.
    !      e#     Push the logical NOT of the result.
           e#     This pushes 1 iff all words contain enough letters.
    *      e#     Repeat the array of words that many times.
    1>     e#     Remove the first word.
  },       e#   Keep I if there are still words left.
  _{       e#   If at least one I was kept:
    W=     e#     Select the last (highest) one.
    /      e#     Split the string on the stack into chunks of that length.
    (      e#     Shift out the first chunk.
    AA26m> e#     Push "A...Za...z" and "a...zA...Z".
    er     e#     Perform transliteration to swap cases.
  }{       e#   Else:
    ;      e#     Discard the filtered array.
    (      e#     Shift out the first character of the string on the stack.
  }?       e#
  \s       e#   Swap the shifted out chunk/character with the rest of the string.
}h         e# If the remainder of the string is non-empty, repeat.

Perl, 96 82 80 bytes

-pe'$y=qr/[^a-z ]{2,}|\b\S[^a-z ]+/;s#$y( $y)+#join$,,map{uc eq$_?lc:uc}$&=~/./g#eg'

Pasa todas las pruebas. Asume entrada de STDIN, imprime a STDOUT.

Cómo funciona:

• configurar una expresión regular ( $y) que coincida

  • al menos dos caracteres en minúsculas y sin espacios en blanco O
  • un límite de palabra, seguido de un carácter sin espacios en blanco, seguido de uno o más caracteres en minúsculas y sin espacios en blanco

• hacer coincidir múltiples instancias de cadenas separadas por espacios que coinciden $y, usar s///para invertir mayúsculas y minúsculas

Estoy seguro de que hay margen de mejora. Si hay una manera de deshacerse de todo el join-map-splitacuerdo, aún puede existir la posibilidad de calificar para el bono :)

Javascript, 193

decapslock =

a=>a.replace(/(^[a-z][^a-z ]+|[^a-z ]{2,})( [a-z][^a-z ]+| [^a-z ]{2,})+/g,b=>b.split` `.some(f=>f.split(/[a-z]/i).length<3)?b:b.split``.map(e=>e==(E=e.toUpperCase())?e.toLowerCase():E).join``)

<!-- Snippet UI -->
<input placeholder='sAMPLE tEXT' oninput="document.getElementsByTagName('p')[0].innerText=decapslock(this.value)" />
<p></p>

Explicación:

a=>a.replace(/* giant regex */,
  b=>
    b.split` `.some(
      f=>
        f.split(/[a-z]/i).length < 3   // check for 2+ letters
    )
      ? b                              // .some() immediately returns true if it's invalid
      : b.split``.map(                 // otherwise it's valid, so flip case
          e=>
            e == (E = e.toUpperCase()) // is it uppercase?
              ? e.toLowerCase()        // change it to LC
              : E                      // change it to UC, which was already done for
                                       // the case check
            ).join``
        )

(
^[a-z][^a-z ]+ // check for a CLR starting at the beginning with LC
|
[^a-z ]{2,}    // check for a CLR that begins in the middle of a word or starts at the
               // beginning with UC
               // in both cases, 2+ letters are required
)
(
 [a-z][^a-z ]+ // check for the next word of the CLR, starting with LC
|
 [^a-z ]{2,}   // check for the next word of the CLR, starting with UC
)+             // check for 1 or more next words