Obbiettivo

Questa è una sfida semplice. Il tuo obiettivo è di decodificare una stringa scambiando ogni lettera con la lettera successiva dello stesso caso, lasciando invariati i caratteri non lettera.

Spiegazione dettagliata

1. Il primo personaggio è a E. Cerchiamo la lettera successiva in maiuscolo: è a C. Scambiamo questi personaggi, il che porta a CdoE!.

2. Passiamo al personaggio successivo: questo è un d. Cerchiamo la lettera successiva in minuscolo: è a o. Scambiamo questi personaggi, il che porta a CodE!.

3. Passiamo al personaggio successivo: questo è quello dche ci siamo appena trasferiti qui. Lo ignoriamo perché è già stato elaborato.

4. Passiamo al personaggio successivo: questo è quello Eche è stato spostato qui al passaggio # 1. Lo ignoriamo perché è già stato elaborato.

5. Passiamo al personaggio successivo: questo è un !. Lo ignoriamo, perché non è una lettera.

Regole

• Si può presumere che la stringa di input sia composta esclusivamente da caratteri ASCII stampabili, nell'intervallo 32-126.

• È possibile scrivere un programma completo o una funzione, che stampa o restituisce il risultato.

• Se la stringa di input contiene un numero dispari di lettere, l'ultima lettera rimanente non può essere scambiata con un'altra e deve rimanere al suo posto, indipendentemente dal caso. La stessa logica si applica se la stringa contiene un numero pari di lettere, ma un numero dispari di lettere maiuscole e un numero dispari di lettere minuscole.

• Questo è code-golf, quindi vince la risposta più breve in byte. Sono vietate le scappatoie standard.

Casi test

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

Casi di test non casuali:

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.

Gelatina , 21 20 19 18 byte

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

Provalo online!

Come funziona

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.

Retina , 53 byte

Non molto intelligente, ma una soluzione pulita e abbastanza leggibile

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

Provalo online!

MATL , 22 byte

2:"tttk<f2etAZ))P5M(Yo

Provalo online! Oppure verifica tutti i casi di test .

Come funziona

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)

Utilità Bash + Unix, 77 62 57 56 54 byte

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

Ingresso in stdin. Uscita in stdout.

(In quest'ultima versione, anche stderr sembra essere scritto, ma il consenso di PPCG sembra essere quello che va bene - stderr viene semplicemente ignorato. )

Modifica 1: grazie a @Dennis per 15 byte! Miglioramenti: (a) Ricezione di input tramite stdin; (b) combinare 2 script sed in uno; e (c) sostituire tr con la sostituzione tramite espansione del parametro bash; (b) e (c) sono scomparsi in Modifica 2.

Modifica 2: più breve di 5 byte aggiuntivi. Utilizzata una chiamata di funzione per sostituire sia (b) che (c) in Modifica 1.

Modifica 3: ancora un byte - passato] come parte degli argomenti della funzione.

Modifica 4: sostituite le due chiamate di funzione con chiamate al programma stesso quando non ha argomenti.

Testbed e output del campione:

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 byte

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

Soluzione notevolmente ridotta con l'aiuto di @Neil, @Arnauld e @ edc65

Spiegazione

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 byte

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

Provalo online!

QBasic, 229 byte

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

Passiamo attraverso la stringa di input. Quando incontriamo una lettera maiuscola, la memorizziamo e la sua posizione. La seconda volta che incontriamo una lettera maiuscola, usiamo quei valori memorizzati per scambiarla con quella precedente. Lo stesso vale per le lettere minuscole.

(Stavo per pubblicare una versione piuttosto lunga che utilizzava un array, perché pensavo che le stringhe QBasic fossero immutabili. Poi mi sono imbattuto nel fatto che MID$(strng$, index, length) = replacement$funziona perfettamente. Vivi e impara.)

Ungolfed + commentato

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 byte

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

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$

Salvato un byte grazie a DLosc. Ne ho salvati molti altri cambiando la gestione dei caratteri non lettera.

Fondamentalmente si compone di tre parti:

• Dividere l'input in 3 stringhe (maiuscole, minuscole e una mappa (tenendo anche gli altri caratteri))
• Capovolgere le lettere maiuscole e minuscole
• Utilizzo della mappa per (ri) costruire l'output.

Una spiegazione più dettagliata (si noti che si tratta di una versione precedente del codice, ma il principio si applica ancora):

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

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

Versione precedente (93 byte)

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

Grazie a @ user59178 per avermi ricordato che preg_replace()può prendere matrici di stringhe come argomenti.

La risposta originale (108 byte)

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

Il codice è racchiuso qui per adattarsi allo spazio disponibile.
Può essere eseguito dalla riga di comando:

$ 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!'

Una versione più corta di 1 byte è possibile su PHP 7 premendo l'assegnazione $fall'interno della sua prima chiamata:

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

Entrambe le soluzioni, con casi di test e versioni non giocate, sono disponibili su Github .

Mathematica, 96 byte

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

Un port della risposta Retina di Leo , che utilizza espressioni regolari.

Python 2 , 124 byte

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

Non è breve come la mia soluzione basata su regex , ma penso che sia ancora interessante.

Provalo online!

Fagiolo , 83 byte

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

JavaScript equivalente:

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

Spiegazione:

Prendendo implicitamente la prima riga di input non formattata come a(poiché le nuove righe non possono far parte della stringa codificata) e genera implicitamente la stringa non codificata sostituendo sequenzialmente coppie maiuscole e minuscole.

Prova la demo qui.

Prova qui la suite di test.

Rubino, 81 byte

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

JavaScript (ES6), 80 byte

Basato sulla risposta di Retina di Leo .

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

Ciò funziona perché gli unici caratteri maiuscoli nel codice .replace(/([A-Z])([^A-Z]*)([A-Z])/g,'$3$2$1')sono Ae Z, utilizzati per descrivere gli intervalli di caratteri. Questo è esattamente ciò che dobbiamo trasformare in minuscolo per elaborare il secondo passaggio.

Casi test

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 byte

So che c'è già una risposta migliore, ma volevo provare senza regex. Questo funziona anche sulla punteggiatura, ma sembra violare il (^_^)test. In tal caso, ho un'altra c()funzione, indicata di seguito.

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("(^_^)")     //> (^_^)

Spiegazione

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 byte

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

Prende una variabile stringa come argomento e la modifica sul posto in modo che dopo aver chiamato lambda la variabile contenga il risultato.

Più a lungo di quanto sarebbe in Perl, perché:

• La nuova sintassi della regex è più dettagliata, ad esempio scrivere invece le classi di caratteri dovrebbe apparire <[A..Z]>invece di [A-Z].
• I regex sono codici sorgente di prima classe analizzati in fase di compilazione e una stringa può essere interpolata in essi solo in fase di esecuzione se è costituita da un sottoregex autonomo (ovvero non è possibile interpolare una stringa in una classe di caratteri).
• Explict EVAL, che consentirebbe una maggiore flessibilità, richiede il use MONKEY-SEE-NO-EVAL;pragma ostile al golf .

Sul lato positivo, un array in una @variabile può essere referenziato direttamente in una regex e viene trattato come un'alternanza.

Perl 6 , 65 byte

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

Versione funzionale (genera il risultato come valore di ritorno della lambda).

R, 343 byte

Soluzione R terribilmente goffa:

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 byte

Molto più lungo di quanto dovrebbe essere, ma comunque:

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

In questo modo vengono creati due elenchi: uno degli indici dei caratteri maiuscoli e uno per i caratteri minuscoli. Ognuno di questi elenchi è ripetuto in coppie di indici e i caratteri di quegli indici vengono scambiati.

Domani giocherò a golf , ma per ora è tempo di dormire .

Pip , 28 byte

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

Accetta input come argomento della riga di comando. Provalo online!

Spiegazione

Questa è una soluzione regex, usando le variabili regex integrate XL(lettere minuscole `[a-z]`) e XU(lettere maiuscole `[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)

Quando il secondo argomento Rè un elenco, le sostituzioni vengono eseguite in serie; pertanto, la sostituzione in minuscolo e la sostituzione in maiuscolo non interferiscono l'una con l'altra.

Perl 5 , 48 + 1 (-p) = 49 byte

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

Provalo online!

AWK , 121 129 byte

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

Provalo online! Nota: Link ha 8 byte extra per consentire l'input multilinea

L'utilizzo è abbastanza tipico, ma richiede una versione AWKche accetta una stringa vuota come separatore di campo (la maggior parte delle versioni di gawkma sono abbastanza sicuro che l'originale AWKfallirebbe :()

È molto semplice in quanto scorre semplicemente su ogni personaggio e controlla se è stato trovato uno di questi casi prima. In tal caso, scambia i caratteri e ripristina l'indice selezionato. Dal punto di vista dell'apprendimento, in precedenza non avevo mai usato un'istruzione di assegnazione all'interno di un'istruzione di assegnazione AWK. Per qualche motivo non era mai emerso. :)

Potrei essere in grado di radere un paio di byte dicendo di assegnare OFS e FS fuori da un BEGINblocco tramite assegnazione della riga di comando o simili, ma è "più pulito" in questo modo.

L'aggiunta del collegamento TIO mi ha mostrato che avevo un errore di trascrizione che ha richiesto 8 byte per la correzione :( (ho lasciato fuori 0*(U=a):)

C (gcc) , 212 206 byte

• Grazie a ceilingcat per giocare a golf sei byte.

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

Provalo online!

Stax , 18 byte

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

Esegui ed esegui il debug

L'approccio generale è basato su regex.

• Due volte fanno:
• Trova tutte le partite per [a-z].*?[a-z].
• Scambia il primo e l'ultimo personaggio nelle partite.
• Inverti caso.

R , 223 163 byte 148 byte

EDIT: -60 byte implementando un ciclo for

EDIT: -15 byte da 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="")

Provalo online!

Funziona testando se il carattere è minuscolo o maiuscolo, li posiziona in una matrice, inverte la matrice per estrarre i valori in un formato scambiato. Quindi emetti con cat. Provalo online con le lotte scan(,'')se il codice è più di una riga, quindi i punti e virgola in tutta la singola riga di codice.

Java 7, 117 byte

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

EDIT: Ho appena notato che ho una risposta simile alla risposta Retina di @Leo , anche se ci ho pensato in modo indipendente ..

Ungolfed:

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

Codice di prova:

Provalo qui.

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

Produzione:

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.