LE 22 OCTOBRE EST LA JOURNÉE INTERNATIONALE DE SERRURE DES CAPSULES ! MALHEUREUSEMENT, CERTAINS NE RECONNAISSENT PAS LA GLOIRE DE LA SERRURE TOUT-PUISSANT. ILS DISENT QU'IL SEMBLE "OBNOXIEUX" OU "COMME CRIER" OU QUELQUE SENS. AFIN DE SE CONFORMER À CES PLAINTES ILLOGIQUES ET INNÉES, VEUILLEZ M'ÉCRIRE UN PROGRAMME QUI TRANSFORME LE TEXTE NORMAL EN TEXTE "SENSIBLE" OU "RAISONNABLE" POUR FAIRE ARRÊTER LES PLAINTES.

La description

L'entrée et la sortie de votre solution seront toutes deux des chaînes contenant uniquement des caractères ASCII imprimables.

La chaîne d'entrée contiendra zéro ou plusieurs exécutions de verrouillage des majuscules . Un cycle de verrouillage des majuscules (ou CLR pour faire court) est défini comme suit:

• Le CLR ne doit contenir aucune lettre minuscule ( a-z), sauf comme premier caractère d'un mot .

  • Un mot , pour l'application de ce défi, est une séquence de non-espaces. Ainsi, PPCG, correcthorsebatterystapleet jkl#@_>00()@#__f-023\f[sont tous considérés comme mot s.

• Le CLR doit également contenir au moins un espace; par conséquent, il doit s'agir d'au moins deux mots .

• Chacun des mots s du CLR doit contenir au moins deux lettres ( A-Za-z).

  • Notez que cela fait référence au CLR pris seul, sans aucun caractère environnant qui pourrait ne pas avoir été inclus dans le CLR. Par exemple, n'est pas un CLR car la chaîne en elle-même a un mot s avec moins de deux lettres.foO BarO B

Les CLR doivent être analysés «avec avidité», c'est-à-dire que vous devez toujours trouver les CLR les plus longs possibles.

Une fois que vous avez identifié tous les CLR dans la chaîne d'entrée, permutez la casse de toutes les lettres à l'intérieur des CLR et sortez la chaîne résultante.

Cas de test

La première ligne est entrée et la seconde est sortie. Les parties en gras de l'entrée sont des sous-chaînes qui sont considérées comme des 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

Règles

• Vous pouvez supposer que l'entrée ne contiendra jamais deux ou plusieurs espaces d'affilée et qu'elle ne contiendra jamais d'espace de début ou de fin.

• Bonus de 20% (multipliez la longueur de votre code par 0,8) si tout votre code est un CLR. ;) (surtout juste pour le plaisir, car il est peu probable que la soumission gagnante ait ce bonus)

• Il s'agit de code-golf , donc le code le plus court en octets l'emporte.

CJam, 100 86 83 81 octets

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

Essayez ce violon dans l'interpréteur CJam ou vérifiez tous les cas de test à la fois .

Algorithme

1. Identifiez le CLR le plus long possible qui commence par le premier caractère.

2. S'il existe, échangez son boîtier, imprimez-le et supprimez-le du début de la chaîne.

   Sinon, supprimez un seul caractère au début de la chaîne et imprimez-le tel quel.

3. S'il reste plus de caractères, revenez à l'étape 1.

Comment ça marche

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 octets

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

Réussit tous les tests. Suppose l'entrée de STDIN, imprime vers STDOUT.

Comment ça marche:

• configurer un regex ( $y) qui correspond

  • au moins deux caractères non minuscules et non blancs OU
  • une limite de mot, suivie d'un caractère non blanc, suivie d'un ou plusieurs caractères non minuscules, non blancs

• faire correspondre plusieurs instances de chaînes séparées par des espaces qui correspondent $y, utiliser s///pour inverser la casse

Je suis sûr qu'il y a place à amélioration. S'il existe un moyen de se débarrasser de toute l' join-map-splitaffaire, il peut toujours y avoir une chance de se qualifier pour le bonus :)

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>

Explication:

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