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!

Beschreibung

Die Eingabe besteht aus zwei Zeichenfolgen s1und s2ist gleich lang. Sie enthalten jeweils nur druckbares ASCII und haben eine Länge von mindestens einem Zeichen. Sie können diese als zwei Zeichenfolgen, ein Array von zwei Zeichenfolgen oder eine einzelne Zeichenfolge mit s1und s2getrennt durch ein Tabulatorzeichen oder eine neue Zeile eingeben.

Die Ausgabe ist wie folgt:

• Für jedes Zeichen cin s1:

  • Wenn das Zeichen kein Buchstabe ist, geben Sie es unverändert aus.

  • Andernfalls, wenn ces sich um einen Buchstaben handelt:

    • Suchen Sie das übereinstimmende Zeichen (das am selben Index) in s2.

      • Wenn es sich um einen Großbuchstaben handelt, wird die Ausgabe caktiviert.

      • Wenn es sich um einen Kleinbuchstaben handelt, erfolgt die Ausgabe cin Kleinbuchstaben.

      • Ansonsten Ausgabe cunverändert.

• Dann mache dasselbe, außer mit s1und s2geschaltet.

Im Wesentlichen sollten alle Buchstaben, s1für die das übereinstimmende Zeichen in s2Großbuchstaben steht, groß geschrieben werden, und alle Buchstaben s1mit einem Kleinbuchstaben am selben Index in s2sollten in Kleinbuchstaben umgewandelt werden (und umgekehrt).

Testfälle

Eingang:

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

Ausgabe:

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

Eingang:

PRogrammiNG puzZLes & CODe golf
SdlkhkfaladlKsdlalksdg7ldklDgsl

Ausgabe:

Programming Puzzles & Code Golf
SDlkhkfalADlksdLAlksdg7LDkldgsl

Eingang:

AAAbbb111
Cc2Dd3Ee4

Ausgabe:

AaABbb111
CC2dd3Ee4

Pyth, 19 18 Bytes

LCmrW&@dG@drG1d2Cb

Dies definiert eine Funktion y , die eine Liste von Zeichenfolgen akzeptiert und zurückgibt.

Überprüfen Sie alle Testfälle gleichzeitig im Pyth Compiler / Executor .

Vielen Dank an @Jakube für das Golfen ab 1 Byte.

Wie es funktioniert

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

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

Dies ist eine anonyme Funktion, die ein Array von Zeichenfolgen aus dem Stapel entfernt und eine zurückgibt.

In unterstützten Browsern können Sie alle Testfälle gleichzeitig im CJam-Interpreter überprüfen .

Testfälle

Code

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.

Eingang

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

Ausgabe

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

Wie es funktioniert

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 Bytes

Dies ist mein erster Versuch, überhaupt Codegolf zu spielen. Lassen Sie mich wissen, wenn ich etwas falsch gemacht habe.

Ich verwende bitweise Operationen, um die Umschaltung durchzuführen

Golf gespielt:

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

Bearbeiten: && durch * ersetzt

SQL (PostGreSQL), 427 Bytes

Trotz der enormen Größe war dies etwas kleiner als ich erwartet hatte. Um ehrlich zu sein, war ich mir nicht ganz sicher, ob ich es schaffen würde. Ich vermute, es gibt noch viel zu tun :)

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

Formatiert und kommentiert

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

Testlauf

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 Bytes

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

Dadurch wird eine Funktion erstellt, die zwei Zeichenfolgen akzeptiert und ein Tupel von Zeichenfolgen zurückgibt. Hier ist nichts besonders Schlaues los; Wir definieren einfach eine innere Funktion, die den Algorithmus direkt in der Spezifikation implementiert, und rufen ihn zweimal auf.

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 Bytes

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

JavaScript's toUpperCase()und toLowerCase()nehmen eine Menge Bytes ein, sind aber String.fromCharCode()noch länger

Mathematica, 173 169 155 Bytes

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

Dies ist eine Funktion, die ein Array von zwei Zeichenfolgen {"Foo","bAR"}aufnimmt , z. B. und ein Array von zwei Zeichenfolgen ausgibt. Dekomprimieren Sie es räumlich, schreiben Sie das Schema f@xwie f[x]gewünscht neu, erweitern Sie die Notationsabkürzungen ( f=0>1aka False, t=!faka True, c=Charactersund u=ToUpperCaseQ) und ersetzen Sie UpperCaseQ [#] nicht durch #==u@#(dieses Zeichen entspricht der Großbuchstaben-Version).

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

Schnittstelle: Durch das Trailing &wird dies zu einer Funktion. Sein Argument wird in beiden Instanzen von als "#" eingefügt /@ #. Zum Beispiel f=0>1; ... & [{"AAAbbb111", "Cc2Dd3Ee4"}]erzeugt die Ausgabe {AaABbb111,CC2dd3Ee4}.

Verarbeitung: erzählt in üblichen außerhalb in auftrag:

• Die Ausgabe von MapThread[...]ist eine Liste von zwei Listen von Zeichen. StringJoin wird auf jede dieser beiden Zeichenlisten angewendet, um eine Liste mit zwei Zeichenfolgen zu erstellen, die Ausgabe.
• MapThread[#[#2]&, ... , 2]Wirkt auf ein Array von zwei 2-mal-n-Elementlisten. Die erste Liste ist ein 2-mal-n-Array von Funktionen. Die zweite Liste ist ein 2-mal-n-Array von Zeichen Characters /@ #, die Liste der Zeichen in den beiden Eingabezeichenfolgen. Es arbeitet in der Tiefe 2, dh an den Funktionen und einzelnen Zeichen.
• Reverse[...] Vertauscht die beiden Unterlisten von Funktionen, sodass MapThread die Funktionen der zweiten Zeichenfolge auf die erste Zeichenfolge anwendet und umgekehrt.
• { ... } & ist eine anonyme Funktion, die auf jede der beiden Eingabezeichenfolgen angewendet wird.
• {LetterQ[#], UpperCaseQ[#]} & /@ Characters[#]Teilt eine Zeichenfolge in eine Liste von Zeichen und ersetzt jedes Zeichen durch zwei Elementlisten. In diesen beiden Elementlisten gibt das erste Element an, Trueob das Zeichen ein Buchstabe ist, und Falseansonsten gibt das zweite Element an, ob es sich bei dem Zeichen um Großbuchstaben handelt. UpperCaseQ[]kann nicht true zurückgeben, wenn es keinen Brief erhält.
• /. {{False, _} -> (# &), {True, True} -> ToUpperCase, {True, False} -> ToLowerCase}ersetzt diese beiden Elementlisten durch Funktionen. (Erweiterung der Abkürzungen tund ferfolgt, bevor ein Abgleich versucht wird.) Wenn eine Liste mit zwei Elementen Falseals erstes Element vorhanden ist, wird sie durch die Funktion (# &), die Identitätsfunktion, ersetzt. (Die Klammern sind erforderlich, ansonsten ist der Pfeil enger als das kaufmännische Und.) Andernfalls beginnt die Liste mit zwei Elementen True, das Zeichen war ein Buchstabe, und wir geben die Funktionen aus , die der Groß- ToUpperCaseund ToLowerCaseKleinschreibung entsprechen. (Es ist nicht erforderlich, nach letzterem zu suchen. Dies würde Falsetatsächlich {_,_}->ToLowerCasefunktionieren und alles auffangen, was noch nicht ersetzt wurde. Dies wäre jedoch nicht kürzer und unklarer.)

Die einzige Herausforderung bestand darin, einen prägnanten Weg zu finden, um ein zweidimensionales Array von Funktionen mit einem Array von Argumenten zu verbinden.

Edit: Danke an @Martin Büttner für das Abfangen von "hilfreichen" Backslashes zum Ausschneiden / Einfügen von Zeilenumbrüchen, die 1>0und 1<0Abkürzungen, und auch für die Anleitung zum Zählen der Länge in Bytes, nicht in Zeichen (was auch immer das sind :-))

Edit2: Vielen Dank an @Martin Büttner für den Hinweis, dass das Verschmutzen des globalen Namensraums akzeptabel ist. Erinnert mich an eine Zeichenfunktionsanwendung und schlägt vor, die beiden Großbuchstaben durch eine Abkürzung für eine zu ersetzen und die eine zu verwenden, um die andere zu emulieren (Speichern) vier Zeichen). (Ich denke, er hat das schon mal gemacht. :-))

Python 3, 131 Bytes

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)

Die Funktion gibt Strings in einem Tupel zurück

Erlang, 157 Bytes

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

Zippt die beiden Zeichenfolgen (eigentlich Listen) in eine Zwei-Zeichen-Tupelliste und ordnet jedes Zeichen mithilfe eines Listenverständnisses dem entsprechenden Fall zu.

Python 2, 101 Bytes

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

Eine anonyme Funktion, die zwei Zeichenfolgen verwendet und die Ausgabezeichenfolgen in einer Liste zurückgibt. Ich habe dies als Python 2 markiert, weil Python 3 es nicht zulässt I,I[::-1], am Ende so alleine zu sitzen.

Python, 126 Bytes

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

Die Funktion fgibt Strings in einem Tupel zurück

C, 181 Bytes

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

Es gab Probleme, die Namen der Standardbibliotheken auf eine sinnvolle Weise zu kürzen (für die Definition sind 11 zusätzliche Zeichen erforderlich). Verwendet die Hauptrekursion und die globalen Variablen x und y als Argumente.

main (<nicht null>, argv) = Haupt (0, {argv [1], argv [2]} aufrufen, dann neue Zeile ausgeben, dann Haupt (0, {argv [2], argv [1]} aufrufen)

main (0, {x, y}) = Wenn x das Ende der Zeichenfolge ist, wird 0 zurückgegeben. Anderenfalls wird die korrekte Schreibweise des ersten Zeichens von x ausgegeben und main (0, {x + 1, y + 1}) aufgerufen.

Führen Sie die beiden Zeichenfolgen als Argumente aus.

C - 164 153 Bytes - 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

Wird aktualisiert, wenn ich wc -c down bekommen kann. Funktioniert eigentlich sehr gut

F #, 211 Zeichen

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

könnte besser sein ...

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

Beispiel:

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

C 164 Bytes

So ziemlich das Implementieren des Algorithmus wie im Problem beschrieben. Nimmt 2 Strings als Eingabeparameter.

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

Rubin, 102

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

Nimmt die ursprünglichen Zeichenfolgen und paart Buchstaben in Arrays. Wenn sie entweder niedriger / kappe oder kappe / niedriger sind, tauschen Sie beide aus. Dann transponieren Sie die Arrays zurück in unser bestelltes Array.

Dies erfordert einen abschließenden Zeilenumbruch in der Eingabe.

Perl 5.10+, 101 99 Bytes

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

96 Bytes + 3 Bytes für die Befehlszeilenflags p00. Nimmt eine einzelne durch Zeilenumbrüche getrennte Zeichenfolge als Eingabe:

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

Oder Sie können eine Eingabe in STDIN eingeben:

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

Heruntergebrochen:

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
'

Erster Versuch in der Waage, 138 Zeichen

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 ist eine Funktion, die die beiden Eingabezeichenfolgen verwendet und die Aufgabe mit einer lokalen Funktion ausführt, die zweimal verwendet wird, um die Groß- und Kleinschreibung von Zeichenfolgen zu ändern.

Derselbe Code mit Einrückung und nur ein bisschen besser lesbaren Namen:

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
} 

Jelly , 13 Bytes

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

Ein monadischer Link, der Listen mit zwei "Strings" (Zeichenlisten in Jelly) akzeptiert und zurückgibt.

Probieren Sie es online!

Python 2 , 97 Bytes

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

Probieren Sie es online!

Tcl , 194 Bytes

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}

Probieren Sie es online!

Haskell , 109 91 Bytes

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

Danke an @Laikoni für 16 Bytes!

Probieren Sie es online!