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!

描述

输入是两个字符串，s1并且s2长度相等。它们每个将仅包含可打印的ASCII，并且长度至少为一个字符。您可以将它们输入为两个字符串，两个字符串的数组或带制表符或换行符的单个字符串，s1并s2用制表符或换行符分隔。

输出如下：

• 对于每个角色c在s1：

  • 如果字符不是字母，则将其原样输出。

  • 否则，如果c是字母：

    • 在中找到匹配的字符（具有相同索引的字符）s2。

      • 如果是大写字母，则输出c大写。

      • 如果是小写字母，则输出c为小写字母。

      • 否则，输出c保持不变。

• 然后，除了s1和以外，请执行相同的操作s2。

本质上，所有与之s1匹配的字符s2为大写的字母都应大写，并且s1在同一索引中带有小写字母的所有字母s2都应变为小写（反之亦然）。

测试用例

输入：

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

输出：

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

输入：

PRogrammiNG puzZLes & CODe golf
SdlkhkfaladlKsdlalksdg7ldklDgsl

输出：

Programming Puzzles & Code Golf
SDlkhkfalADlksdLAlksdg7LDkldgsl

输入：

AAAbbb111
Cc2Dd3Ee4

输出：

AaABbb111
CC2dd3Ee4

Pyth，19 18字节

LCmrW&@dG@drG1d2Cb

这定义了一个函数y，该函数接受并返回一个字符串列表。

在Pyth编译器/执行器中一次验证所有测试用例。

感谢@Jakube高尔夫球了1个字节。

怎么运行的

                   " (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个字节

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

这是一个匿名函数，该函数从堆栈中弹出一个字符串数组，然后返回一个。

在受支持的浏览器中，您可以在CJam解释器中一次验证所有测试用例。

测试用例

码

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.

输入项

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

输出量

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

怎么运行的

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字节

这是我第一次参加标准高尔夫。让我知道我做错了什么。

我正在使用按位操作来执行切换

打高尔夫球：

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]);}

取消高尔夫：

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

编辑：用＆替换*

SQL（PostGreSQL），427字节

尽管尺寸很大，但最终比我预期的要小很多。老实说，我不太确定自己是否能够做到这一点。我怀疑还有很多事情可以做：）

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

格式化和评论

-- 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

测试运行

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

朱莉娅140字节

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)))

这将创建一个接受两个字符串并返回字符串元组的函数。这里没有什么特别聪明的事。我们只需定义一个内部函数即可直接实现规范中的算法，然后调用两次。

取消高尔夫：

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个字节

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()和toLowerCase()占用大量的字节，但String.fromCharCode()甚至更长

数学，173个 169 155字节

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]&

此函数采用两个字符串的数组，例如{"Foo","bAR"}，输出两个字符串的数组。联合国空间上压缩它，改写该计划f@x为f[x]凡出现，扩大了符号缩写（f=0>1又名False，t=!f又名True，c=Characters和u=ToUpperCaseQ），并且未替换为UpperCaseQ [＃] #==u@#（这个角色等于它的大写的版本），它是：

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

接口：尾随&使它起作用。在的两个实例中，其参数均以“＃”插入/@ #。例如f=0>1; ... & [{"AAAbbb111", "Cc2Dd3Ee4"}]产生输出{AaABbb111,CC2dd3Ee4}。

加工：按常规顺序在外面告诉：

• 的输出MapThread[...]是两个字符列表的列表。StringJoin应用于这两个字符列表中的每一个，以产生两个字符串的列表，即输出。
• MapThread[#[#2]&, ... , 2]作用于两个2×n元素列表的数组。第一个列表是2×n函数数组。第二个列表是2×n字符数组，Characters /@ #即两个输入字符串中的字符列表。它在深度2（即功能和单个字符）上起作用。
• Reverse[...] 交换函数的两个子列表，以便MapThread将第二个字符串的函数应用于第一个字符串，反之亦然。
• { ... } & 是应用于两个输入字符串中的每个字符串的匿名函数。
• {LetterQ[#], UpperCaseQ[#]} & /@ Characters[#]将字符串拆分为字符列表，然后将每个字符替换为两个元素列表。在这两个元素列表中，第一个元素是True字符是否为字母，False否则，类似地，第二个元素指示字符是否为大写。 UpperCaseQ[]如果未收到字母，则不能返回true。
• /. {{False, _} -> (# &), {True, True} -> ToUpperCase, {True, False} -> ToLowerCase}用函数替换这两个元素列表。（缩写的膨胀t和f任何匹配尝试之前发生）。如果两个元件列表具有False作为其第一元件，它被替换为函数(# &)，恒等函数。（括号是必需的，否则箭头比＆符更紧密地绑定。）否则，两个元素列表以开头True，该字符为字母，然后输出函数ToUpperCase并ToLowerCase对应于其大小写。（检查最后一个False是不必要的，实际上{_,_}->ToLowerCase是可行的，可以捕获尚未替换的任何东西，但这不会变得更短且更晦涩。）

唯一的挑战是想出一种简洁的方法来将二维函数数组压缩为参数数组。

编辑：感谢@MartinBüttner捕获了“有用的”剪切/粘贴换行符反斜杠，1>0和和1<0缩写，并且还提供了以字节为单位而不是字符计数长度的指导（无论是：-））

Edit2：还要感谢@MartinBüttner指出污染全局名称空间是可以接受的，这使我想起了一个字符函数应用程序，并建议将两个大写函数替换为一个缩写，并使用一个模拟另一个函数（保存）。四个字符）。（我认为他以前已经做到了。:-)）

Python 3，131个字节

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)

函数返回元组中的字符串

Erlang，157个字节

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).

将两个字符串（实际上是列表）压缩为两个字符的元组列表，并使用列表理解将每个字符映射到适当的大小写。

Python 2，101字节

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]]

一个匿名函数，它接受两个字符串并在列表中返回输出字符串。我将其标记为Python 2，因为Python 3不允许I,I[::-1]像这样单独坐在最后。

Python，126个字节

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)))

函数f返回元组中的字符串

C，181字节

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);}

很难以一种值得的方式来缩短标准库名称（（定义它们需要11个字符的开销））。使用主递归和全局变量x和y作为参数。

main（<非零>，argv）=调用main（0，{argv [1]，argv [2]}）然后打印换行符，然后调用main（0，{argv [2]，argv [1]}）

main（0，{x，y}）=如果x是字符串的结尾，则返回0，否则打印x的第一个字符的正确情况并调用main（0，{x + 1，y + 1}）。

使用两个字符串作为参数运行。

C- 164153字节-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]);}

gcc程序

./a.out AfdgF a2dfsd

如果我可以将wc -c降下来，将会更新。实际上效果很好

F＃，211个字符

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

有待改善 ...

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;

取消高尔夫：

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

例：

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

C，164字节

几乎实现了问题中所述的算法。将2个字符串作为输入参数。

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]);}

取消高尔夫：

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 */
}

露比102

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

取出原始字符串，将数组中的字母配对。如果它们是下限/上限或上限/下限，则在两者上互换大小写。然后将数组转置为我们的有序数组。

这需要输入末尾的换行符。

Perl 5.10 +，101 99个字节

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

96字节+ 3字节的命令行标志p00。以单个换行符分隔的字符串作为输入：

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

或者，您可以在STDIN上输入输入：

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

细分：

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
'

首次尝试Scala，138个字符

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是一个函数，它使用两个输入字符串来完成工作，并且使用局部函数（两次）来更改字符串的大小写。

相同的代码，带有缩进和更易读的名称：

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
} 

果冻，13 个字节

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

一个接受并返回两个“字符串”列表（Jelly中的字符列表）的单子链接。

在线尝试！

Python 2，97字节

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))

在线尝试！

Tcl，194字节

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}

在线尝试！

Haskell，109 91字节

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

感谢@Laikoni提供16个字节！

在线尝试！