Cel

To proste wyzwanie. Twoim celem jest rozszyfrowanie łańcucha poprzez zamianę każdej litery na następną literę tej samej sprawy, pozostawiając znaki inne niż litery bez zmian.

Wyjaśnienie krok po kroku

1. Pierwsza postać to E. Następna litera szukamy dużymi literami: to C. Zamieniamy te postacie, co prowadzi do CdoE!.

2. Przechodzimy do następnej postaci: jest to d. Następnej litery szukamy małymi literami: to o. Zamieniamy te postacie, co prowadzi do CodE!.

3. Przechodzimy do następnej postaci: dwłaśnie tu się przeprowadziliśmy. Ignorujemy to, ponieważ zostało już przetworzone.

4. Przechodzimy do następnej postaci: tę Ewłaśnie przeniesiono tutaj w kroku # 1. Ignorujemy to, ponieważ zostało już przetworzone.

5. Przechodzimy do następnej postaci: jest to !. Ignorujemy to, ponieważ to nie jest list.

Zasady

• Możesz założyć, że łańcuch wejściowy składa się wyłącznie z drukowalnych znaków ASCII, w zakresie od 32 do 126.

• Możesz napisać pełny program lub funkcję, która albo wydrukuje, albo zwróci wynik.

• Jeśli ciąg wejściowy zawiera nieparzystą liczbę liter, ostatniej pozostałej litery nie można zamienić na inną i powinien pozostać na miejscu, bez względu na wielkość liter. Ta sama logika ma zastosowanie, jeśli ciąg zawiera parzystą liczbę liter, ale nieparzystą liczbę wielkich liter i nieparzystą liczbę małych liter.

• To jest golf golfowy, więc wygrywa najkrótsza odpowiedź w bajtach. Standardowe luki są zabronione.

Przypadki testowe

Input : lLEhW OroLd!
Output: hELlO WorLd!

Input : rpGOZmaimgn uplRzse naC DEoO LdGf
Output: prOGRamming puzZles anD COdE GoLf

Input : eIt uqHKC RBWOO xNf ujPMO SzRE HTL EOvd yAg
Output: tHe quICK BROWN fOx juMPS OvER THE LAzy dOg

Input : NraWgCi: Nsas-eNEiTIsev rNsiTG!!
Output: WarNiNg: Case-sENsITive sTriNG!!

Niezbyt przypadkowe przypadki testowe:

Input : (^_^)
Output: (^_^)

Input : AWCTY HUOS RETP
Output: WATCH YOUR STEP

Input : hwn oeesd acsp nawyya
Output: who needs caps anyway

Input : SpMycaeIesKyBorekn
Output: MySpaceKeyIsBroken

Input : D's mroyr, Ivam. I'e faardi I act'n od htta.
Output: I'm sorry, Dave. I'm afraid I can't do that.

Galaretka , 21 20 19 18 bajtów

s2UF,
nŒlTÇyJịŒsµ⁺

Wypróbuj online!

Jak to działa

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.
    Ç         Call the helper link. 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.


s2UF,         Helper link. Argument: J (list of indices)

s2            Split J into pairs. If the length is odd, the last list will be
              a singleton list.
  U           Upend; reverse each pair. This is a no-op for singletons lists.
   F          Flatten, concatenating the pairs.
    ,          Pair the previous result with J.

Siatkówka , 53 bajty

Niezbyt sprytne, ale czyste i dość czytelne rozwiązanie

([a-z])(.*?)([a-z])
$3$2$1
([A-Z])(.*?)([A-Z])
$3$2$1

Wypróbuj online!

MATL , 22 bajty

2:"tttk<f2etAZ))P5M(Yo

Wypróbuj online! Lub sprawdź wszystkie przypadki testowe .

Jak to działa

2:"       % Do the following twice
  ttt     %   Input string (implicit). Push three more copies
  k       %   Convert to lowercase
  <f      %   Indices of characters that had their code point increased by
          %   the lowercase conversion, i.e. that were uppercase letters
  2e      %   Convert to 2-row matrix. This pads a zero in the lower-right 
          %   corner if necessary
  tAZ)    %   Keep only columns that don't contain zeros. Thus if there
          %   was a character that can't be swapped it will be ignored             
  )       %   Get 2-row matrix of characters at those positions
  P       %   Flip vertically. This does the swapping
  5M      %   Push matrix of original indices again
  (       %   Write the swapped characters onto their original positions
  Yo      %   Change case. In the first iteration, this prepares the
          %   string so the second iteration will process the letters that
          %   were originally lowercase. In the second iteration, it
          %   undoes the change of case 
          % End (implicit)
          % Display (implicit)

Narzędzia Bash + Unix, 77 62 57 56 54 bajtów

sed -r "s/([$1)([^$1*)([$1)/\3\2\1/g"||$0 a-z]|$0 A-Z]

Wejście w standardowe wejście. Wyjście w standardowym wyjściu.

(W tej ostatniej wersji zdarza się, że napisano również o Stderr, ale wydaje się, że zgoda PPCG jest w porządku - stderr jest po prostu ignorowany. )

Edycja 1: Dzięki @Dennis za 15 bajtów! Ulepszenia: (a) Pobieranie danych wejściowych za pośrednictwem standardowego wejścia; (b) połączenie 2 skryptów sed w jeden; i (c) zastąpienie tr podstawieniem przez rozszerzenie parametru bash; (b) i (c) zniknęły w Edycji 2.

Edycja 2: Krótszy o 5 dodatkowych bajtów. Użyłem wywołania funkcji do zastąpienia zarówno (b), jak i (c) w Edycji 1.

Edycja 3: przekazano jeszcze jeden bajt] jako część argumentów funkcji.

Edycja 4: Zamieniono dwa wywołania funkcji na wywołania samego programu, gdy nie ma on żadnych argumentów.

Wyjście testowe i próbka:

for x in 'lLEhW OroLd!' 'rpGOZmaimgn uplRzse naC DEoO LdGf' 'eIt uqHKC RBWOO xNf ujPMO SzRE HTL EOvd yAg' 'NraWgCi: Nsas-eNEiTIsev rNsiTG!!' '(^_^)' 'AWCTY HUOS RETP' 'hwn oeesd acsp nawyya' 'SpMycaeIesKyBorekn' "D's mroyr, Ivam. I'e faardi I act'n od htta."; do ./swapping <<<"$x" 2>/dev/null; done

hELlO WorLd!
prOGRamming puzZles anD COdE GoLf
tHe quICK BROWN fOx juMPS OvER THE LAzy dOg
WarNiNg: Case-sENsITive sTriNG!!
(^_^)
WATCH YOUR STEP
who needs caps anyway
MySpaceKeyIsBroken
I'm sorry, Dave. I'm afraid I can't do that.

ES6, 185 95 bajtów

i=>(o=[...i]).map((c,j)=>/[a-z]/i.test(c)?o[e=c>"Z"]=1/(b=o[e])?o[o[j]=o[b],b]=c:j:0)&&o.join``

Rozwiązanie znacznie skrócone za pomocą @Neil, @Arnauld i @ edc65

Wyjaśnienie

f = i =>
  // Get array of characters from input string
  (o = [...i])
    .map((c, j) => 
      // Check if it's a text character, otherwise skip it
      /[a-z]/i.test(c) ? 
        // Get last character position for case
        // merged with setting a variable for if the character is lowercase
        // merged with storing the current case character position,  
        // under properties on the array (with keys "true" or "false")
        o[e = c>"Z"] =
          // Check if there exists a character position to switch with
          // merged with storing the current position for quick access
          1/(b=o[e]) ? 
            // This statement will end up returning the Array subset, 
            // which will be falsy in the above conditional since (1/[])==false
            o[
              // Switch left character to the right
              o[j]=o[b]
            // Switch right character to the left
            ,b]=c : 
            // No character exists for case, so return current character position
            j
         // It was not a text character, so do nothing
         :0
      )
  // Join array and return as result
  && o.join``;

`lLEhW OroLd!
NraWgCi: Nsas-eNEiTIsev rNsiTG!!
rpGOZmaimgn uplRzse naC DEoO LdGf
eIt uqHKC RBWOO xNf ujPMO SzRE HTL EOvd yAg
(^_^)
AWCTY HUOS RETP
hwn oeesd acsp nawyya
SpMycaeIesKyBorekn
D's mroyr, Ivam. I'e faardi I act'n od htta`
  .split`\n`
  .map(testCase => console.log(f(testCase)));

Python , 82 bajty

lambda s:S(r.lower(),t,S(r,t,s))
import re
S=re.sub
r='([A-Z])(.*?)'*2
t=r'\3\2\1'

Wypróbuj online!

QBasic, 229 bajtów

LINE INPUT s$
FOR i=1TO LEN(s$)
c$=MID$(s$,i,1)
IF"@"<c$AND"[">c$THEN
IF u THEN MID$(s$,u,1)=c$:MID$(s$,i,1)=u$
u=-i*(u=0)
u$=c$
ELSEIF"`"<c$AND"{">c$THEN
IF l THEN MID$(s$,l,1)=c$:MID$(s$,i,1)=l$
l=-i*(l=0)
l$=c$
END IF
NEXT
?s$

Strategia

Zapętlamy ciąg wejściowy. Kiedy napotykamy wielką literę, przechowujemy ją i jej pozycję. Za drugim razem, gdy napotykamy wielką literę, używamy przechowywanych wartości, aby zamienić ją na poprzednią. To samo dotyczy małych liter.

( MID$(strng$, index, length) = replacement$Właśnie miałem opublikować dłuższą wersję, która używała tablicy, ponieważ myślałem, że ciągi QBasic są niezmienne. Potem natknąłem się na fakt, że działa dobrze. Żyj i ucz się.)

Ungolfed + skomentował

LINE INPUT text$

FOR i = 1 TO LEN(text$)
  char$ = MID$(text$, i, 1)
  IF "A" <= char$ AND "Z" >= char$ THEN
    ' Uppercase
    IF upperIndex = 0 THEN
      ' This is the first of a pair of uppercase letters
      ' Store the letter and its index for later
      upperLetter$ = char$
      upperIndex = i
    ELSE
      ' This is the second of a pair of uppercase letters
      ' Put it at the position of the previous uppercase letter
      ' and put that letter at this letter's position
      MID$(text$, upperIndex, 1) = char$
      MID$(text$, i, 1) = upperLetter$
      upperIndex = 0
    END IF
  ELSEIF "a" <= char$ AND "z" >= char$ THEN
    ' Lowercase
    IF lowerIndex = 0 THEN
      ' This is the first of a pair of lowercase letters
      ' Store the letter and its index for later
      lowerLetter$ = char$
      lowerIndex = i
    ELSE
      ' This is the second of a pair of lowercase letters
      ' Put it at the position of the previous lowercase letter
      ' and put that letter at this letter's position
      MID$(text$, lowerIndex, 1) = char$
      MID$(text$, i, 1) = lowerLetter$
      lowerIndex = 0
    END IF
  END IF
NEXT i

PRINT text$

C ++ 11 (GCC), 154 149 bajtów

#include<algorithm>
[](std::string s){int*p,u,l=u=-1;for(auto&c:s)(c|32)-97<26U?p=&(c&32?u:l),~*p?(std::swap(c,s[*p]),*p=-1):*p=&c-&s[0]:0;return s;}

Qbasic, 436 408 bajtów

LINE INPUT a$:b=len(a$):FOR a=1TO b:t$=MID$(a$,a,1)
IF"@"<t$AND"[">t$THEN
b$=b$+"U":u$=u$+t$
ELSEIF"`"<t$AND"{">t$THEN
b$=b$+"L":l$=l$+t$
ELSE b$=b$+t$
END IF:NEXT
FOR x=1TO b STEP 2:g$=g$+MID$(u$,x+1,1)+MID$(u$,x,1):h$=h$+MID$(l$,x+1,1)+MID$(l$,x,1):NEXT
FOR x=1TO b:t$=MID$(b$,x,1)
IF"U"=t$THEN
u=u+1:z$=z$+MID$(g$,u,1)
ELSEIF"L"=t$THEN l=l+1:z$=z$+MID$(h$,l,1)
ELSE z$=z$+t$
END IF:NEXT:?z$

Oszczędność jednego bajtu dzięki DLosc. Zaoszczędziłem kilka innych, zmieniając obsługę znaków nieliterowych.

Zasadniczo składa się z trzech części:

• Dzielenie danych wejściowych na 3 ciągi znaków (wielkie litery, małe litery i mapa (również z innymi znakami))
• Odwracanie wielkich i małych liter
• Używanie mapy do (re) konstruowania danych wyjściowych.

Bardziej szczegółowe wyjaśnienie (zauważ, że jest to wcześniejsza wersja kodu, ale zasada nadal obowiązuje):

' --- Part I: Reading the input
LINE INPUT a$
'This FOR loop takes one character at a time
b=len(a$):FOR a=1TO b
' And checks in what category the character belongs
t$=MID$(a$,a,1):SELECT CASE t$
' For each group, char t$ is added to that group (u$ for uppercase, 
' l$ for lowercase. The map in b$ is updated with a U or L on this index,
' or with the non-letter char t$.
CASE"A"TO"Z":b$=b$+"U":u$=u$+t$
CASE"a"TO"z":b$=b$+"L":l$=l$+t$
CASE ELSE:b$=b$+t$
END SELECT:NEXT

' --- Part II: Swapping within case-groups
' Loop through u$ and l$ twp chars at a time, and add those chunks in reverse order
' to g$ and h$. Because mid$ doesn't fail past the end of a string (but returns ""), 
' this automatically compensates for odd-length groups.
FOR x=1TO b STEP 2:g$=g$+MID$(u$,x+1,1)+MID$(u$,x,1):h$=h$+MID$(l$,x+1,1)+MID$(l$,x,1):NEXT

' --- Part III: Read the map to put it all back together
FOR x=1TO b:t$=MID$(b$,x,1)
' See what group was in this spot, then read the next char from the flipped string.
' This keeps an index on those strings for the next lookup.
IF t$="U"THEN
u=u+1:z$=z$+MID$(g$,u,1)
ELSEIF t$="L"THEN l=l+1:z$=z$+MID$(h$,l,1)
' The map contains a non-letter char, just drop that in
ELSE z$=z$+t$
' And finally,display the end result.
END IF:NEXT:?z$

PHP, 108 93 83 bajty

<?=preg_replace([$a="/([a-z])([^a-z]*)([a-z])/",strtoupper($a)],"$3$2$1",$argv[1]);

Poprzednia wersja (93 bajty)

<?=preg_replace(["/([a-z])([^a-z]*)([a-z])/","/([A-Z])([^A-Z]*)([A-Z])/"],"$3$2$1",$argv[1]);

Dzięki @ user59178 za przypomnienie, że preg_replace()mogę traktować tablice ciągów jako argumenty.

Oryginalna odpowiedź (108 bajtów)

$f=preg_replace;echo$f("/([a-z])([^a-z]*)([a-z])/",$r="$3$2$1",
$f("/([A-Z])([^A-Z]*)([A-Z])/",$r,$argv[1]));

Kod jest zawinięty tutaj, aby zmieścił się w dostępnej przestrzeni.
Można go wykonać z wiersza poleceń:

$ php -d error_reporting=0 -r '$f=preg_replace;echo$f("/([a-z])([^a-z]*)([a-z])/",$r="$3$2$1",$f("/([A-Z])([^A-Z]*)([A-Z])/",$r,$argv[1]));' 'lLEhW OroLd!'

1-bajtowa krótsza wersja jest możliwa na PHP 7, ściskając przypisanie $fwewnątrz pierwszego wywołania:

echo($f=preg_replace)("/([a-z])([^a-z]*)([a-z])/",$r="$3$2$1",
$f("/([A-Z])([^A-Z]*)([A-Z])/",$r,$argv[1]));

Oba rozwiązania, przypadki testowe i wersje bez golfa, można znaleźć na Github .

Mathematica, 96 bajtów

s[#,r="([a-z])(.*?)([a-z])"]~(s=StringReplace[#,RegularExpression@#2->"$3$2$1"]&)~ToUpperCase@r&

Port odpowiedzi Retina Leo , która używa wyrażeń regularnych.

Python 2 , 124 bajty

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

Nie tak krótkie jak moje rozwiązanie oparte na wyrażeniach regularnych , ale myślę, że wciąż jest interesujące.

Wypróbuj online!

Fasola , 83 bajty

Hexdump:

00000000 26 53 d0 80 d3 d0 80 a0 5d 20 80 0a a1 81 81 00  &SÐ.ÓÐ. ] ..¡...
00000010 23 81 01 20 80 0a a1 81 81 02 23 81 01 a8 db c1  #.. ..¡...#..¨ÛÁ
00000020 ad da dd a9 a8 db de c1 ad da dd aa bf a9 a8 db  .ÚÝ©¨ÛÞÁ.Úݪ¿©¨Û
00000030 c1 ad da dd 29 a4 b3 a4 b2 a4 31 a8 db e1 ad fa  Á.ÚÝ)¤³¤²¤1¨Ûá.ú
00000040 dd a9 a8 db de e1 ad fa dd aa bf a9 a8 db e1 ad  Ý©¨ÛÞá.úݪ¿©¨Ûá.
00000050 fa dd 29                                         úÝ)
00000053

Odpowiednik JavaScript:

a.replace(/([A-Z])([^A-Z]*?)([A-Z])/g,'$3$2$1').replace(/([a-z])([^a-z]*?)([a-z])/g,'$3$2$1')

Wyjaśnienie:

Niejawnie przyjmuje pierwszy wiersz danych wejściowych jako niesformatowany jako a(ponieważ znaki nowej linii nie mogą być częścią zaszyfrowanego łańcucha) i domyślnie wyprowadza nieszyfrowany ciąg przez sekwencyjne zastępowanie wielkich i następnie małych liter.

Wypróbuj wersję demo tutaj.

Wypróbuj pakiet testowy tutaj.

Ruby, 81 bajtów

puts f=->(i,s){i.gsub /([#{s})([^#{s}*)([#{s})/,'\3\2\1'}[f[$*[0],'a-z]'],'A-Z]']

JavaScript (ES6), 80 bajtów

Na podstawie odpowiedzi Leo's Retina .

s=>eval("s"+(r=".replace(/([A-Z])([^A-Z]*)([A-Z])/g,'$3$2$1')")+r.toLowerCase())

Działa to, ponieważ jedynymi dużymi znakami w kodzie .replace(/([A-Z])([^A-Z]*)([A-Z])/g,'$3$2$1')są Ai Z, które służą do opisu zakresów znaków. Właśnie tego potrzebujemy przekształcić na małe litery, aby przetworzyć drugie przejście.

Przypadki testowe

let f =

s=>eval("s"+(r=".replace(/([A-Z])([^A-Z]*)([A-Z])/g,'$3$2$1')")+r.toLowerCase())

console.log(f("lLEhW OroLd!"));
console.log(f("rpGOZmaimgn uplRzse naC DEoO LdGf"));
console.log(f("eIt uqHKC RBWOO xNf ujPMO SzRE HTL EOvd yAg"));
console.log(f("NraWgCi: Nsas-eNEiTIsev rNsiTG!!"));
console.log(f("(^_^)"));
console.log(f("AWCTY HUOS RETP"));
console.log(f("hwn oeesd acsp nawyya"));
console.log(f("SpMycaeIesKyBorekn"));
console.log(f("D's mroyr, Ivam. I'e faardi I act'n od htta."));

ES6 155–195 bajtów

Wiem, że jest już lepsza odpowiedź, ale chciałem spróbować bez wyrażenia regularnego. Ten działa również na interpunkcji, ale wydaje się, że to narusza (^_^)test. W takim przypadku mam inną c()funkcję, podaną poniżej.

f=(s)=>{d={};s=[...s];for(i in s){b=s[i];for(j in s)if(i<j&!d[i]&c(s[j])==c(b)){d[j]=1;s[i]=s[j];s[j]=b;break}}return s.join('')}
c=c=>~(c.charCodeAt()/32)

f("M I'o DaG") //> I'M a GoD
f("(^_^)")     //> )_^^(

c=c=>((c!=c.toUpperCase())<<1|c!=c.toLowerCase())||c.charCodeAt()

f("M I'o DaG") //> I'M a GoD
f("(^_^)")     //> (^_^)

Wyjaśnienie

f=(s)=>{
    d={};        //list of indexes already swapped
    s=[...s];        //string to array, stolen from above ES6 answer
    for(i in s){
        b=s[i];        //keep a note of what we are swapping
        for(j in s)        //iterate over the array again
            if( i<j & !d[i] & c(s[j])==c(b) ){
                        //only pay attention after we pass i'th
                        //only swap if this char hasn't been swapped
                        //only swap if both chars in same 'category'
                d[j]=1;        //note that the latter char has been swapped
                s[i]=s[j];
                s[j]=b;
                break        //avoid swapping on the same 'i' twice
            }
    }
    return s.join('')        //return as string
}

Perl 6 , 56 bajtów

{for "A".."Z","a".."z" ->@c {s:g/(@c)(.*?)(@c)/$2$1$0/}}

Bierze zmienną łańcuchową jako argument i modyfikuje ją w miejscu, aby po wywołaniu lambda zmienna zawierała wynik.

Dłuższy niż w Perlu, ponieważ:

• Nowa składnia wyrażenia regularnego jest bardziej szczegółowa, np. Zapisywanie klas znaków wyglądałoby <[A..Z]>zamiast [A-Z].
• Regeksy są pierwszorzędnym kodem źródłowym analizowanym w czasie kompilacji, a ciąg może być interpolowany do nich w czasie wykonywania tylko wtedy, gdy składa się z samodzielnego podregexu (tzn. Nie można interpolować ciągu znaków do klasy znaków).
• Wyjaśnienie EVAL, które pozwoliłoby na większą elastyczność, wymaga nieprzyjaznej golfowi pragmy use MONKEY-SEE-NO-EVAL;.

Po stronie plus do tablicy w @zmiennej można odwoływać się bezpośrednio w wyrażeniu regularnym i jest ona traktowana jako alternatywa.

Perl 6 , 65 bajtów

{reduce ->$_,@c {S:g/(@c)(.*?)(@c)/$2$1$0/},$_,"A".."Z","a".."z"}

Wersja funkcjonalna (zwraca wynik jako wartość zwracaną lambda).

R, 343 bajtów

Strasznie niezdarne rozwiązanie R:

f <- function(x) {
        y=unlist(strsplit(x,""))
        z=data.frame(l=ifelse(y %in% letters,0,ifelse(y %in% LETTERS,1,2)),s=y)
        l <- list(which(z$l==0),which(z$l==1))
        v <- unlist(l)
        for(j in 1:2) for (i in seq(1,ifelse(length(l[[j]])%%2==1,length(l[[j]])-2,length(l[[j]])-1),2)) l[[j]][i:(i+1)] <- rev(l[[j]][i:(i+1)])
        z[v,] <- z[unlist(l),]
        return(z$s)
    }

f("D's mroyr, Ivam. I'e faardi I act'n od htta.")

# [1] I ' m   s o r r y ,   D a v e .   I ' m   a f r a i d   I   c a n ' t   d o   t h a t .

Python 2, 181 bajtów

Znacznie dłużej niż powinno, ale i tak:

def F(s):
 for l in[i for i,c in enumerate(s)if c.isupper()],[i for i,c in enumerate(s)if c.islower()]:
  for a,b in zip(l[0::2],l[1::2]):s=s[:a]+s[b]+s[a+1:b]+s[a]+s[b+1:]
 print s

To najpierw tworzy dwie listy: jeden z indeksów wielkich liter i jeden dla małych liter. Każda z tych list jest zapętlona w parach indeksów, a znaki w tych indeksach są zamieniane.

Jutro zagram w golfa , ale teraz czas na sen .

Pip , 28 bajtów

Y[XLXU]aRy.`.*?`.y{Sa@0a@va}

Pobiera dane wejściowe jako argument wiersza polecenia. Wypróbuj online!

Wyjaśnienie

Jest to rozwiązanie wyrażenia regularnego, wykorzystujące wbudowane zmienne wyrażenia regularnego XL(małe litery `[a-z]`) i XU(wielkie litery `[A-Z]`).

                              a is 1st cmdline arg; v is -1 (implicit)
Y[XLXU]                       Yank a list containing XL and XU into y
         y.`.*?`.y            Concatenate y, `.*?`, and y itemwise, giving this list:
                              [`[a-z].*?[a-z]`; `[A-Z].*?[A-Z]`]
       aR                     In a, replace matches of each regex in that list...
                  {        }  ... using this callback function:
                   Sa@0a@v     Swap the 0th and -1st characters of the match
                          a    and return the resulting string
                              Print (implicit)

Gdy drugim argumentem Rjest lista, zamiany są wykonywane szeregowo; tak więc zamiana małych liter i zamiana wielkich liter nie kolidują ze sobą.

Perl 5 , 48 + 1 (-p) = 49 bajtów

for$p(qw/([a-z]) ([A-Z])/){s/$p(.*?)$p/$3$2$1/g}

Wypróbuj online!

AWK , 121 129 bajtów

BEGIN{FS=OFS=""}{for(a=1;a<=NF;a++){if($a~/[A-Z]/?U>0?p=U+(U=0):0*(U=a):$a~/[a-z]/?L>0?p=L+(L=0):0*(L=a):0>0){t=$a;$a=$p;$p=t}}}1

Wypróbuj online! Uwaga: Link ma 8 dodatkowych bajtów, aby umożliwić wejście wielowierszowe

Użycie jest dość typowe, ale wymaga wersji, AWKktóra akceptuje pusty ciąg znaków jako separator pól (większość wersji, gawkale jestem prawie pewien, że oryginał się AWKnie powiedzie :()

Jest to bardzo proste, ponieważ po prostu iteruje każdą postać i sprawdza, czy wcześniej znalazła jedną z takich spraw. Jeśli tak, zamienia znaki i resetuje zaznaczony indeks. Po stronie uczenia się nigdy wcześniej nie użyłem instrukcji przypisania w instrukcji przypisania AWK. Z jakiegoś powodu nigdy się nie pojawiło. :)

Mogę być w stanie ogolić kilka bajtów, mówiąc o przypisaniu OFS i FS poza BEGINblok za pomocą przypisania z wiersza poleceń lub podobnego, ale w ten sposób jest „czystszy”.

Dodanie linku TIO pokazało mi, że mam błąd transkrypcji, który wymagał naprawy 8 bajtów :( (Pominąłem 0*(U=a):)

C (gcc) , 212 206 bajtów

• Dzięki pułapowi do gry w golfa sześć bajtów.

#define I(a,b)if(S[j=i]>=a&S[i]<-~b){for(;S[++j]<a|S[j]>b;);j<l?s[i]=S[j],s[j]=S[i]:0;}
i,j,l;f(char*S){char*s=calloc(l=-~strlen(S),1);for(i=~0;++i<strlen(S);)if(!s[i]){s[i]=S[i];I(65,90)I(97,'z')}puts(s);}

Wypróbuj online!

Stax , 18 bajtów

âß:}\]ó☺æ■jφ╛jz/Φi

Uruchom i debuguj

Ogólne podejście opiera się na wyrażeniach regularnych.

• Dwa razy:
• Znajdź wszystkie dopasowania dla [a-z].*?[a-z].
• Zamień pierwszą i ostatnią postać w meczach.
• Odwróć przypadek.

R , 223 163 bajty 148 bajtów

EDYCJA: -60 bajtów poprzez implementację pętli for

EDYCJA: -15 bajtów od Giuseppe

u=utf8ToInt(scan(,''));for(i in c(65,97)){l=which(u%in%i:(i+25));x=sum(l|1)%/%2;u[l[1:(x*2)]]=u[c(matrix(l,2)[2:1,1:x])]};cat(intToUtf8(u,T),sep="")

Wypróbuj online!

Działa poprzez testowanie, czy znak jest małą lub wielką literą, umieszcza je w macierzy, odwraca macierz, aby wyodrębnić wartości w formacie zamienionym. Następnie wyślij za pomocą cat. Wypróbuj go online, scan(,'')gdy kod ma więcej niż jedną linię, stąd średniki w całym wierszu kodu.

Java 7, 117 bajtów

String c(String s){String x="([a-z])(.*?)([a-z])",y="$3$2$1";return s.replaceAll(x,y).replaceAll(x.toUpperCase(),y);}

EDYCJA: Właśnie zauważyłem, że mam podobną odpowiedź jak odpowiedź Retina @Leo , mimo że myślałem o tym niezależnie.

Nie golfowany:

String c(final String s) {
  String x = "([a-z])(.*?)([a-z])",
         y = "$3$2$1";
  return s.replaceAll(x, y).replaceAll(x.toUpperCase(), y);
}

Kod testowy:

Wypróbuj tutaj.

class M{
  static String c(String s){String x="([a-z])(.*?)([a-z])",y="$3$2$1";return s.replaceAll(x,y).replaceAll(x.toUpperCase(),y);}

  public static void main(String[] a){
    System.out.println(c("lLEhW OroLd!"));
    System.out.println(c("rpGOZmaimgn uplRzse naC DEoO LdGf"));
    System.out.println(c("eIt uqHKC RBWOO xNf ujPMO SzRE HTL EOvd yAg"));
    System.out.println(c("NraWgCi: Nsas-eNEiTIsev rNsiTG!!"));
    System.out.println(c("(^_^)"));
    System.out.println(c("AWCTY HUOS RETP"));
    System.out.println(c("hwn oeesd acsp nawyya"));
    System.out.println(c("SpMycaeIesKyBorekn"));
    System.out.println(c("D's mroyr, Ivam. I'e faardi I act'n od htta."));
  }
}

Wynik:

hELlO WorLd!
prOGRamming puzZles anD COdE GoLf
tHe quICK BROWN fOx juMPS OvER THE LAzy dOg
WarNiNg: Case-sENsITive sTriNG!!
(^_^)
WATCH YOUR STEP
who needs caps anyway
MySpaceKeyIsBroken
I'm sorry, Dave. I'm afraid I can't do that.