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 Compiler / Executor 에서 모든 테스트 사례를 한 번에 확인하십시오 .

1 바이트를 골프로 해준 @Jakube에게 감사합니다.

작동 원리

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

자바 스크립트 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))

자바 스크립트의 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]두 개의 2xn 요소 목록의 배열에 작용합니다. 첫 번째 목록은 2xn 함수 배열입니다. 두 번째 목록은 2xn 문자 배열이며 Characters /@ #두 입력 문자열의 문자 목록입니다. 깊이 2, 즉 기능과 개별 문자에서 작동합니다.
• Reverse[...] MapThread가 두 번째 문자열의 함수를 첫 번째 문자열에 적용하거나 그 반대로 적용하도록 함수의 두 하위 목록을 교체합니다.
• { ... } & 두 입력 문자열 각각에 적용되는 익명 함수입니다.
• {LetterQ[#], UpperCaseQ[#]} & /@ Characters[#]문자열을 문자 목록으로 분할 한 다음 각 문자를 두 요소 목록으로 바꿉니다. 이 두 요소 목록에서 첫 번째 요소는 True문자가 문자 인 False경우와 유사하게 두 번째 요소는 문자가 대문자인지 여부를 나타냅니다. UpperCaseQ[]문자를받지 못하면 true를 반환 할 수 없습니다.
• /. {{False, _} -> (# &), {True, True} -> ToUpperCase, {True, False} -> ToLowerCase}이 두 요소 목록을 함수로 바꿉니다. (약어의 확장 t및 f일치를 시도하기 전에 발생합니다.) 두 요소 목록이 False첫 번째 요소 인 경우 (# &)identity 함수 라는 함수로 대체됩니다 . (괄호 달리 앰퍼샌드보다 단단히 결속 화살표 필요하다.)와 그렇지 않은 두 요소리스트 시작 True, 문자는 글자, 그리고 우리 출력 기능 ToUpperCase과 ToLowerCase케이스에 대응. (마지막 False으로 이것을 점검하는 것은 불필요하며, 실제로 {_,_}->ToLowerCase교체되지 않은 것을 잡을 수는 있지만 더 짧고 모호하지는 않습니다.)

유일한 도전은 함수의 2 차원 배열을 인수 배열에 압축하는 간결한 방법을 찾는 것이 었습니다.

편집 : 잡기위한 @Martin 있음 Büttner 덕분에 "도움"컷 / LINEBREAK의 백 슬래시를 붙여 넣 1>0및1<0 약어 약어를 가져 와서 문자가 아닌 바이트 단위의 길이를 계산하는 지침에 대해 (-:))

Edit2 : @Martin Büttner에게 글로벌 네임 스페이스를 오염시키는 것이 허용 가능한 골프임을 지적하고 하나의 문자 함수 응용 프로그램을 상기 시키며 두 개의 대문자 함수를 하나의 약어로 바꾸고 다른 하나를 에뮬레이트하기 위해 하나의 약어를 사용하도록 제안하는 것에 감사드립니다 (저장 네 문자). (나는 그가 전에 이것을 한 것 같아요. :-))

파이썬 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)

함수는 튜플에서 문자열을 반환

얼랭, 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).

두 개의 문자열 (실제로 목록)을 두 문자 튜플 목록으로 압축하고 목록 이해를 사용하여 각 문자를 적절한 경우에 매핑합니다.

파이썬 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]]

두 개의 문자열을 가져와 목록에 출력 문자열을 반환하는 익명 함수입니다. 파이썬 3은 I,I[::-1]마지막에 혼자 앉을 수 없기 때문에 이것을 파이썬 2로 표시 했습니다.

파이썬, 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);}

표준 라이브러리 이름을 합리적으로 단축하는 데 어려움이있었습니다. 주 재귀와 전역 변수 x 및 y를 인수로 사용합니다.

main (<0이 아닌>, 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 prog.c

./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
'

스칼라 첫 시도, 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$

두 개의 "문자열"(젤리의 문자 목록) 목록을 수락하고 반환하는 모나드 링크.

온라인으로 사용해보십시오!

파이썬 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}

온라인으로 사용해보십시오!

하스켈 , 109 91 바이트

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

16 바이트의 @Laikoni에게 감사합니다!

온라인으로 사용해보십시오!