Đối với thử thách ngày hôm nay, bạn phải viết một chương trình hoặc hàm xen kẽ trường hợp của một chuỗi. Tuy nhiên, bạn phải bỏ qua các ký tự không phải là chữ cái. Điều này có nghĩa là mỗi ký tự chữ cái phải có một trường hợp khác với ký tự chữ cái trước và sau. Điều này hơi phức tạp hơn so với việc viết hoa mỗi chữ cái khác chẳng hạn. Nếu bạn lấy một chuỗi như

hello world

và chuyển đổi mọi ký tự khác thành chữ hoa, bạn sẽ nhận được:

hElLo wOrLd

Như bạn có thể thấy, chữ thường ođược theo sau bởi chữ thường w. Điều này không hợp lệ. Thay vào đó, bạn phải bỏ qua không gian, cho chúng tôi kết quả này:

hElLo WoRlD

Tất cả các ký tự không phải là chữ cái phải được để nguyên. Đầu ra có thể bắt đầu bằng chữ hoa hoặc chữ thường, miễn là nó luôn thay thế. Điều này có nghĩa là sau đây cũng sẽ là một đầu ra chấp nhận được:

HeLlO wOrLd

Chương trình của bạn sẽ hoạt động bất kể trường hợp đầu vào.

Chuỗi đầu vào sẽ chỉ bao gồm ASCII có thể in được , vì vậy bạn không phải lo lắng về các ký tự không thể in, dòng mới hoặc unicode. Nội dung gửi của bạn có thể là một chương trình đầy đủ hoặc một chức năng và bạn có thể nhận đầu vào và đầu ra ở bất kỳ định dạng hợp lý nào. Ví dụ: đối số hàm / giá trị trả về, STDIN / STDOUT, đọc / ghi tệp, v.v.

Ví dụ:

ASCII                                   ->  AsCiI
42                                      ->  42
#include <iostream>                     ->  #InClUdE <iOsTrEaM>
LEAVE_my_symbols#!#&^%_ALONE!!!         ->  lEaVe_My_SyMbOlS#!#&^%_aLoNe!!!
PPCG Rocks!!! For realz.                ->  PpCg RoCkS!!! fOr ReAlZ.
This example will start with lowercase  ->  tHiS eXaMpLe WiLl StArT wItH lOwErCaSe
This example will start with uppercase  ->  ThIs ExAmPlE wIlL sTaRt WiTh UpPeRcAsE
A1B2                                    ->  A1b2

Vì đây là môn đánh gôn , nên các sơ hở tiêu chuẩn được áp dụng và câu trả lời ngắn nhất tính theo byte sẽ thắng!

JavaScript (ES6), 66 63 byte

Bắt đầu bằng chữ hoa.

s=>s.replace(/[a-z]/gi,c=>c[`to${(s=!s)?'Low':'Upp'}erCase`]())

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

let f =

s=>s.replace(/[a-z]/gi,c=>c[`to${(s=!s)?'Low':'Upp'}erCase`]())

console.log(f("ASCII"))
console.log(f("42"))
console.log(f("#include <iostream>"))
console.log(f("LEAVE_my_symbols#!#&^%_ALONE!!!"))
console.log(f("PPCG Rocks!!! For realz."))
console.log(f("This example will start with lowercase"))
console.log(f("This example will start with uppercase"))
console.log(f("A1B2"))

05AB1E , 11 8 byte

Mã số:

lvyJ¤aiš

Sử dụng mã hóa 05AB1E . Hãy thử trực tuyến!

Giải trình:

l           # Lowercase the input
 vy         # For each element..
   J        #   Join the entire stack into a single string
    ¤a      #   Check if the last character is alphabetic
      iš    #   If true, swapcase the entire string

GNU Sed, 33

• 5 byte được lưu nhờ @TobySpeight

Điểm bao gồm +1 cho -rcờ để sed.

s/([a-z])([^a-z]*.?)/\U\1\L\2/gi

Hãy thử trực tuyến .

Thạch , 13 byte

nŒsTm2
ŒlŒuǦ

Hãy thử trực tuyến!

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

ŒlŒsǦ  Main link. Argument: s (string)

Œl      Cast to lowercase.
    Ǧ  At indices returned by the helper link...
  Œu        apply uppercase.


nŒsTm2      Helper link. Argument: s (string)

 Œs         Apply swapcase to s.
n           Perform vectorizing not-equal comparison.
   T        Compute the truthy indices.
    m2      Select every other one, starting with the first.

Japt , 16 14 byte

r"%l"_m"uv"gT°

Hãy thử trực tuyến!

Giải trình

r              // RegEx replace input
 "%l"          // [A-Za-z] as first arg to replace
     _         // created function Z=>Z as second arg to replace
       "uv"gT° // alternates "u" & "v"
      m        // map Z to either "u" upper or "v" lower

Python 3 , 86 76 68 66 63 byte

^{-2 byte nhờ DJMcMayhem
-3 byte nhờ Cyoce}

x=0
for i in input():print(end=(2*i).title()[x]);x^=i.isalpha()

Hãy thử trực tuyến! hoặc Thử tất cả các trường hợp thử nghiệm

Alice , 18 byte

/olZlYuN
@iy.u..//

Hãy thử trực tuyến!

Giải trình

Chương trình này tuân theo một mẫu ít được biết đến hơn cho các chương trình có độ dài lẻ chạy hoàn toàn ở chế độ thứ tự. Phiên bản tuyến tính hóa của mã này là:

il.l.uN.YuZyo@

Giải thích về mã:

i - push input onto stack            ["Hello world!"]
l - convert to lowercase             ["hello world!"]
. - duplicate                        ["hello world!", "hello world!"]
l - convert to lowercase (should be no-op, but avoids what seems to be a bug in the TIO implementation)
. - duplicate again                  ["hello world!", "hello world!", "hello world!"]
u - convert to uppercase             ["hello world!", "hello world!", "HELLO WORLD!"]
N - difference between sets          ["hello world!", "helloworld"]
. - duplicate reduced string         ["hello world!", "helloworld", "helloworld"]
Y - unzip (extract even positions)   ["hello world!", "helloworld", "hlool", "elwrd"]
u - convert to uppercase             ["hello world!", "helloworld", "hlool", "ELWRD"]
Z - zip evens back into string       ["hello world!", "helloworld", "hElLoWoRlD"]
y - perform substitution             ["hElLo WoRlD!"]
o - output                           []
@ - terminate

Không sử dụng ltrên bản sao, ngăn xếp sau Nsẽ là ["helloworld", "helloworld"]. Tôi nghi ngờ đây là một lỗi.

C (tcc) , 60 57 56 byte

Cảm ơn DigitalTrauma vì đã nhận thấy bit 5 là sự khác biệt duy nhất cho chữ hoa / chữ thường của ASCII.

Đặc biệt cảm ơn zch vì đã chơi golf thêm ba byte.

Lưu thêm một byte từ ý tưởng của RJHunter

l;f(char*s){for(;*s=isalpha(*s)?*s&95|++l%2<<5:*s;s++);}

Hãy thử trực tuyến!

Java 8, 99 byte

a->{String r="";int i=0;for(int c:a)r+=(char)(c>64&c<91|c>96&c<123?i++%2<1?c|32:c&~32:c);return r;}

Giải trình:

Hãy thử nó ở đây.

a->{                          // Lambda with char-array parameter and String return-type
  String r="";                //  Result-String
  int i=0;                    //  Flag for alteration
  for(int c:a)                //  Loop over the characters of the input
    r+=(char)                 //   And append the result-String with the following (converted to char):
      (c>64&c<91|c>96&c<123?  //    If it's a letter:
       i++%2<1?               //     And the flag states it should be lowercase:
        (c|32)                //      Convert it to lowercase
       :                      //     Else (should be uppercase):
        (c&~32)               //      Convert it to uppercase
      :                       //    Else:
       c);                    //     Simply append the non-letter character as is
                              //  End of loop (implicit / single-line body)
  return r;                   //  Return result-String
}                             // End of method

Ruby, 57 55 47 41 byte

Số byte bao gồm hai byte cho các tùy chọn dòng lệnh.
Chạy nó ví dụ như thế này:$ ruby -p0 alternate_case.rb <<< "some input"

gsub(/\p{L}/){($&.ord&95|32*$.^=1).chr}

Với p0tùy chọn, toàn bộ đầu vào được tiêu thụ trong một lần và toàn cầu ma thuật $.được tăng lên 1. Điều này sau đó được chuyển từ 0 đến 1 và được sử dụng để giữ trạng thái.

Hoạt động với đầu vào đa dòng; Hãy thử trực tuyến!

Cảm ơn Ventero cho đầu vào tuyệt vời - kiểm tra các ý kiến ​​để biết chi tiết.

Brachylog , 25 byte

{ḷ|ụ}ᵐ.{ḷ∈Ạ&}ˢ¬{s₂{∈Ạ}ᵐ}∧

Hãy thử trực tuyến!

Điều này là cả dài và chậm.

Giải trình

{   }ᵐ.                       The Output is the result of mapping on each char of the Input:
 ḷ                              Lowecase the char
  |                             Or
   ụ                            Uppercase the char
       {    }ˢ                In the Ouput, select the chars that:
        ḷ∈Ạ&                    when lowercased are in "abc...xyz" (ie are letters)
              ¬{       }∧     In that new string, it is impossible to find:
                s₂              a substring of 2 consecutive chars
                  {∈Ạ}ᵐ         where both of them are in the lowercase alphabet

MATL , 16 15 byte

Xktkyy-f2L))5M(

Hãy thử trực tuyến! Hoặc xác minh tất cả các trường hợp thử nghiệm .

Giải trình

Xem xét đầu vào 'xin chào thế giới'

Xk    % To upper case
      % STACK: 'HELLO WORLD'
t     % Duplicate top element
      % STACK: 'HELLO WORLD', 'HELLO WORLD'
k     % To lower case
      % STACK: 'HELLO WORLD', 'hello word'
yy    % Duplicate top two elements
      % STACK: 'HELLO WORLD', 'hello word', 'HELLO WORLD', 'hello word'
-     % Difference (of code points; element-wise)
      % STACK: 'HELLO WORLD', 'hello word', [-32 -32 -32 -32 -32 0 -32 -32 -32 -32 -32]
f     % Indices of nonzeros
      % STACK: 'HELLO WORLD', 'hello word', [1 2 3 4 5 7 8 9 10 11]
2L)   % Keep only even-indexed values (*)
      % STACK: 'HELLO WORLD', 'hello word', [2 4 7 9 11]
)     % Reference indexing (get values at indices)
      % STACK: 'HELLO WORLD', 'elwrd'
5M    % Push (*) again
      % STACK: 'HELLO WORLD', 'elwrd', [2 4 7 9 11]
(     % Assignment indexing (write values at indices). Implicit display
      % STACK: 'HeLlO wOrLd

'

Perl 6 ,  32  30 byte

{S:g/<:L><-:L>*<:L>?/$/.tclc()/}

Thử nó

{S:g{<:L><-:L>*<:L>?}=$/.tclc}

Thử nó

Mở rộng:

{  # bare block lambda with implicit parameter ｢$_｣

  S            # string replace (not in-place) implicitly against ｢$_｣

  :global

  {

    <+ :L >    # a letter
    <- :L >*   # any number of non-letters
    <+ :L >?   # an optional letter

  }

  =

  $/.tclc()    # uppercase the first letter, lowercase everything else
}

q / kdb +, 51 42 38 byte

Giải pháp:

{@[x;;upper]1#'2 cut(&)x in .Q.a}lower

Thí dụ:

q){@[x;;upper]1#'2 cut(&)x in .Q.a}lower"hello world"
"HeLlO wOrLd"

Ghi chú:

.Q.a        // abcde...xyz lowercase alphabet
(&) x in    // where, returns indices for where x (hello world) is an alpha
2 cut       // splits list into 2-item lists
1#'         // takes first item of each 2-item list; ie the indices to uppercase
@[x;;upper] // apply (@) upper to x at these indices

V , 17 , 13 byte

VUÍშáü$©/ì&

Hãy thử trực tuyến!

Hoặc Xác minh tất cả các trường hợp thử nghiệm!

HeXdUmP:

00000000: 5655 cde1 83a8 e1fc 24a9 2fec 26         VU......$./.&

Giải trình:

Cái này sử dụng regex ™ đã nén, vì vậy trước khi giải thích nó, hãy mở rộng regex ra:

:%s/\v\a.{-}(\a|$)/\l&

Việc VUchuyển đổi mọi thứ thành chữ hoa. Sau đó, chúng tôi chạy này:

:%                      " On every line:
  s/\v                  "   Substitute:
      \a                "     A letter
        .{-}            "     Followed by as few characters as possible
            (\a|$)      "     Followed by either another letter or an EOL
                  /     "   With:
                   \l   "     The next character is lowercased
                     &  "     The whole text we matched

Câu trả lời cũ / thú vị hơn:

:se nows
Vuò~h2/á

PHP, 71 byte

for(;a&$c=$argn[$i++];)echo ctype_alpha($c)?(ul[$k++&1].cfirst)($c):$c;

Hãy thử trực tuyến!

CJam , 26 24 byte

qeu{_'[,65>&,T^:T{el}&}%

Hãy thử trực tuyến!

Giải trình

q         e# Read all input.
eu        e# Uppercase it.
{         e# For each character:
 _        e#  Duplicate it.
 '[,65>&  e#  Set intersection with the uppercase alphabet.
 ,        e#  Length (either 0 or 1 in this case).
 T^:T     e#  XOR with T (T is initially 0), then store the result back in T.
 {el}&    e#  If The result of the XOR is true, lowercase the character.
}%        e# (end for)

Bình thường, 11 byte

srR~xZ}dGrZ

Hãy thử nó ở đây

Giải trình

              # Z = 0; Q = eval(input())
srR~xZ}dGrZQ  # Auto-fill variables
         rZQ  # lowercase the input
 rR           # Apply the r function to each letter of the input with
   ~xZ}dG     # ... this as the other argument
   ~          # use the old value of the variable Z, then update it with the value of ...
    xZ        # Z xor ...
      }dG     # the variable d is a lowercase letter
              # because of how mapping works in pyth, d will contain the current letter
              # This causes Z to flip between 0 and 1, alternately upper and lower casing
              # the current character if it is a letter

PowerShell, 86 byte

-join($args[0]|%{if($_-match"[a-z]"-and($i=!$i)){"$_".toupper()}else{"$_".tolower()}})

Đầu vào là một [char[]]mảng.

Nhận xét trong mã để giải thích

# Join the array of string and char back together.
-join
    # Take the first argument and pass each element ([char]) down the pipe. 
    ($args[0]|%{
        # Check if this is a letter. Second condition is a boolean that changes at every pass 
        # but only if the current element is a letter. If not the condition never fires
        if($_-match"[a-z]"-and($i=!$i)){
            # Change the character to uppercase
            "$_".toupper()
        }else{
            # Output the character to lowercase. 
            # Special characters are not affected by this method
            "$_".tolower()
        }
    })

Haskell, 105 83 + 2 4 + 1 byte dải phân cách = 108 86 88 byte

import Data.Char
f#(x:y)|isLetter x=([toUpper,toLower]!!f)x:(1-f)#y|1>0=x:f#y
_#l=l

Chức năng là (1#), bắt đầu chữ thường. Hãy thử trực tuyến!

Điều đáng buồn là nó dài hơn câu trả lời của Java và C # Cảm ơn Ørjan Johansen vì đã lưu 22 byte bằng cách hợp nhất ba dòng thành một!

Google Sheets, 264 byte

=ArrayFormula(JOIN("",IF(REGEXMATCH(MID(A1,ROW(OFFSET(A1,0,0,LEN(A1))),1),"[A-Za-z]"),CHAR(CODE(UPPER(MID(A1,ROW(OFFSET(A1,0,0,LEN(A1))),1)))+MOD(LEN(REGEXREPLACE(LEFT(A1,ROW(OFFSET(A1,0,0,LEN(A1)))),"[^A-Za-z]","")),2)*32),MID(A1,ROW(OFFSET(A1,0,0,LEN(A1))),1))))

Đó là một mớ hỗn độn lớn nhưng sẽ dễ dàng hơn một chút nếu bạn mở rộng nó ra:

=ArrayFormula(
  JOIN(
    "",
    IF(REGEXMATCH(MID(A1,ROW(OFFSET(A1,0,0,LEN(A1))),1),"[A-Za-z]"),
      CHAR(
        CODE(UPPER(MID(A1,ROW(OFFSET(A1,0,0,LEN(A1))),1)))
        +
        MOD(LEN(REGEXREPLACE(LEFT(A1,ROW(OFFSET(A1,0,0,LEN(A1)))),"[^A-Za-z]","")),2)*32
      ),
      MID(A1,ROW(OFFSET(A1,0,0,LEN(A1))),1)
    )
  )
) 

Logic giả sẽ chạy như thế này:

For each character {                                    // ArrayFormula()
  If (character is a letter) {                          // REGEXMATCH(MID())
    Return CHAR(                                        // CHAR()
      CODE(UPPER(letter))                               // CODE(UPPER(MID()))
      +
      If (nth letter found and n is odd) {32} else {0}  // MOD(LEN(REGEXREPLACE(LEFT())))
    )
  } else {
    Return character                                    // MID()
  }
}

Perl 5 , 24 byte

23 byte + 1 byte cho -p.

Cảm ơn @Dada cho -2 byte.

s/\pl/--$|?uc$&:lc$&/eg

Hãy thử trực tuyến!

Võng mạc , 46 byte

T`L`l
T`l`L`.(?=([^a-z]*|[a-z][^a-z]*[a-z])*$)

Hãy thử trực tuyến! Bao gồm các trường hợp thử nghiệm.

C 64 byte

B;R(char *s){for(;*s=isalpha(*s)?(B=!B)?*s|=32:*s&=~32:*s;s++);}

Tận dụng lợi thế của mã hóa ascii trong đó chữ in hoa và chữ thường được bù bằng 0x20.

Võng mạc , 32 byte

T`l`L
01T`L`l`[A-Z][^A-Z]*[A-Z]?

Hãy thử trực tuyến!

Đầu tiên chuyển đổi đầu vào thành chữ hoa, sau đó nhóm đầu vào thành các kết quả chứa tối đa hai chữ in hoa. Lần duy nhất nó sẽ chỉ chứa một chữ cái là nếu chữ cái cuối cùng không có cặp. Sau đó, nó viết thường chữ cái đầu tiên của mỗi trận đấu.

Các 01trong giai đoạn thứ hai chuyển khoảng để: không thay đổi hành vi của giai đoạn này dựa trên số trận đấu, nhưng chỉ áp dụng các thay đổi đối với ký tự đầu tiên của mỗi trận đấu.

PHP 5, 54 byte

<?=preg_filter('/\pL/e','($0|" ")^a^aA[$i^=1]',$argn);

C #, 100 byte

s=>{var r="";int m=0;foreach(var c in s)r+=char.IsLetter(c)?(char)(++m%2>0?c|32:c&~32):c;return r;};

Groovy, 79 byte

{x=0;it.toUpperCase().collect{(it==~/\w/)?x++%2?it:it.toLowerCase():it}.join()}

Python 3 , 192 byte

x=list(input())
s=[]
for i in x[1::2]:
 s.append(i)
 x.remove(i)
s.reverse()
while len(x)<len(s):
 x.append("")
while len(x)>len(s):
 s.append("")
for i in range(len(x)):
 print(end=x[i]+s[i])

Hãy thử trực tuyến!

Lồi , 16 byte

¯{_U&,R^:R{¬}&}%

Hãy thử trực tuyến!

Cổng lồi của câu trả lời của @Business Cat .