Tháng Mười 22 LÀ CAPS QUỐC TẾ LOCK NGÀY ! KHÔNG THỂ NÀO, MỘT SỐ KHÔNG NHẬN ĐƯỢC NHỮNG CÂU HỎI THƯỜNG GẶP CAPS ALMIGHTY. HỌ NÓI NÓ BIẾT "OBNOXIOUS" HOẶC "THÍCH KHÔNG NÊN" HOẶC MỘT SỐ NONSENSE. ĐẶT HÀNG ĐỂ XÁC NHẬN CÁC NỀN TẢNG HOÀN TOÀN NÀY VÀ XÁC NHẬN, HÃY VIẾT CHO TÔI MỘT CHƯƠNG TRÌNH RÚT RA VĂN BẢN BÌNH THƯỜNG VÀO "CẢM XÚC" HOẶC "BẮT BUỘC" VĂN BẢN ĐỂ KIẾM ĐƯỢC.

Sự miêu tả

Cả đầu vào và đầu ra cho giải pháp của bạn đều sẽ là các chuỗi chỉ chứa các ký tự ASCII có thể in được.

Chuỗi đầu vào sẽ chứa 0 hoặc nhiều mũ khóa chạy . Một khóa mũ chạy (hoặc viết tắt là CLR) được định nghĩa như sau:

• CLR không được chứa các chữ cái thường ( a-z), ngoại trừ là ký tự đầu tiên của một từ .

  • Một từ , cho mục đích của thách thức này, là một chuỗi các khoảng không. Vì vậy, PPCG, correcthorsebatterystaple, và jkl#@_>00()@#__f-023\f[tất cả đều được coi là chữ s.

• CLR cũng phải chứa ít nhất một khoảng trắng; do đó, nó phải có ít nhất hai từ s.

• Mỗi từ s trong CLR phải chứa ít nhất hai chữ cái ( A-Za-z).

  • Lưu ý rằng điều này đề cập đến CLR được thực hiện bởi chính nó, không có bất kỳ ký tự xung quanh nào có thể không được bao gồm trong CLR. Ví dụ, là không một CLR vì chuỗi bởi chính nó có chữ s có ít hơn hai chữ cái.foO BarO B

CLR nên được phân tích cú pháp "tham lam", bạn nên luôn luôn tìm CLR dài nhất có thể.

Khi bạn đã xác định tất cả các CLR trong chuỗi đầu vào, hãy hoán đổi trường hợp của tất cả các chữ cái bên trong CLR và xuất chuỗi kết quả.

Các trường hợp thử nghiệm

Dòng đầu tiên là đầu vào và dòng thứ hai là đầu ra. Các phần được in đậm của đầu vào là các chuỗi con được coi là 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

Quy tắc

• Bạn có thể giả định rằng đầu vào sẽ không bao giờ chứa hai hoặc nhiều khoảng trắng trong một hàng và nó sẽ không bao giờ chứa một khoảng trắng ở đầu hoặc cuối.

• Phần thưởng 20% ​​(nhân độ dài mã của bạn với .8) nếu toàn bộ mã của bạn là CLR. ;) (chủ yếu chỉ để giải trí, vì không chắc rằng bài dự thi sẽ có phần thưởng này)

• Đây là mã golf , vì vậy mã ngắn nhất tính bằng byte sẽ thắng.

CJam, 100 86 83 81 byte

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

Hãy thử fiddle này trong trình thông dịch CJam hoặc xác minh tất cả các trường hợp thử nghiệm cùng một lúc .

Thuật toán

1. Xác định CLR dài nhất có thể bắt đầu bằng ký tự đầu tiên.

2. Nếu nó tồn tại, trao đổi trường hợp của nó, in nó và loại bỏ nó từ đầu chuỗi.

   Khác, loại bỏ một ký tự từ đầu chuỗi và in nó không thay đổi.

3. Nếu còn nhiều ký tự, quay lại bước 1.

Làm thế nào nó hoạt động

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 byte

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

Vượt qua tất cả các bài kiểm tra. Giả sử đầu vào từ STDIN, in ra STDOUT.

Làm thế nào nó hoạt động:

• thiết lập regex ( $y) phù hợp

  • ít nhất hai ký tự không chữ thường, không khoảng trắng HOẶC
  • một ranh giới từ, theo sau là một ký tự không phải khoảng trắng, theo sau là một hoặc nhiều ký tự không phải chữ thường, không khoảng trắng

• khớp nhiều trường hợp của các chuỗi được phân tách bằng dấu cách khớp nhau $y, sử dụng s///để đảo ngược trường hợp

Tôi chắc chắn có chỗ để cải thiện. Nếu có một cách để thoát khỏi toàn bộ join-map-splitthỏa thuận, vẫn có thể có cơ hội đủ điều kiện nhận thưởng :)

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>

Giải trình:

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