Hedef

Bu basit bir zorluktur. Amacınız, harf olmayan karakterleri değiştirmeden bırakarak her harfin aynı harfin bir sonraki harfiyle değiştirilmesiyle dizeyi çözmektir.

Adım adım açıklama

1. İlk karakter a E. Bir sonraki mektubu büyük harf olarak ararız: bu bir C. Bu karakterleri değiştiriyoruz, ki bu da yol açar CdoE!.

2. Bir sonraki karaktere geçiyoruz: bu bir d. Bir sonraki harfi küçük harf olarak ararız: bu bir o. Bu karakterleri değiştiriyoruz, ki bu da yol açar CodE!.

3. Bir sonraki karaktere ilerliyoruz: bu, dburaya yeni taşındığımız şey. Bunu görmezden geliyoruz, çünkü zaten işlendi.

4. Bir sonraki karaktere ilerliyoruz: Eişte adım 1'de buraya taşınmıştı. Bunu görmezden geliyoruz, çünkü zaten işlendi.

5. Bir sonraki karaktere geçiyoruz: bu bir !. Bunu görmezden geliyoruz, çünkü bu bir mektup değil.

kurallar

• Giriş dizesinin yalnızca yazdırılabilir ASCII karakterlerinden, 32 - 126 aralığında olduğunu varsayabilirsiniz.

• Tam bir program veya sonucu yazdıran ya da veren bir fonksiyon yazabilirsiniz.

• Giriş dizgisinde tek sayıda harf varsa, kalan son harf başka bir harfle değiştirilemez ve ne olursa olsun yerinde kalmalıdır. Aynı mantık, dize eşit sayıda harf içeriyorsa, ancak tek sayıda büyük harf ve tek sayıda küçük harf içeriyorsa geçerlidir.

• Bu kod golf, yani bayt cinsinden en kısa cevap kazanır. Standart boşluklar yasaktır.

Test durumları

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

Rastgele olmayan test durumları:

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.

Jelly , 21 20 19 18 bayt

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

Çevrimiçi deneyin!

Nasıl çalışır

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 bayt

Gerçekten akıllıca değil, temiz ve okunaklı bir çözüm

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

Çevrimiçi deneyin!

MATL , 22 bayt

2:"tttk<f2etAZ))P5M(Yo

Çevrimiçi deneyin! Veya tüm test durumlarını doğrulayın .

Nasıl çalışır

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)

Bash + Unix yardımcı programları, 77 62 57 56 54 bayt

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

Stdin girişi. Stdout'ta çıktı.

(Bu son sürümde, stderr de yazılır, ancak PPCG konsensüsü tamamdır - stderr basitçe göz ardı edilir. )

Düzenleme 1: 15 bayt için @Dennis'e teşekkürler! İyileştirmeler: (a) stdin ile girdi almak; (b) 2 sed senaryoyu bir tanede birleştirmek; ve (c) tr'nin, bash parametresi genişlemesi ile ikame ile değiştirilmesi; (b) ve (c) Düzen 2'de kayboldu.

Düzenleme 2: 5 ek byte ile daha kısa. Düzen 1'deki hem (b) hem de (c) yerine işlev çağrısı kullanılır.

Düzen 3: İşlev bağımsız değişkenlerinin bir parçası olarak bir bayt iletildi.

Düzen 4: Değiştirilen iki işlev, çağrıları argüman olmadığında programın kendisine çağırır.

Testbed ve örnek çıktı:

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 bayt

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

@Neil, @Arnauld ve @ edc65 yardımı ile çözüm çok kısaldı

açıklama

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 bayt

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

Çevrimiçi deneyin!

QBasic, 229 bayt

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$

strateji

Giriş dizgisinden geçiyoruz. Büyük bir harfle karşılaştığımızda, onu ve konumunu saklarız. İkinci kez büyük harfle karşılaştığımızda, saklanan değerleri öncekiyle değiştirmek için kullanırız. Küçük harf için aynı.

(Bir diziyi kullanan daha uzun bir sürüm yayınlamak üzereydim, çünkü QBasic dizelerinin değişmez olduğunu düşündüm. Sonra MID$(strng$, index, length) = replacement$gayet iyi çalışan bir gerçeğe rastladım . Canlı ve öğren.)

Ungolfed + yorum yaptı

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 bayt

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

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$

DLosc sayesinde bir bayt kurtarıldı. Harf olmayan karakterlerin kullanım şeklini değiştirerek birkaç kez daha tasarruf edin.

Bu temelde üç bölümden oluşur:

• Girişi 3 karaktere ayırma (Büyük harf, Küçük harf ve bir harita (diğer karakterleri de tutar)
• Büyük ve küçük harfleri çevirmek
• Haritayı kullanarak çıktıyı (yeniden) oluşturmak.

Daha ayrıntılı bir açıklama (bunun kodun daha eski bir versiyonuna ait olduğunu ancak prensibin hala geçerli olduğunu unutmayın):

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

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

Önceki sürüm (93 bytes)

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

Bana preg_replace()dizgileri argüman olarak alabilecekleri hatırlattığım için @ user59178'e teşekkür ederiz .

Orijinal cevap (108 bayt)

$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, kullanılabilir alana sığması için buraya sarılır.
Komut satırından çalıştırılabilir:

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

PHP 7'de $f, ilk çağrısının içindeki atamayı sıkarak 1 baytlık kısa bir sürüm mümkündür :

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

Test durumlarda ve ungolfed sürümleri ile Her iki çözüm de, bulunabilir Github .

Mathematica, 96 bayt

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

Leo'nun Retina cevabının , düzenli ifadeler kullanan bir limanı .

Python 2,121 bayt

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

Regex tabanlı çözümüm kadar kısa değil , ama yine de ilginç olduğunu düşünüyorum.

Çevrimiçi deneyin!

Fasulye , 83 bayt

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

Eşdeğer JavaScript:

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

Açıklama:

Örtülü olarak ilk girdi satırını almak a(yeni satırlar şifreli dizgenin bir parçası olamayacağı için) ve dolaylı olarak büyük harf ve küçük harf çiftleri sırayla değiştirerek şifrelenmemiş dizgenin çıktısını alır.

Burada demoyu deneyin.

Burada test odasını deneyin.

Ruby, 81 bayt

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

JavaScript (ES6), 80 bayt

Leo'nun Retina cevabı dayanarak .

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

Kodunda sadece büyük harf karakterler, çünkü bu işleri .replace(/([A-Z])([^A-Z]*)([A-Z])/g,'$3$2$1')vardır Ave Zkarakter aralıkları tanımlamak için kullanılır, hangi. Bu tam olarak ikinci geçişi işlemek için küçük harfe dönüştürmemiz gereken şeydir.

Test durumları

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 bayt

Daha iyi bir cevap olduğunu biliyorum ama regex olmadan denemek istedim. Bu bir de noktalama işaretleri üzerinde çalışıyor ama bu (^_^)testi ihlal ediyor gibi görünüyor . Bu durumda c()aşağıda verilen başka bir işleve sahibim .

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

açıklama

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 bayt

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

Dizge değişkenini argüman olarak alır ve yerinde değiştirir, böylece lambda çağırdıktan sonra değişken sonucu içerir.

Perl'de olacağından daha uzun, çünkü:

• Yeni regex sözdizimi daha ayrıntılıdır, örneğin karakter sınıflarının <[A..Z]>yerine nasıl görüneceğini yazmak [A-Z].
• Regexes, derleme zamanında ayrıştırılan birinci sınıf kaynak koddur ve bir dize yalnızca bağımsız bir alt regex'ten oluşuyorsa çalışma zamanında onlara enterpolasyon yapabilir (yani bir dizeyi karakter sınıfına giremezsiniz).
• EVALDaha fazla esneklik sağlayacak açık, golf dostu olmayan pragmayı gerektirir use MONKEY-SEE-NO-EVAL;.

Artı tarafta, bir @değişkendeki bir diziye doğrudan bir regex'te referans verilebilir ve bir alternatif olarak değerlendirilir.

Perl 6 , 65 bayt

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

İşlevsel versiyon (sonucu lambdanın dönüş değeri olarak verir).

R, 343 Bayt

Çok sakar R çözümü:

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 bayt

Olması gerekenden çok daha uzun ama yine de:

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

Bu, ilk önce iki liste oluşturur: büyük harfli karakterlerin dizinlerinden biri ve küçük harfli karakterlerden biri. Bu listelerin her biri indeks çiftleri arasında ilmeklenir ve bu indekslerdeki karakterler değiştirilir.

Bunu yarın golf oynayacağım , ama şimdilik uyku zamanı .

Pip , 28 bayt

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

Komut satırı argümanı olarak girdi alır. Çevrimiçi deneyin!

açıklama

Bu, yerleşik regex değişkenlerini XL(küçük harfler, `[a-z]`) ve XU(büyük harfler, `[A-Z]`) kullanan bir regex çözümüdür .

                              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)

İkinci argüman Rbir liste olduğunda, değiştirmeler seri olarak gerçekleştirilir; bu nedenle, küçük harf değişimi ve büyük harf değişimi birbirlerini etkilemez.

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

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

Çevrimiçi deneyin!

AWK , 121 129 bayt

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

Çevrimiçi deneyin! Not: Link, çok satırlı girişe izin vermek için 8 ekstra bayta sahiptir.

Kullanımı oldukça tipiktir, ancak AWKalan ayırıcı olarak boş bir dize kabul eden bir sürümü gerektirir (sürümlerin çoğu gawkancak orijinalinin AWKbaşarısız olacağından eminim :()

Her karakter üzerinde basitçe yinelendiği ve bu durumda daha önce bulunup bulunmadığını kontrol ettiği için çok basittir. Öyleyse karakterleri değiştirir ve kontrol edilen dizini sıfırlar. Şeylerin öğrenme tarafında, AWKönceden bir atama ifadesinde bir atama ifadesi kullanmamıştım . Nedense hiç gelmedi. :)

OFS ve FS'yi BEGINkomut satırı ataması veya benzeri ile bir bloğun dışına atayarak birkaç bayt tıraş edebilirim , ancak bu şekilde "daha temiz".

TIO bağlantısını eklemek bana düzeltmek için 8 byte gerektiren bir transkripsiyon hatası olduğunu gösterdi :( (Ben dışarıda bıraktım 0*(U=a):)

C (gcc) , 212 206 bayt

• Altı baytlık golf oynamak için ceilingcat sayesinde .

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

Çevrimiçi deneyin!

Stax , 18 bayt

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

Koş ve hata ayıkla

Genel yaklaşım regex tabanlıdır.

• İki kere yaparsın:
• İçin tüm eşleşmeleri bul [a-z].*?[a-z].
• Maçlarda ilk ve son karakteri değiştir.
• Büyük / küçük harf ters çevir.

R , 223 163 bayt 148 bayt

EDIT: -60 bayt bir for döngüsü uygulayarak

EDIT: Giuseppe gelen -15 bayt

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

Çevrimiçi deneyin!

Karakterin küçük harf mi yoksa büyük harf mi olduğunu test ederek çalışır, bunları bir matrise yerleştirir, değerleri değiştirilen bir biçimde çıkarmak için matrisi tersine çevirir. Ardından ile çıktı cat. scan(,'')Kodun birden fazla satır olması durumunda çevrimiçi mücadeleleri deneyin ; bu nedenle, tek bir kod satırı boyunca noktalı virgüller.

Java 7, 117 bayt

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

EDIT: Sadece farkettim ki, @Leo'nun Retina cevabı ile benzer bir cevabım var, bağımsız olarak düşünmeme rağmen ..

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

Test kodu:

Burada dene.

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

Çıktı:

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.