22. OKTOBER IST INTERNATIONALER CAPS LOCK DAY ! Leider erkennen einige nicht den Ruhm des allmächtigen Feststellers. SIE SAGEN, ES SEHT "OBNOXIOUS" ODER "LIKE SHOUTING" ODER EINIGE UNSINNES. BITTE SCHREIBEN SIE MIR EIN PROGRAMM, DAS NORMALEN TEXT IN "EMPFINDLICHEN" ODER "VERNÜNDLICHEN" TEXT UM DIE BESCHWERDEN DER MENSCHEN ABZUSCHALTEN.

Beschreibung

Die Eingabe und Ausgabe für Ihre Lösung sind Zeichenfolgen, die nur druckbare ASCII-Zeichen enthalten.

Die Eingabezeichenfolge enthält keine oder mehrere Feststelltasten . Ein Caps-Lock-Lauf (kurz CLR) ist wie folgt definiert:

• Die CLR darf keine Kleinbuchstaben ( a-z) enthalten, außer als erstes Zeichen eines Wortes .

  • Ein Wort im Sinne dieser Herausforderung ist eine Folge von Nicht-Leerzeichen. So PPCG, correcthorsebatterystapleund jkl#@_>00()@#__f-023\f[sind alle als Wort s.

• Die CLR muss außerdem mindestens ein Leerzeichen enthalten. daher müssen es mindestens zwei Wörter sein .

• Jedes der Wörter in der CLR muss mindestens zwei Buchstaben enthalten ( A-Za-z).

  • Beachten Sie, dass sich dies auf die CLR bezieht, die für sich genommen wurde, ohne umgebende Zeichen, die möglicherweise nicht in der CLR enthalten waren. Zum Beispiel ist nicht eine CLR , da die Zeichenfolge selbst hat Wort s mit weniger als zwei Buchstaben.foO BarO B

CLRs sollten "gierig" analysiert werden - das heißt, Sie sollten immer die längsten möglichen CLRs finden.

Wenn Sie alle CLRs in der Eingabezeichenfolge identifiziert haben, tauschen Sie die Groß- und Kleinschreibung aller Buchstaben in den CLRs aus und geben Sie die resultierende Zeichenfolge aus.

Testfälle

Die erste Zeile wird eingegeben und die zweite ausgegeben. Fettgedruckte Teile der Eingabe sind Teilzeichenfolgen, die als CLRs gelten.

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

Regeln

• Sie können davon ausgehen, dass die Eingabe niemals zwei oder mehr Leerzeichen in einer Zeile und niemals ein führendes oder nachfolgendes Leerzeichen enthält.

• 20% Bonus (multiplizieren Sie Ihre Codelänge mit 0,8), wenn Ihr gesamter Code eine CLR ist. ;) (meistens nur zum Spaß, da es unwahrscheinlich ist, dass die gewinnende Einreichung diesen Bonus hat)

• Das ist Code-Golf , also gewinnt der kürzeste Code in 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

Probieren Sie diese Geige im CJam-Interpreter aus oder überprüfen Sie alle Testfälle auf einmal .

Algorithmus

1. Identifizieren Sie die längste mögliche CLR, die mit dem ersten Zeichen beginnt.

2. Wenn es existiert, tauschen Sie die Schutzhülle aus, drucken Sie es aus und entfernen Sie es vom Anfang der Zeichenfolge.

   Entfernen Sie andernfalls ein einzelnes Zeichen vom Anfang der Zeichenfolge und drucken Sie es unverändert aus.

3. Wenn noch weitere Zeichen übrig sind, kehren Sie zu Schritt 1 zurück.

Wie es funktioniert

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'

Besteht alle Tests. Übernimmt Eingaben von STDIN, druckt auf STDOUT.

Wie es funktioniert:

• Richten Sie einen passenden regulären Ausdruck ( $y) ein

  • mindestens zwei Nicht-Kleinbuchstaben, Nicht-Leerzeichen ODER
  • eine Wortgrenze, gefolgt von einem Nicht-Leerzeichen, gefolgt von einem oder mehreren Nicht-Kleinbuchstaben, Nicht-Leerzeichen

• stimmen Sie mit mehreren Instanzen von durch Leerzeichen getrennten Zeichenfolgen überein $y, mit denen s///die Groß- / Kleinschreibung invertiert wird

Ich bin sicher, es gibt Raum für Verbesserungen. Wenn es eine Möglichkeit gibt, den gesamten join-map-splitDeal loszuwerden, besteht möglicherweise immer noch die Möglichkeit, sich für den Bonus zu qualifizieren :)

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>

Erläuterung:

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