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!

Açıklama

Giriş, iki dizedir s1ve s2eşit uzunluktadır. Her biri yalnızca yazdırılabilir ASCII içerecek ve uzunluğu en az bir karakter olacaktır. Bunları iki dize, iki dize dizisi veya bir sekme veya yeni satırla ayrılmış s1ve s2ayrılmış tek bir dize olarak girebilirsiniz .

Çıktı aşağıdaki gibidir:

• Her karakter ciçin s1:

  • Karakter bir harf değilse, değişmeden yazdırın.

  • Aksi takdirde, cbir harf ise:

    • İçinde eşleşen karakteri (aynı dizindeki karakter) bulun s2.

      • Büyük harf ise çıktı cbüyük harfle yazılır.

      • Küçük harf ise, küçük harfle cyazdırın.

      • Aksi takdirde çıktı cdeğişmez.

• Öyleyse, s1ve dışında da aynı şeyi yap s2.

Temel olarak, içinde s1eşleşen karakterin büyük s2olduğu tüm harfler s1büyük harfle s2yazılmalı ve aynı endekste küçük harfli olan tüm harfler küçük harf olmalıdır (veya tersi).

Test durumları

Giriş:

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

Çıktı:

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

Giriş:

PRogrammiNG puzZLes & CODe golf
SdlkhkfaladlKsdlalksdg7ldklDgsl

Çıktı:

Programming Puzzles & Code Golf
SDlkhkfalADlksdLAlksdg7LDkldgsl

Giriş:

AAAbbb111
Cc2Dd3Ee4

Çıktı:

AaABbb111
CC2dd3Ee4

Pyth, 19 18 bayt

LCmrW&@dG@drG1d2Cb

Bu, dizelerin listesini kabul eden ve veren bir y işlevini tanımlar .

Pyth Compiler / Executor'da tüm test durumlarını aynı anda doğrulayın .

1 byte kapalı golf için @Jakube teşekkürler.

Nasıl çalışır

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

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

Bu, dizeden bir dizge dizisini çıkaran ve karşılığında bir tane bırakan isimsiz bir işlevdir.

Desteklenen tarayıcılarda, tüm test durumlarını bir kerede CJam tercümanında doğrulayabilirsiniz .

Test durumları

kod

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.

Giriş

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

Çıktı

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

Nasıl çalışır

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 bayt

Bu benim ilk defa kod golfüne girişmem. Yanlış bir şey yaptıysam haberim olsun.

Anahtarlamayı gerçekleştirmek için bitsel işlemler kullanıyorum

golfed:

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

Ungolfed:

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

düzenleme: && ile değiştirildi *

SQL (PostGreSQL), 427 Bayt

Büyük boyutuna rağmen, bu beklediğimden biraz daha küçük oldu. Dürüst olmak için başarabileceğime emin değildim. Hala yapılabilecek çok şey olduğundan şüpheleniyorum :)

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

Biçimlendi ve yorumlandı

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

Test sürüşü

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 bayt

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

Bu, iki dizeyi kabul eden ve bir dizi dizge döndüren bir işlev yaratır. Burada özellikle akıllıca bir şey olmaz; sadece spesifikasyonu algoritmaya doğrudan uygulayan ve iki kez çağıran iç fonksiyon tanımlarız.

Ungolfed:

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 bayt

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

JavaScript en toUpperCase()ve toLowerCase()bayt çok yer almak ama String.fromCharCode()daha da uzun olduğu

Mathematica, 173 169 155 bayt

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

Bu, iki diziden oluşan, örneğin iki diziden oluşan bir diziyi alan bir işlevdir {"Foo","bAR"}. Şemasını yeniden, o un-mekansal-sıkıştırarak f@xolarak f[x]notasyonu kısaltmalar (genişleyen, Göründüğü her yerde f=0>1aka False, t=!faka True, c=Charactersve u=ToUpperCaseQ) ve un-değiştirilmesi ile UpperCaseQ [#] #==u@#(Bu karakterin kendine Büyük harfli versiyonunu eşittir), öyle:

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

Arayüzleme: takip eden &bir fonksiyon yapar. Argümanı her iki durumda da "#" olarak eklenir /@ #. Örneğin f=0>1; ... & [{"AAAbbb111", "Cc2Dd3Ee4"}]çıktı üretir {AaABbb111,CC2dd3Ee4}.

İşleme: Sırayla her zamanki gibi sıralanmıştır:

• Çıktısı, MapThread[...]iki karakter listesinin bir listesidir. StringJoin, iki dizenin bir listesini üretmek için bu iki karakter listesinin her birine uygulanır, çıktı.
• MapThread[#[#2]&, ... , 2]2'ye iki öğe listesinin bir dizisine etki eder. İlk liste 2'ye kadar bir işlevler dizisidir. İkinci liste, Characters /@ #iki giriş dizesindeki karakter listeleri olan 2'ye kadar bir karakter dizisidir . İşlev 2'de ve tek tek karakterlerde, derinlik 2'de çalışır.
• Reverse[...] iki işlev listesinin yerini değiştirir, böylece MapThread ikinci dizginin işlevlerini ilk dizgeye uygular ve bunun tersi de geçerlidir.
• { ... } & İki giriş dizesinin her birine uygulanan anonim bir işlevdir.
• {LetterQ[#], UpperCaseQ[#]} & /@ Characters[#]bir dize karakter listesine böler, sonra her karakteri iki eleman listesi ile değiştirir. Bu iki öğe listesinde, ilk öğe, Truekarakterin bir harf olması durumundadır ve Falseaksi halde benzer şekilde, ikinci öğe karakterin büyük harf olup olmadığını gösterir. UpperCaseQ[]Bir mektup almazsa true döndüremezsiniz.
• /. {{False, _} -> (# &), {True, True} -> ToUpperCase, {True, False} -> ToLowerCase}bu iki öğe listesini işlevlerle değiştirir. (Kısaltmaların genişletilmesi tve feşleşme denenmeden önce gerçekleşir.) İki öğe listesinin Falseilk öğesi olarak varsa, işlev (# &), kimlik işlevi ile değiştirilir. (Parantez aksi işareti daha sıkı şekilde ok gereklidir.) İle Aksi takdirde, iki öğe listesi başlar True, karakter yazmak oldu ve çıkış fonksiyonları ToUpperCaseve ToLowerCasekendi halinde karşılık gelir. (Bunun sonuncusunu kontrol etmek Falsegereksizdir, aslında {_,_}->ToLowerCaseişe yarar, henüz değiştirilmemiş bir şeyi yakalamak, ancak bu daha kısa ve daha karanlık olmazdı.)

Tek zorluk, iki boyutlu bir fonksiyon dizisini bir argüman dizisine bağlamanın özlü bir yolunu bulmaktı.

Düzenleme: "yararlı" kesme / yapıştırma linebreak tersbölüleri yakalamak için @Martin Büttner sayesinde 1>0ve 1<0kısaltmalar ve ayrıca rehberlik bayt uzunluğunu saymak için değil (o :-) ne olursa olsun) karakterleri

Düzen2: Küresel isim alanını kirletmenin kabul edilebilir bir golf olduğunu, bana bir karakter işlevi uygulamasının hatırlattığını ve iki büyük harf işlevinin birinin kısaltmasıyla kullanıldığını ve birinin diğerinin öykünmek için kullanılmasının kullanıldığını öne sürdüğü için @Martin Büttner'e teşekkürler dört karakter). (Sanırım bunu daha önce yaptı. :-))

Python 3, 131 bayt

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)

İşlev bir dizgede dizeleri döndürür

Erlang, 157 bayt

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

İki dizeyi (aslında listeler) iki karakterli bir listeye sıkıştırır ve her bir karakteri bir liste kavrama kullanarak uygun duruma getirir.

Python 2, 101 bayt

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

İki dizeyi alan ve çıktı dizelerini bir listede döndüren adsız bir işlev. Bunu Python 2 olarak işaretledim çünkü Python 3 bu şekilde I,I[::-1]tek başına oturmaya izin vermiyor .

Python, 126 bayt

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

İşlev fbir dizgede dizeleri döndürür

C, 181 bayt

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

Standart kütüphane adlarını uygun bir şekilde kısaltmakta güçlük çekti, (# onları tanımlamak baştan sona 11 karakter alıyor). Ana özyinelemeyi ve x ve y değişkenlerini argüman olarak kullanır.

main (<non-zero>, argv) = main (0, {argv [1], argv [2]}) çağrısı yapın, sonra yeni satırı yazdırın, sonra main (0, {argv [2], argv [1]}) çağırın.

main (0, {x, y}) = x, dizge dönüşü 0 ise, aksi halde x'in ilk karakterinin doğru harfini basar ve main'i çağır (0, {x + 1, y + 1}).

İki dizeyle bağımsız değişken olarak çalıştırın.

C - 164 153 Bayt - 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 hakkında

Wc -c'yi indirebilirsem güncellenir. Aslında çok iyi çalışıyor

F #, 211 karakter

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

daha iyi olabilir ...

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;

Ungolfed:

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

Örnek:

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

C, 164 bayt

Algoritmanın problemde tarif edildiği gibi kullanılması hemen hemen aynıdır. Giriş parametresi olarak 2 karakter alır.

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

Ungolfed:

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

Ruby, 102

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

Orijinal dizeleri alır, dizilerdeki harfleri çiftler. Bunlar alt / üst veya alt / alt ise, her ikisini de değiştirin. Ardından dizileri tekrar sıralı dizimize çevirin.

Bu, girişte izleyen bir yeni satır gerektirir.

Perl 5.10+, 101 99 bayt

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

Komut satırı bayrakları için 96 bayt + 3 bayt p00. Girdi olarak tek bir yeni satır ayrılmış dize alır:

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

Veya STDIN'e giriş yapabilirsiniz:

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

Bozuldu:

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'da ilk deneme, 138 karakter

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, iki girdi dizesini alan ve işi, yerel bir işlevle dizeleri değiştirmek için iki kez kullanılan bir işlevdir.

Girinti ve sadece bir litre daha okunabilir isimleri ile aynı kod:

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
} 

Jöle , 13 bayt

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

İki "dizge" (Jelly'deki karakter listeleri) listelerini kabul eden ve geri gönderen monadik bir Bağlantı.

Çevrimiçi deneyin!

Python 2,97 bayt

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

Çevrimiçi deneyin!

Tcl , 194 bayt

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}

Çevrimiçi deneyin!

Haskell , 109 91 bayt

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

16 baytlık @Likonikoni'ye teşekkürler!

Çevrimiçi deneyin!