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!

Opis

Wejście jest dwa ciągi, s1a s2, równej długości. Każdy z nich będzie zawierał tylko ASCII do wydrukowania i będzie miał co najmniej jeden znak długości. Możesz wprowadzić je jako dwa ciągi, tablicę dwóch ciągów lub pojedynczy ciąg z s1i s2oddzielony tabulatorem lub znakiem nowej linii.

Dane wyjściowe są następujące:

• Dla każdej postaci cw s1:

  • Jeśli znak nie jest literą, wyślij go bez zmian.

  • W przeciwnym razie, jeśli cjest to litera:

    • Znajdź pasujący znak (ten o tym samym indeksie) w s2.

      • Jeśli jest to wielka litera, produkcja jest cpisana wielkimi literami.

      • Jeśli jest to mała litera, cwypisz małymi literami.

      • W przeciwnym razie dane wyjściowe cpozostają niezmienione.

• Następnie zrób to samo, z wyjątkiem przełączania s1i s2przełączania.

Zasadniczo wszystkie litery, w s1których pasujący znak s2jest wielką, powinny być pisane wielkimi literami, a wszystkie litery s1z małą literą o tym samym indeksie w s2powinny stać się małe (i odwrotnie).

Przypadki testowe

Wkład:

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

Wydajność:

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

Wkład:

PRogrammiNG puzZLes & CODe golf
SdlkhkfaladlKsdlalksdg7ldklDgsl

Wydajność:

Programming Puzzles & Code Golf
SDlkhkfalADlksdLAlksdg7LDkldgsl

Wkład:

AAAbbb111
Cc2Dd3Ee4

Wydajność:

AaABbb111
CC2dd3Ee4

Pyth, 19 18 bajtów

LCmrW&@dG@drG1d2Cb

Definiuje funkcję y, która akceptuje i zwraca listę ciągów znaków.

Zweryfikuj wszystkie przypadki testowe jednocześnie w Pyth Compiler / Executor .

Dzięki @Jakube za grę w golfa z 1 bajtu.

Jak to działa

                   " (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 bajtów

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

Jest to anonimowa funkcja, która wyrzuca tablicę ciągów ze stosu i pozostawia jeden w zamian.

W obsługiwanych przeglądarkach możesz zweryfikować wszystkie przypadki testowe jednocześnie w interpretera CJam .

Przypadki testowe

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.

Wkład

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

Wydajność

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

Jak to działa

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 bajtów

To moja pierwsza w historii gra w golfa kodowego. Daj mi znać, jeśli zrobiłem coś złego.

Korzystam z operacji bitowych do przełączania

Gra w golfa:

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

Nie golfowany:

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

edycja: zastąpiono && *

SQL (PostGreSQL), 427 bajtów

Pomimo tego, że jest ogromny, okazało się, że jest nieco mniejszy niż się spodziewałem. Nie byłem całkiem pewien, czy będę w stanie to zrobić szczerze. Podejrzewam, że jest jeszcze wiele do zrobienia :)

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

Sformatowane i skomentowane

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

Testowe uruchomienie

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 bajtów

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

Tworzy to funkcję, która akceptuje dwa łańcuchy i zwraca krotkę łańcuchów. Nie dzieje się tu nic szczególnie sprytnego; po prostu definiujemy funkcję wewnętrzną, która bezpośrednio implementuje algorytm w specyfikacji i wywołujemy go dwukrotnie.

Nie golfowany:

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 bajtów

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()i toLowerCase()zajmują dużo bajtów, ale String.fromCharCode()jest jeszcze dłuższy

Mathematica, 173 169 155 bajtów

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

Jest to funkcja pobierająca tablicę dwóch ciągów, np. {"Foo","bAR"}I wysyłająca tablicę dwóch ciągów. Un-przestrzennie ściskając go, przepisywanie schemat f@xjak f[x]wszędzie wydaje się, rozszerzając skróty notacją ( f=0>1aka False, t=!faka True, c=Charactersi u=ToUpperCaseQ), i un-zastąpienie UpperCaseQ [#] z #==u@#(postać ta jest równa jego wersję duże litery), to jest:

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

Interfejs: trailing &sprawia, że ​​jest to funkcja. Jego argument jest wstawiany jako „#” w obu przypadkach /@ #. Na przykład f=0>1; ... & [{"AAAbbb111", "Cc2Dd3Ee4"}]produkuje dane wyjściowe {AaABbb111,CC2dd3Ee4}.

Przetwarzanie: Powiedziane zwykle na zewnątrz w celu:

• Dane wyjściowe MapThread[...]to lista dwóch list znaków. StringJoin jest stosowany do każdej z tych dwóch list znaków, aby utworzyć listę dwóch ciągów, wynik.
• MapThread[#[#2]&, ... , 2]działa na tablicę dwóch list elementów 2 na n. Pierwsza lista to tablica funkcji 2 na n. Druga lista to tablica znaków 2 na n Characters /@ #, lista znaków w dwóch ciągach wejściowych. Działa na głębokości 2, tj. Na funkcjach i poszczególnych znakach.
• Reverse[...] zamienia dwie podlisty funkcji, dzięki czemu MapThread zastosuje funkcje drugiego ciągu do pierwszego ciągu i odwrotnie.
• { ... } & to anonimowa funkcja stosowana do każdego z dwóch ciągów wejściowych.
• {LetterQ[#], UpperCaseQ[#]} & /@ Characters[#]dzieli ciąg na listę znaków, a następnie zastępuje każdy znak dwiema listami elementów. Na tych dwóch listach elementów pierwszy element ma Truepostać, jeśli znak jest literą, a w Falseprzeciwnym razie drugi element wskazuje, czy znak jest pisany wielkimi literami. UpperCaseQ[]nie może zwrócić prawdy, jeśli nie otrzyma listu.
• /. {{False, _} -> (# &), {True, True} -> ToUpperCase, {True, False} -> ToLowerCase}zastępuje te dwie listy elementów funkcjami. (Rozwinięcie skrótów ti fwystępuje przed próbą dopasowania). Jeśli lista dwóch elementów ma Falseswój pierwszy element, jest ona zastępowana funkcją (# &), funkcją tożsamości. (Nawiasy są konieczne, w przeciwnym razie strzałka wiąże się ściślej niż znak ampersand). W przeciwnym razie lista dwóch elementów zaczyna się od True, znak był literą, a my wyprowadzamy funkcje ToUpperCasei ToLowerCaseodpowiadamy ich wielkości. (Sprawdzanie tego ostatniego nie Falsejest konieczne, w rzeczywistości {_,_}->ToLowerCasezadziałałoby, wyłapując wszystko, co jeszcze nie zostało wymienione, ale nie byłoby to krótsze i bardziej niejasne).

Jedynym wyzwaniem było znalezienie zwięzłego sposobu spakowania dwuwymiarowej tablicy funkcji do tablicy argumentów.

Edycja: Podziękowania dla @Martin Büttner za wyłapanie ukośnych odwrotnych ukośników, skrótów 1>0i 1<0skrótów, oraz pomoc w liczeniu długości w bajtach, a nie znakach (cokolwiek to jest :-))

Edit2: Dalsze podziękowania dla @Martin Büttner za zwrócenie uwagi na to, że zanieczyszczenie globalnej przestrzeni nazw jest akceptowalnym golfem, przypomnienie mi jednej aplikacji funkcji znakowej i zasugerowanie zastąpienia dwóch funkcji wielkimi literami skrótem dla jednej i używanie jednej do emulacji drugiej (zapisywanie cztery znaki). (Myślę, że już to zrobił. :-))

Python 3, 131 bajtów

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)

Funkcja zwraca ciągi w krotce

Erlang, 157 bajtów

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

Zipuje dwa ciągi (właściwie listy) na listę krotek składającą się z dwóch znaków i mapuje każdy znak na odpowiedni przypadek, korzystając ze zrozumienia listy.

Python 2, 101 bajtów

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

Anonimowa funkcja, która pobiera dwa ciągi i zwraca ciągi wyjściowe z listy. Oznacziłem to jako Python 2, ponieważ Python 3 nie pozwala I,I[::-1]siedzieć samemu na końcu w ten sposób.

Python, 126 bajtów

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

Funkcja fzwraca ciągi w krotce

C, 181 bajtów

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

Miałem problem ze skracaniem standardowych nazw bibliotek w wartościowy sposób (# ich zdefiniowanie wymaga narzutu 11 znaków). Wykorzystuje jako argumenty główną rekurencję i zmienne globalne xiy.

main (<non-zero>, argv) = wywołanie main (0, {argv [1], argv [2]}), następnie wydrukowanie nowej linii, a następnie wywołanie main (0, {argv [2], argv [1]})

main (0, {x, y}) = jeśli x jest końcem łańcucha, zwraca 0, w przeciwnym razie wypisz poprawną wielkość pierwszego znaku x i wywołaj main (0, {x + 1, y + 1}).

Uruchom z dwoma ciągami jako argumentami.

C - 164 153 bajtów - 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

Zaktualizuje się, jeśli uda mi się obniżyć wc -c. Właściwie działa bardzo dobrze

F #, 211 znaków

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

może być lepiej ...

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;

Nie golfowany:

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

Przykład:

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

C, 164 bajty

Prawie implementacja algorytmu opisanego w problemie. Pobiera 2 łańcuchy jako parametry wejściowe.

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

Nie golfowany:

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

Usuwa oryginalne ciągi znaków, paruje litery w tablicach. Jeśli są albo niższe / cap lub cap / niższe, zamień na obu. Następnie przetransportuj tablice z powrotem do naszej uporządkowanej tablicy.

Wymaga to wprowadzenia nowego wiersza w danych wejściowych.

Perl 5.10+, 101 99 bajtów

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

96 bajtów + 3 bajty dla flag wiersza poleceń p00. Pobiera na wejściu pojedynczy ciąg rozdzielany znakiem nowej linii:

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

Lub możesz wprowadzić dane wejściowe w STDIN:

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

Zepsuty:

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
'

Pierwsza próba w Scali, 138 znaków

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 jest funkcją, która pobiera dwa ciągi wejściowe i wykonuje zadanie, używając funkcji lokalnej, użytej dwa razy, do zmiany wielkości liter ciągów.

Ten sam kod, z wcięciami i tylko trochę bardziej czytelnymi nazwami:

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
} 

Galaretka , 13 bajtów

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

Monadyczny link przyjmujący i zwracający listy dwóch „ciągów” (list znaków w galarecie).

Wypróbuj online!

Python 2 , 97 bajtów

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

Wypróbuj online!

Tcl , 194 bajty

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}

Wypróbuj online!

Haskell , 109 91 bajtów

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

Dzięki @Laikoni za 16 bajtów!

Wypróbuj online!