Mục tiêu là, đã lấy một chuỗi làm đầu vào, sao chép từng chữ cái Latinh và "chuyển đổi" trường hợp của nó (nghĩa là chữ hoa trở thành chữ thường và ngược lại).

Ví dụ đầu vào và đầu ra:

Input      Output
bad        bBaAdD
Nice       NniIcCeE
T e S t    Tt eE Ss tT
s E t      sS Ee tT
1!1!1st!   1!1!1sStT!
n00b       nN00bB     
(e.g.)     (eE.gG.)
H3l|@!     Hh3lL|@!

Đầu vào bao gồm các ký hiệu ASCII có thể in được.

Bạn không nên sao chép các chữ cái không phải là chữ Latinh, số, ký tự đặc biệt.

Thạch, 5 byte

żŒsQ€

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

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

żŒsQ€  Main link. Argument: s (string)

 Œs    Yield s with swapped case.
ż      Zip s with the result.
   Q€  Unique each; deduplicate each pair of characters.

Python, 56 54 byte

lambda s:''.join(c+c.swapcase()*c.isalpha()for c in s)

Kiểm tra nó trên Ideone .

JavaScript ES6, 70 68 66 64 byte

Đã lưu 2 byte nhờ @Kevin Lau - không phải Kenny

Đã lưu 2 byte nhờ @ Cᴏɴᴏʀ O'Bʀɪᴇɴ

s=>s.replace(/[A-Z]/gi,l=>l+l[`to${l<"a"?"Low":"Upp"}erCase`]())

Giải trình

Điều này sử dụng một hacky thực sự:

l[`to${l<"a"?"Low":"Upp"}erCase`]()

mà vô dụng là:

l[`to${
   l < "a" ?
   "Low" : 
   "Upp"
}erCase`]()

Về cơ bản l < "a"kiểm tra xem điểm mã của chữ cái có nhỏ hơn điểm mã của a(do đó là một chữ cái viết hoa). Nếu có, nó sẽ làm điều to + Low + erCaseđó l['toLowerCase']()và làm cho ký tự viết thường. `trích dẫn cho phép định dạng chuỗi để về cơ bản bạn có thể nghĩ về:

`to${l < "a" ?"Low" : "Upp"}erCase`

as: "to" + (l<"a" ? "Low" : "Upp") + "erCase"tạo ra hàm để gọi (tạo chuỗi chữ hoa hoặc chữ thường). Chúng tôi đặt cái này trong dấu ngoặc vuông [ ... ]cho phép chúng tôi truy cập vào một thuộc tính có tên là chuỗi. Điều này trả về chức năng thích hợp và sau đó chúng ta chỉ cần gọi nó.

Ruby, 37 33 (30 + -pcờ) byte

swapcaseđể giải cứu! Sắp xếp -4 byte từ @Lynn.

gsub(/[a-z]/i){$&+$&.swapcase}

C, 63 60 byte

f(char*s){for(;*s;s++)isalpha(putchar(*s))&&putchar(32^*s);}

Sử dụng thực tế rằng 'a' XOR 32 == 'A', vv

Ba byte được lưu nhờ FryAmTheEggman.

CJam, 11 byte

l_el_eu.+.|

Kiểm tra nó ở đây.

Giải trình

l      e# Read input.
_el    e# Duplicate, convert to lower case.
_eu    e# Duplicate, convert to upper case.
.+     e# Concatenate the two characters in matching positions from those two
       e# strings. E.g. "ab!" "AB!" would give ["aA" "bB" "!!"].
       e# For each character from the original string and the corresponding 
.|     e# string from this list, take the set union (which eliminates duplicates
       e# and keeps the order the values appear in from left to right, so that
       e# the original case of each letter comes first).

Bình thường , 7 byte

sm{+dr2

Bộ thử nghiệm .

sm{+dr2    input: Q
sm{+dr2dQ  implicit arguments

        Q  input
 m         for each character as d:
     r2d       swapcase
   +d          prepend d
  {            deduplicate
s          join as string

Python 3.5, 60 56 byte:

for i in input():print(end=i+i.swapcase()[:i.isalpha()])

Một chương trình đầy đủ. Sẽ cố gắng để chơi golf nhiều hơn.

Dùng thử trực tuyến! (Ý)

Haskell, 73 byte

l=['a'..'z']
u=['A'..]
(>>= \c->c:maybe""pure(lookup c$zip l u++zip u l))

Cheddar , 118 104 byte

(s)->s.chars.map((i)->{if String.letters has i.lower{if i<"a"{i+i.lower}else{i+i.upper}}else{i}}).join()

Câu trả lời thực sự đầu tiên của Cheddar !!! Đây là ít khí hậu hơn tôi nghĩ nó sẽ ...; _;

Hoạt động với phiên bản 1.0.0-beta.9 , không cạnh tranh.

Như bạn có thể nói tôi đã không thiết kế cheddar để chơi golf: /

Ung dung:

(str) -> str.chars.map(
    (i) -> {
        if String.letters has i {
            if i < "a" { // Check char code, meaning it's upper case if true
                i+i.lower
            }
            else {
                i+i.upper
            }
        } else {
            i
        }
    }
).join()

Sử dụng:

var doThing = <code here>;
doThing("input...");

Cập nhật: 14/07/16 Tôi đã hoàn thành các ternary làm cho điều này giảm xuống còn 84 byte

Cheddar, 84 byte

(s)->s.chars.map((i)->String.letters has i.lower?i<"a"?i+i.lower:i+i.upper:i).join()

hoạt động như phiên bản v1.0.0-beta.14

Võng mạc, 28 27 21 byte

Đó là các tab, không phải khoảng trắng.

.
$&  $&
T`lL    p`Ll_`  .

Dùng thử trực tuyến

Cảm ơn những lời đề nghị tất cả mọi người.

C, 87 80

Truyền một chuỗi làm đầu vào f()và đầu ra được ghi vào STDOUT. Chuỗi không được sửa đổi.

f(char*v){for(;*v;++v)putchar(*v),isalpha(*v)?putchar(*v-32+64*!islower(*v)):0;}

sed, 30 byte

Mã 29 byte + tham số 1 byte -r

s/([a-z])|([A-Z])/&\u\1\l\2/g

Sử dụng:

echo -e 'bad\nNice\nT e S t\ns E t\n1!1!1st!\nn00b\n(e.g.)\nH3l|@!' |\
sed -r 's/([a-z])|([A-Z])/&\u\1\l\2/g'

J, 31 29 byte

[:;]<@~."1@,.tolower,.toupper

Giải trình

[:;]<@~."1@,.tolower,.toupper  Input: s
                      toupper  Convert s to all uppercase
             tolower           Convert s to all lowercase
                    ,.         Join them as columns in a 2d array
   ]                           Identity function, get s
           ,.                  Prepend s as a column to the 2d array
      ~."1@                    Take the unique chars on each row
    <@                         Box them
[:;                            Unbox the list of boxes and join their contents and return

Haskell, 121, 101, 85, 82

import Data.Char
g n|isLower n=toUpper n|1<2=toLower n
(>>= \x->x:[g x|isAlpha x])

Perl, 36 byte ( -ncờ 35+)

s/[a-z]/$&.(ord$&<97?lc$&:uc$&)/ige

( -pcần thẻ)

(-2 byte nhờ vào @Dom Hasting)

Giải thích ngắn:
ordtrả về giá trị số của một char. ord(any lower case) >= 97, Và ord(any upper case) <= 90).

Chạy với:

perl -pe 's/[a-z]/$&.(ord$&<97?lc$&:uc$&)/ige'

Ruby, 31 + 1 = 32 30 + 1 = 31 byte

Với -pcờ, chạy

gsub(/(?<=(.))/){$1.swapcase!}

Tận dụng lợi thế của thực tế là swapcase!sẽ trả nilvề bất cứ thứ gì ngoại trừ một chữ cái ASCII, dịch thành một chuỗi trống khi được trả lại khỏi gsubkhối. @Jordan đã lưu một byte bằng cách chụp ký tự trước đó trong một cái nhìn phía sau.

R, 191 187 168 156 98 99 byte

99 byte do cải tiến qua Giuseppe và MickyT .

paste0(x<-unlist(strsplit(readline(),"")),gsub("[^A-Za-z]","",chartr("a-zA-Z","A-Za-z",x)),collapse="")

05AB1E , 7 byte

Mã số:

vyyš«Ù?

Giải trình:

v       # For each in input.
 yyš    # Push y and y swapcased.
    «Ù  # Concatentate and uniquify.
      ? # Print without a newline.

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

Pyke, 8 6 byte

FDl4+}

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

V , 21 byte

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

Quá nhiều byte ...

Ó./°ò
Íá/°°
Îlg~lÎHògJ

Trên thực tế, 8 byte

`;Öo╔`MΣ

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

Giải trình:

`;Öo╔`MΣ
`;Öo╔`M   for each character in input:
 ;          duplicate the character
  Ö         swap case
   o        append to original character
    ╔       remove duplicated characters
       Σ  concatenate

MATL, 11 9 byte

tYov"@uv!

Dùng thử trực tuyến

Giải trình

        % Implicitly grab input as string
t       % Duplicate the input
Yo      % Swap case of all characters
v       % Vertically concatenate the original and swap-cased versions
"       % For each column (letter in the original)
  @u    % Compute the unique values (without sorting)
  v!    % Vertically concatenate with the existing output and transpose
        % Implicit end of for loop and implicit display

Perl, 28 22 21 byte ( -pcờ 20+)

s/[a-z]/$&.$&^$"/ige

Stax , 7 6 byte

Cảm ơn @recursive cho một byte được lưu!

┤§ÆP♦■

Chạy và gỡ lỗi nó tại staxlang.xyz! (liên kết là phiên bản giải nén)

Giải nén (7 byte):

c:~\{um

Giải trình:

c:~\{um
c          Copy the top element of the stack (the input, in this case).
 :~        Switch case of each letter in the copy.
   \       Zip. This produces an array of two-character strings.
    { m    Map a block over this array of two-character strings.
     u       Get all unique elements.
           Implicit concatenate and print.

Python, 59 byte

lambda s:''.join((x,x+x.swapcase())[x.isalpha()]for x in s)

Đã chỉnh sửa để sửa các ký tự không phải là chữ cái

Julia, 40 byte

!s=[print(c,isalpha(c)?c$' ':"")for c=s]

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

PHP 4.1, 57 byte

Mã này giả định truy cập thông qua một máy chủ web (ví dụ Apache), sử dụng cấu hình mặc định.

Bạn có thể vượt qua chuỗi bằng cách gửi chìa khóa Sbằng bất kỳ phương tiện ( POST, GET, COOKIE, SESSION...).

<?for($i=0;$c=$S[$i++];)echo$c,ctype_alpha($c)?$c^' ':'';

C #, 82 71 byte

s=>string.Concat(s.Select(c=>c+(char.IsLetter(c)?(char)(c^32)+"":"")));

C # lambda nơi đầu vào và đầu ra là string. Hãy thử trực tuyến .

11 byte nhờ thủ thuật @Lynn.

Lisp thông thường (Lispworks), 262 byte

(defun f(s)(let((b""))(dotimes(i(length s))(if(lower-case-p(elt s i))(progn #1=(setf b(concatenate 'string b(string #2=(elt s i))))(setf b(concatenate 'string b(string(char-upcase #2#)))))(progn #1#(setf b(concatenate 'string b(string(char-downcase #2#)))))))b))

vô dụng:

(defun f (s)
  (let ((b ""))
    (dotimes (i (length s))
      (if (lower-case-p (elt s i))
          (progn
           #1=(setf b (concatenate 'string b (string #2=(elt s i))))
           (setf b (concatenate 'string b (string (char-upcase #2#)))))
        (progn
          #1#
          (setf b (concatenate 'string b (string (char-downcase #2#)))))))
    b))

Sử dụng:

CL-USER 1 > (f "abc")
"aAbBcC"

CL-USER 2 > (f "bad")
"bBaAdD"