Inspiriert von dieser Herausforderung (oder genauer gesagt durch falsches Lesen) habe ich die folgende Herausforderung gefunden:

Wenn Sie eine Eingabezeichenfolge S haben, kehren Sie die Reihenfolge aller Groß- und Kleinbuchstaben um. Belassen Sie alle Zeichen, die keine Buchstaben sind. Zum Beispiel:

Beachten Sie, dass der Großbuchstabe W(der erste Großbuchstabe) durch H(den letzten) ersetzt wurde. Gleiches gilt für die Kleinbuchstaben: 'd' (der erste) wird durch e(der letzte) ersetzt, l(der zweite) durch l(der letzte) ... Alle Nichtbuchstaben bleiben an Ort und Stelle.

Eingang

• Die Eingabe ist eine Zeichenfolge mit nur ASCII-Zeichen im Bereich 32-126.
• Die Eingabe ist garantiert mindestens 1 Zeichen lang und überschreitet nicht das Limit Ihrer Sprache.

Ausgabe

• Dieselbe Zeichenfolge, wobei die Zeichen wie beschrieben vertauscht wurden.

Zusätzliche Regeln

• Standardlücken sind verboten
• Die Antwort muss ein vollständiges Programm oder eine Funktion sein, kein Snippet oder ein REPL-Eintrag.
• Code-Golf , die kürzeste Antwort in Bytes gewinnt.

Testfälle

A
A

Ok
Ok

OK
KO

Hello, World!
Wdlro, Holle!

0123456789
0123456789

The quick brown Fox jumps over the lazy doge
Feg odyza lehtr Tev ospmu jxon wor bkci uqeh

odd
ddo

racecar
racecar

EtOn Em OsN R AaToNsIsIhT!!1!
ThIs Is NoT A RaNsOmEnOtE!!1!

MATL , 14 Bytes

2:"t@Y2myy)Pw(

Probieren Sie es bei MATL Online aus

Erläuterung

        % Impicitly grab input as a string
2:      % Push the array [1, 2] to the stack
"       % For each value in this array
  t     % Duplicate the top element of the stack (S)
  @     % Get the current loop index
  Y2    % Load the predefined literal 1Y2 ('ABC...Z') on the first loop
        % and the predefined literal 2Y2 ('abc...z') on the second loop (M)
  m     % Create a logical array the length of S that is TRUE when a character is in the
        % array M and FALSE otherwise (B)
  yy    % Make a copy of both S and B
  )     % Grab just the letters of S that were in M using B as an index
  P     % Reverse this array
  w     % Flip the top two stack elements
  (     % Assign them back into the string
        % Implicit end of for loop and implicit display

Netzhaut , 19 Bytes

Retina hat keine direkte Möglichkeit, einen String umzukehren, aber wir können dies tun, indem wir die Sortierstufe ausnutzen:

O^#`[a-z]
O^#`[A-Z]

Sortieren ( O), sie als Zahlen lesen ( #) und dann die Reihenfolge umkehren (^ ) aller Zeichenfolgen um, die mit der angegebenen Regex übereinstimmen (Kleinbuchstaben für die erste Zeile und Großbuchstaben für die zweite Zeile).

Dies funktioniert, weil beim Versuch, Zeichenfolgen ohne numerische Zeichen als Zahlen zu lesen, diese wie folgt behandelt werden 0 , sodass alle Zeichen den gleichen Wert für die Sortierung haben. Da die Sortierung stabil ist, werden sie in derselben Reihenfolge belassen, und beim Umkehren wird die ursprüngliche Zeichenfolge umgekehrt zurückgegeben.

Probieren Sie es online!

Perl , 45 Bytes

44 Byte Code + -pFlag.

for$c(u,l){@T=/\p{L$c}/g;s/\p{L$c}/pop@T/ge}

Probieren Sie es online!

Unicode-Zeichen werden klassifiziert \p{Lu}und \p{Ll}entsprechen Groß- und Kleinbuchstaben.
So /\p{L$c}/wird die Liste aller Groß- (oder Kleinbuchstaben) zurückgegeben (und darin gespeichert @T).
Und dann ersetzt der reguläre Ausdruck s/\p{$c}/pop@T/gejeden Buchstaben (Groß- und Kleinbuchstaben) durch den letzten Buchstaben von, @Twährend er von entfernt wird @T.

JavaScript (ES6), 74 73 71 70 Byte

f=
s=>(g=r=>s=s.replace(r,_=>a.pop(),a=s.match(r)))(/[A-Z]/g,g(/[a-z]/g))

<input oninput=o.textContent=f(this.value)><pre id=o>

Bearbeiten: 1 Byte dank @Arnauld gespeichert.

JavaScript (ES6), 92 Byte

s=>(F=(r,s)=>s.replace(r,([x],a,y)=>y+F(r,a)+x))(/[a-z](.*)([a-z])/,F(/[A-Z](.*)([A-Z])/,s))

Es hat bekam ein Weg , um die Vorteile der Ähnlichkeit zwischen dem regulären Ausdrücken sein ...

Testschnipsel

let f =
s=>(F=(r,s)=>s.replace(r,([x],a,y)=>y+F(r,a)+x))(/[a-z](.*)([a-z])/,F(/[A-Z](.*)([A-Z])/,s))

<input style="width:500px" value="Wdlro, Holle!" oninput="O.value=f(this.value)"><br>
<input style="width:500px" value="Hello, World!" id=O disabled>

Perl 6 , 75 69 Bytes

{my @a=.comb;@(grep $_,@a).&{@$_=[R,] $_} for /<:Lu>/,/<:Ll>/;[~] @a}

Wie es funktioniert

1. my @a=.comb;
   Teilen Sie die Zeichenfolge in Zeichen auf und speichern Sie sie in einem Array.

2. for /<:Lu>/,/<:Ll>/
   Für zwei Regexes, die mit Groß- und Kleinbuchstaben übereinstimmen ...

   • @(grep $_,@a)
     Holen Sie sich einen Ausschnitt aller Array-Einträge, die dem regulären Ausdruck entsprechen.

   • .&{@$_=[R,] $_}
     Weisen Sie sich die Rückseite des Slice zu.

3. [~] @a
   Verketten Sie das geänderte Array, um erneut eine Zeichenfolge zu bilden, und geben Sie sie zurück.

-6 Bytes durch Diebstahl der Idee, Unicode-Klassen anstelle von Zeichenbereichen zu verwenden, aus der @ Dada-Lösung.

Jelly, 14 bytes

nŒlT,Ṛ$yJịŒsµ⁺

Try it online!

How it works

nŒlT,Ṛ$yJịŒsµ⁺  Main link. Argument: s (string)

 Œl             Convert to lowercase.
n               Test for inequality.
   T            Truth; yield all indices of 1's.
    ,Ṛ$         Pair with its reverse. Yields [A, B] (pair of lists).
        J       Indices; yield I := [1, ..., len(s)].
       y        Translate; replace the integers of I that occur in A with the
                corresponding integers in B.
          Œs    Swapcase; yield s with swapped case.
         ị      Use the translated index list to index into s with swapped case.
            µ   Combine all links to the left into a chain.
             ⁺   Duplicate the chain, executing it twice.

Bash + Unix utilities, 122 121 bytes

f()(p=[^$1*
v="\)\([$1\)\("
for((n=99;n;n--)){
q="$q;s/^\($p$v.*$v$p\)$/\1\4\3\2\5/"
p=[^$1*[$1$p
}
sed $q)
f a-z]|f A-Z]

Try it online!

Not really very short; maybe someone can golf it further.

Input on stdin, output on stdout.

This will work correctly on inputs of less than 200 characters.

(Actually it correctly handles any string with fewer than 200 lower-case letters and fewer than 200 upper-case letters.)

If you increase the 99 in the code to 102 (at the cost of one additional byte), it will handle strings up to 205 characters.

However, you can't increase the 99 in the code beyond 102 since you'll then exceed sed's maximum argument length.

Here's a version without any particular input size limitation, but the count is a little longer, 137 bytes. (This longer version writes to an auxiliary file named t.)

f()(p=[^$1*
v="\)\([$1\)\("
for((n=`wc -c<t`;n;n--)){
sed -i "s/^\($p$v.*$v$p\)$/\1\4\3\2\5/" t
p=[^$1*[$1$p
})
cat>t
f a-z]
f A-Z]
cat t

Test runs:

for x in A Ok OK 'Hello, World!' 0123456789 'The quick brown Fox jumps over the lazy doge' odd racecar 'EtOn Em OsN R AaToNsIsIhT!!1!'
  do
    echo "$x"
    ./swapping3 <<<"$x"
    echo
  done

A
A

Ok
Ok

OK
KO

Hello, World!
Wdlro, Holle!

0123456789
0123456789

The quick brown Fox jumps over the lazy doge
Feg odyza lehtr Tev ospmu jxon wor bkci uqeh

odd
ddo

racecar
racecar

EtOn Em OsN R AaToNsIsIhT!!1!
ThIs Is NoT A RaNsOmEnOtE!!1!

Python 2, 115 bytes

s=input();u=str.isupper
exec"r='';i=0\nfor c in s:r+=c[u(c):]or filter(u,s)[~i];i+=u(c)\ns=r.swapcase();"*2
print s

Try it online!

Java (OpenJDK 8), 271 bytes

s->new String(new Error(){char[]o=s.toCharArray();char c;int b;{while(b++<2)for(int l=0,r=o.length;l<r;l++){for(--r;r>l&&f(r);r--);for(;l<r&&f(l);l++);if(l<r){o[l]=o[r];o[r]=c;}}}boolean f(int i){c=o[i];return b>1?!Character.isUpperCase(c):!Character.isLowerCase(c);}}.o)

Try it online!

R, 107 bytes

u=utf8ToInt(scan(,''));for(i in c(65,97)){l=which(u%in%i:(i+25));u[l]=u[rev(l)]};cat(intToUtf8(u,T),sep="")

Adapted from my response to the linked challenge. This is considerably easier than just swapping pairs. I wonder if I could get sub 100 with some golfs...

Try it online!