your shift key is broken. wheNever you type two lines, the cApitaL
LetteRs in them get swappeD. you must write a program to fiX THIS!

Sự miêu tả

Đầu vào là hai chuỗi s1và có s2độ dài bằng nhau. Mỗi cái sẽ chỉ chứa ASCII có thể in và có ít nhất một ký tự. Bạn có thể nhập hai chuỗi này dưới dạng hai chuỗi, một chuỗi gồm hai chuỗi hoặc một chuỗi đơn s1và được s2phân tách bằng một tab hoặc dòng mới.

Đầu ra như sau:

• Đối với mỗi nhân vật ctrong s1:

  • Nếu ký tự không phải là một chữ cái, xuất nó không thay đổi.

  • Mặt khác, nếu clà một chữ cái:

    • Tìm ký tự trùng khớp (ký tự có cùng chỉ mục) trong s2.

      • Nếu nó là một chữ cái cviết hoa , đầu ra viết hoa.

      • Nếu nó là một chữ cái viết thường, đầu ra cbằng chữ thường.

      • Nếu không, đầu ra ckhông thay đổi.

• Sau đó làm điều tương tự, ngoại trừ với s1và s2chuyển đổi.

Về cơ bản, tất cả các chữ cái trong s1đó ký tự trùng khớp s2là chữ hoa nên được viết hoa và tất cả các chữ cái s1có chữ thường ở cùng một chỉ mục s2sẽ trở thành chữ thường (và ngược lại).

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

Đầu vào:

ABCDEfghijKlMnOpqrstuvwxyz
aaaaaaaaaaaaaaaa----------

Đầu ra:

abcdefghijklmnopqrstuvwxyz
AAAAAaaaaaAaAaAa----------

Đầu vào:

PRogrammiNG puzZLes & CODe golf
SdlkhkfaladlKsdlalksdg7ldklDgsl

Đầu ra:

Programming Puzzles & Code Golf
SDlkhkfalADlksdLAlksdg7LDkldgsl

Đầu vào:

AAAbbb111
Cc2Dd3Ee4

Đầu ra:

AaABbb111
CC2dd3Ee4

Pyth, 19 18 byte

LCmrW&@dG@drG1d2Cb

Điều này xác định một hàm y chấp nhận và trả về một danh sách các chuỗi.

Xác minh tất cả các trường hợp thử nghiệm cùng một lúc trong Trình biên dịch / thực thi Pyth .

Cảm ơn @Jakube đã chơi golf 1 byte.

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

                   " (implicit) Initialize G to 'abcdefghijklmnopqrstuvwxyz'.

L                  " Define y(b):
                Cb "   Zip to turn the two strings into an array of char pairs.
  m                "   Map (implicit variable d):
      @dG          "     Intersect d with G.
         @drG1     "     Intersect d with G.upper().
    W&             "     If both are non-empty:
   r          d2   "       Apply swapcase() to d.
 C                 "   Zip to turn the character pairs back into two strings.

CJam, 25 byte

{z{_el_eu&\__:^32&f^?}%z}

Đây là một hàm ẩn danh bật ra một chuỗi các chuỗi từ ngăn xếp và trả lại một chuỗi.

Trong các trình duyệt được hỗ trợ, bạn có thể xác minh tất cả các trường hợp kiểm tra cùng một lúc trong trình thông dịch CJam .

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

Mã

qN/2/                     e# Read input and split into arrays of two strings.

{z{_el_eu&\__:^32&f^?}%z}

%                         e# Map the block over all string arrays.
:+N*                      e# Separate the strings by linefeeds.

Đầu vào

ABCDEfghijKlMnOpqrstuvwxyz
aaaaaaaaaaaaaaaa----------
PRogrammiNG puzZLes & CODe golf
SdlkhkfaladlKsdlalksdg7ldklDgsl
AAAbbb111
Cc2Dd3Ee4

Đầu ra

abcdefghijklmnopqrstuvwxyz
AAAAAaaaaaAaAaAa----------
Programming Puzzles & Code Golf
SDlkhkfalADlksdLAlksdg7LDkldgsl
AaABbb111
CC2dd3Ee4

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

z                       e# Zip to transform the array of strings into an array
                        e# of character pairs.
 {                  }%  e# For each character pair:
  _el                   e#   Push a copy and convert to lowercase.
     _eu                e#   Push a copy and convert to uppercase.
        &               e#   Intersect. The result will be an empty string if
                        e#   and only if both characters are letters.
         \              e#   Swap the character pair on top of the stack.
          __            e#   Push two copies.
            :^          e#   XOR both characters.
              32&       e#   Logical AND with 32. This pushes 32 for letters of
                        e#   different cases and 0 for letters of the same case.
                 f^     e#   XOR each character with the result.
                   ?    e#   Select the original copy for non-empty intersection
                        e#   and the modified one otherwise.
                      z e# Zip to turn the characters pairs back into two strings.

C, 126 byte

Đây là nỗ lực đầu tiên của tôi tại một sân golf mã, bao giờ hết. Hãy cho tôi biết nếu tôi làm bất cứ điều gì sai.

Tôi đang sử dụng các thao tác bitwise để thực hiện chuyển đổi

Chơi gôn

main(u,a,s,t)char**a,*s,*t;{for(s=a[1],t=a[2];*t;s++,t++)isalpha(*s)*isalpha(*t)?u=(*t^*s)&32,*t^=u,*s^=u:0;*s=10;puts(a[1]);}

Ung dung:

main(u,a,s,t) char**a,*s,*t; {       // K&R style arguments
    for(s=a[1],t=a[2];*t;s++,t++)    // initialize loop.
        isalpha(*s) * isalpha(*t) ? // ensure both characters are letters (if)
            u = (*t^*s) & 0x20,      // check if characters have swapped case
            *t^=u,                   // if so, xor the bit which represents case
            *s^=u                    // for both characters in the string.
        :0;                          // end ternary statement (endif)
    *s=10;                           // replace null terminator in first string 
    puts(a[1]);                      // with newline. This allows both output to 
}                                    // be printed out all at once

chỉnh sửa: thay thế && bằng *

SQL (PostGreSQL), 427 byte

Mặc dù có kích thước khổng lồ, nhưng điều này cuối cùng lại nhỏ hơn một chút so với tôi dự đoán. Tôi đã không chắc chắn rằng tôi sẽ có thể làm điều đó thành thật. Tôi nghi ngờ có rất nhiều điều vẫn có thể được thực hiện :)

CREATE FUNCTION F(TEXT,TEXT)RETURNS TABLE(S TEXT) AS'SELECT unnest(array[string_agg(CASE WHEN T~''[A-Z]''THEN upper(S)WHEN T~''[a-z]''THEN lower(S)ELSE S END,''''),string_agg(CASE WHEN S~''[A-Z]''THEN upper(T)WHEN S~''[a-z]''THEN lower(T)ELSE T END,'''')])FROM(SELECT ROW_NUMBER()OVER()N,S FROM regexp_split_to_table($1,'''')X(S))A JOIN(SELECT ROW_NUMBER()OVER()M,T FROM regexp_split_to_table($2,'''')Y(T))B ON N=M'LANGUAGE SQL

Định dạng và nhận xét

-- Declare the function spec
CREATE FUNCTION F(TEXT,TEXT)RETURNS TABLE(S TEXT) AS  
'SELECT unnest(   -- turns array into a table
    array[        -- build array of the column results
    string_agg( -- Aggregate the result into a string
        CASE 
        WHEN T~''[A-Z]''THEN upper(S) -- uppercase it if corresponding char is uppercase
        WHEN T~''[a-z]''THEN lower(S) -- lowercase it if corresponding char is lowercase
        ELSE S END
        ,''''),
    string_agg( -- Same as the previous but swap strings
        CASE 
        WHEN S~''[A-Z]''THEN upper(T)
        WHEN S~''[a-z]''THEN lower(T)
        ELSE T END
        ,'''')
    ])
FROM
    -- split the first string
   (SELECT ROW_NUMBER()OVER()N,S FROM regexp_split_to_table($1,'''')X(S))A
    JOIN
    -- split the second string
   (SELECT ROW_NUMBER()OVER()M,T FROM regexp_split_to_table($2,'''')Y(T))B 
   ON N=M
'
LANGUAGE SQL

Chạy thử nghiệm

SELECT F(A,B) AS Result
FROM (VALUES 
    ('AAAbbb111', 'Cc2Dd3Ee4'), 
    ('ABCDEfghijKlMnOpqrstuvwxyz', 'aaaaaaaaaaaaaaaa----------'), 
    ('PRogrammiNG puzZLes & CODe golf', 'SdlkhkfaladlKsdlalksdg7ldklDgsl')
    )A(A,B)

Result
-----------------------------
AaABbb111
CC2dd3Ee4
abcdefghijklmnopqrstuvwxyz
AAAAAaaaaaAaAaAa----------
Programming Puzzles & Code Golf
SDlkhkfalADlksdLAlksdg7LDkldgsl

Julia, 140 byte

f(s,t)=(C(x,y)=(i=0;z="";for c=x i+=1;z*=string(isalpha(c)?isupper(y[i])?uppercase(c):islower(t[i])?lowercase(c):c:c)end;z);(C(s,t),C(t,s)))

Điều này tạo ra một hàm chấp nhận hai chuỗi và trả về một chuỗi các chuỗi. Không có gì đặc biệt thông minh đang diễn ra ở đây; chúng ta chỉ cần định nghĩa một hàm bên trong trực tiếp thực hiện thuật toán trong thông số kỹ thuật và gọi nó hai lần.

Ung dung:

function f(s, t)
    C(x, y) = begin
        i = 0
        z = ""
        for c in x
            i += 1
            if isalpha(c)
                if isupper(y[i])
                    z *= string(uppercase(c))
                elseif islower(y[i])
                    z *= string(lowercase(c))
                else
                    z *= string(c)
                end
            else
                z *= string(c)
            end
        end
        return z
    end

    return (C(s, t), C(t, s))
end

JavaScript ES6, 128 108 byte

s=(a,b,t)=>[...a].map((l,i)=>/[^a-z]/.exec(b[i])?l.toUpperCase():l.toLowerCase()).join``+(t?'':`
`+s(b,a,1))

JavaScript toUpperCase()và toLowerCase()chiếm rất nhiều byte nhưng String.fromCharCode()thậm chí còn dài hơn

Toán học, 173 169 155 byte

f=0>1;t=!f;c=Characters;u=ToUpperCase;StringJoin/@MapThread[#@#2&,{Reverse[{LetterQ@#,#==(u@#)}&/@c@#/.{{f,_}->(#&),{t,t}->u,{t,f}->ToLowerCase}&/@#],c/@#},2]&

Đây là một hàm lấy một mảng gồm hai chuỗi, ví dụ {"Foo","bAR"}và xuất ra một mảng gồm hai chuỗi. Un-không gian-nén nó, viết lại chương trình f@xnhư f[x]bất cứ nơi nào nó xuất hiện, mở rộng các chữ viết tắt ký hiệu ( f=0>1aka False, t=!faka True, c=Charactersvà u=ToUpperCaseQ), và bỏ thay thế UpperCaseQ [#] với #==u@#(nhân vật này tương đương với phiên bản uppercased của nó), đó là:

StringJoin /@ MapThread[#[#2] &, {
    Reverse[
        { LetterQ[#], UpperCaseQ[#] } & /@ Characters[#] /. 
        { {False, _} -> (# &), {True, True} -> ToUpperCase, 
          {True, False} -> ToLowerCase } & /@ #
    ],
    Characters /@ #
}, 2] &

Giao diện: dấu vết &làm cho điều này một chức năng. Đối số của nó được chèn là "#" trong cả hai trường hợp /@ #. Ví dụ f=0>1; ... & [{"AAAbbb111", "Cc2Dd3Ee4"}]sản xuất đầu ra {AaABbb111,CC2dd3Ee4}.

Xử lý: Đã nói ở bên ngoài thông thường theo thứ tự:

• Đầu ra của MapThread[...]một danh sách gồm hai danh sách các ký tự. StringJoin được áp dụng cho mỗi danh sách hai ký tự này để tạo ra một danh sách gồm hai chuỗi, đầu ra.
• MapThread[#[#2]&, ... , 2]hành động trên một mảng gồm hai danh sách phần tử 2 nhân. Danh sách đầu tiên là một mảng các hàm 2 nhân. Danh sách thứ hai là một mảng các ký tự 2 nhân, Characters /@ #danh sách các ký tự trong hai chuỗi đầu vào. Nó hoạt động ở độ sâu 2, tức là trên các chức năng và các ký tự riêng lẻ.
• Reverse[...] hoán đổi hai danh sách con của các hàm để MapThread sẽ áp dụng các hàm của chuỗi thứ hai cho chuỗi thứ nhất và ngược lại.
• { ... } & là một hàm ẩn danh được áp dụng cho mỗi trong hai chuỗi đầu vào.
• {LetterQ[#], UpperCaseQ[#]} & /@ Characters[#]chia một chuỗi thành một danh sách các ký tự, sau đó thay thế mỗi ký tự bằng hai danh sách thành phần. Trong hai danh sách thành phần này, phần tử đầu tiên là Truenếu ký tự là một chữ cái và mặt Falsekhác, tương tự, phần tử thứ hai cho biết ký tự có phải là chữ hoa hay không. UpperCaseQ[]không thể trả lại đúng nếu nó không nhận được thư.
• /. {{False, _} -> (# &), {True, True} -> ToUpperCase, {True, False} -> ToLowerCase}thay thế hai danh sách thành phần này bằng các hàm. (Mở rộng các chữ viết tắt tvà fxảy ra trước khi bất kỳ kết hợp nào được thử.) Nếu danh sách hai phần tử có Falsethành phần tử đầu tiên, nó được thay thế bằng hàm (# &), hàm nhận dạng. (Các dấu ngoặc đơn là cần thiết, nếu không, mũi tên liên kết chặt chẽ hơn dấu và.) Nếu không, danh sách hai phần tử bắt đầu bằng True, ký tự là một chữ cái và chúng ta xuất các hàm ToUpperCasevà ToLowerCasetương ứng với trường hợp của nó. (Việc kiểm tra lần cuối Falsenày là không cần thiết, trên thực tế {_,_}->ToLowerCasesẽ có hiệu quả, nắm bắt mọi thứ chưa được thay thế, nhưng điều này sẽ không ngắn hơn và tối nghĩa hơn.)

Thử thách duy nhất là tìm ra một cách cô đọng để nén một mảng hàm hai chiều thành một mảng các đối số.

Edit: Nhờ @ Martin Büttner cho việc đánh bắt "hữu ích" cắt / dán backslashes linebreak, các 1>0và 1<0chữ viết tắt, và cũng có thể cho hướng dẫn để đếm chiều dài tính bằng byte không ký tự (bất kể đó là những :-))

Edit2: Xin chân thành cảm ơn @Martin Büttner đã chỉ ra rằng việc gây ô nhiễm không gian tên toàn cầu là golf có thể chấp nhận được, nhắc nhở tôi về một ứng dụng chức năng ký tự và đề nghị thay thế hai chức năng viết hoa bằng một chữ viết tắt cho một cái và sử dụng cái này để mô phỏng cái kia (tiết kiệm bốn nhân vật). (Tôi nghĩ rằng anh ấy đã làm điều này trước đây :-))

Python 3, 131 byte

def j(s,g):p=lambda s,g:''.join(i.upper()if j.istitle()else i.lower()if j.islower()else i for i,j in zip(s,g));return p(s,g),p(g,s)

Hàm trả về các chuỗi trong một tuple

Erlang, 157 byte

f(A,B)->S=string,G=fun(A,B)->[if Q>64andalso Q<91->S:to_upper(P);Q>96andalso Q<123->S:to_lower(P);true->P end||{P,Q}<-lists:zip(A,B)]end,G(A,B)++"\n"++G(B,A).

Kéo hai chuỗi (thực tế là các danh sách) vào một danh sách gồm hai ký tự và ánh xạ từng ký tự vào trường hợp thích hợp bằng cách sử dụng một danh sách hiểu.

Python 2, 101 byte

lambda*I:["".join([a.upper(),a.lower(),a][~-b.isalpha()or"Z"<b]for a,b in zip(*X))for X in I,I[::-1]]

Một hàm ẩn danh có hai chuỗi và trả về các chuỗi đầu ra trong một danh sách. Tôi đã đánh dấu đây là Python 2 vì Python 3 không cho phép I,I[::-1]ngồi một mình ở cuối như thế.

Python, 126 byte

t="".join;s="low","upp";y=lambda a,b:eval("a"+".%ser()"%s[b.isupper()]*b.isalpha());f=lambda a,b:(t(map(y,a,b)),t(map(y,b,a)))

Hàm ftrả về các chuỗi trong một tuple

C, 181 byte

char*x,*y;main(int a,char**_){a?x=_[2],y=_[1],main(0,0),putchar(10),x=_[1],y=_[2],main(0,0):(*x?putchar(!isupper(*x)?!islower(*x)?*y:tolower(*y):toupper(*y)),x++,y++,main(0,0):0);}

Đã gặp sự cố khi rút ngắn tên thư viện tiêu chuẩn theo cách đáng giá, (# xác định chúng có 11 ký tự trên cao). Sử dụng đệ quy chính và các biến toàn cục x và y làm đối số.

main (<non-zero>, argv) = gọi main (0, {argv [1], argv [2]}) sau đó in dòng mới sau đó gọi main (0, {argv [2], argv [1]})

main (0, {x, y}) = if x là kết thúc chuỗi trả về 0, nếu không thì in trường hợp đúng của ký tự đầu tiên của x và gọi main (0, {x + 1, y + 1}).

Chạy với hai chuỗi làm đối số.

C - 164 153 byte - GCC

#define r z[_][w]
main(_,z,w)char**z;{while(--_)for(w=0;r;r+=r<25?97:r<91&&r>64?z[!(_-1)+1][w]-=32,_-1?z[_-1][w]-=97:0,32:0,w++);puts(z[1]),puts(z[2]);}

prog.c

./a.out AfdgF a2dfsd

Sẽ cập nhật nếu tôi có thể tải wc -c xuống. Hoạt động rất tốt

F #, 211 ký tự

let n x y=List.fold2(fun a i j->a@match j with|c when c>='A'&&c<='Z'->[Char.ToUpper i]|c when c>='a'&&c<='z'->[Char.ToLower i]|_->[i])[](x|>Seq.toList)(y|>Seq.toList)|>String.Concat
let m a b =n a b+"\n"+n b a

có thể tốt hơn ...

Matlab, 140

function [s,t]=f(s,t)
c=s>96&s<123;C=s>64&s<91;d=t>96&t<123;D=t>64&t<91;s(c&D)=s(c&D)-32;s(C&d)=s(C&d)+32;t(d&C)=t(d&C)-32;t(D&c)=t(D&c)+32;

Ung dung:

function [s,t] = f(s,t)
c = s>96 & s<123;         % letters that are lowercase in 1st string
C = s>64 & s<91;          % letters that are uppercase in 1st string
d = t>96 & t<123;         % letters that are lowercase in 2nd string
D = t>64 & t<91;          % letters that are uppercase in 2nd string
s(c&D) = s(c&D) - 32;     % make uppercase in 1st string
s(C&d) = s(C&d) + 32;     % make lowercase in 1st string
t(d&C) = t(d&C) - 32;     % make uppercase in 2nd string
t(D&c) = t(D&c) + 32;     % make lowercase in 2nd string

Thí dụ:

>> [s,t]=f('PRogrammiNG puzZLes & CODe golf','SdlkhkfaladlKsdlalksdg7ldklDgsl')
s =
Programming Puzzles & Code Golf
t =
SDlkhkfalADlksdLAlksdg7LDkldgsl

C, 164 byte

Khá nhiều thực hiện các thuật toán như được mô tả trong vấn đề. Lấy 2 chuỗi làm tham số đầu vào.

char*a,*b;main(c,v)char**v;{for(a=v[1],b=v[2];*a&&*b;++a,++b)isupper(*a)&&islower(*b)?*a+=32,*b-=32:isupper(*b)&&islower(*a)?*b+=32,*a-=32:0;puts(v[1]);puts(v[2]);}

Ung dung:

char *a, *b; /* Helpers */

main(c, v)
char **v;
{
    /* While strings not terminated... */
    for (a = v[1], b = v[2]; *a && *b; ++a, ++b)
        isupper(*a) && islower(*b)
            ? *a += 32, *b -= 32 /* Make first string lowercase, second uppercase */
            : isupper(*b) && islower(*a)
                ? *b += 32, *a -= 32; /* Make second string lowercase, first uppercase */

    puts(v[1]); /* print out first string */
    puts(v[2]); /* print out second string */
}

Hồng ngọc, 102

$><<gets.chars.zip(gets.chars).map{|i|/[a-z][A-Z]|[A-Z][a-z]/=~i*''?(i.map &:swapcase):i}.transpose*''

Lấy các chuỗi gốc, ghép các chữ cái trong mảng. Nếu chúng là thấp hơn / nắp hoặc nắp / thấp hơn, sau đó trao đổi trên cả hai. Sau đó hoán chuyển các mảng trở lại vào mảng đã ra lệnh của chúng tôi.

Điều này đòi hỏi một dòng mới trong đầu vào.

Perl 5.10+, 101 99 byte

perl -p00e '/\n/;s/([a-z])(?=.{$-[0]}([a-z]))/$x=($1^$2)&" ";$s{$-[2]}=$2^$x;$1^$x/egis;s|.|$s{$-[0]}//$&|eg'

96 byte + 3 byte cho các cờ dòng lệnh p00. Lấy một chuỗi phân cách dòng mới duy nhất làm đầu vào:

$ echo -e "AAAbbb111\nCc2Dd3Ee4" | perl -p00e '...'

Hoặc bạn có thể nhập dữ liệu vào STDIN:

$ perl -p00e '...'
AAAbbb111 <Enter>
Cc2Dd3Ee4 <Ctrl+D>

Hỏng:

perl -p00e'  # Slurp everything into $_, print $_ automatically at the end
    /\n/;    # Match first newline, setting $-[0] to length(s1)

    s/
        ([a-z])  # Match a single letter in s1
        (?=
            .{$-[0]}  # Match n chars where n is length(s1) (until corresponding char in s2)
            ([a-z])   # Corresponding letter in s2
        )
    /
        $x=($1^$2)&" ";   # Check whether bit 6 is the same for both chars.
                          # (Only difference between a lowercase and uppercase ASCII letter
                          # is bit 6; ASCII space is 100000 in binary)

        $s{$-[2]}=$2^$x;  # Swap case of corresponding char in s2 and store in %s,
                          # with position as the key

        $1^$x             # Swap case of current char
    /egis;

    s|.|$s{$-[0]}//$&|eg  # Do a second pass through $_. If there's a value stored in %s
                          # corresponding to this position, use it
'

Nỗ lực đầu tiên trong scala, 138 ký tự

def f(s:String,t:String)={val g=(a:Char,o:Char)=>if(o.isUpper)a.toUpper else a.toLower;s.zip(t).map(c=>(g.tupled(c),g(c._2, c._1))).unzip}

f là một hàm lấy hai chuỗi đầu vào và thực hiện công việc, với một hàm cục bộ, được sử dụng hai lần, để thay đổi trường hợp của chuỗi.

Cùng một mã, với sự thụt lề và chỉ là một tên dễ đọc hơn:

def f_ungolfed(first : String, second : String) = {
  val aux = (c1: Char, c2: Char) => if (c2.isUpper) c1.toUpper else c1.toLower
    first.zip(second).map(
         c => (aux.tupled(c), aux.tupled(c.swap))
    ).unzip
} 

Thạch , 13 byte

=Œu=/ị"Ɱż"Œs$

Một liên kết đơn chấp nhận và trả về danh sách hai "chuỗi" (danh sách các ký tự trong Jelly).

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

Python 2 , 97 byte

lambda a,b:''.join([x,chr(ord(x)&95|ord(y)&32)][(x+y).isalpha()]for x,y in zip(a+'\n'+b,b+' '+a))

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

Tcl , 194 byte

proc C a\ b {proc L x\ y {expr [[set S string] is u $y]?"[$S tou $x]":"[$S is lo $y]"?"[$S tol $x]":"$x"}
lmap x [split $a ""] y [split $b ""] {append s [L $x $y]
append t [L $y $x]}
list $s $t}

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

Haskell , 109 91 byte

import Data.Char
(!)=zipWith f
f c|isUpper c=toUpper|isAlpha c=toLower|1<3=id
a#b=[b!a,a!b]

Cảm ơn @Laikoni cho 16 byte!

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