İki harf dizisi göz önüne alındığında, her bir dizinin büyük harf yapısını diğerine aktarın. En az bayt kazanır.

Input:   CodeGolf xxPPCGxx  
Output:  coDEGOlf XxppCgxx

• Her iki dize de eşit uzunlukta ve boş olacaktır, yalnızca harfler a..zve A..Z.
• Sonuçta ortaya çıkan iki dizeyi girdilere göre sırayla çıkartabilirsiniz.
• Girdi ve / veya çıktı için harf olmayan tek karakterli ayırıcı içeren bir dize olarak bir çift dizeyi temsil edebilirsiniz.
• Bir dize karakter listesi veya tek karakterli dizeler olarak temsil edebilirsiniz, ancak bunlar yalnızca sizin dilinizde dizeler olmadıkça kod noktası değerleri dizisi olarak gösterilemez.
• Giriş ve çıkışlarınız dizeleri farklı şekilde gösterebilir.

Test durumları:

CodeGolf xxPPCGxx -> coDEGOlf XxppCgxx
lower UPPER -> LOWER upper
MiXeD lower -> mixed LoWeR
A A -> A A
ABcd EfGh -> AbCd EFgh

Java (JDK 10) , 66 bayt

a->b->{for(int i=a.length,t;i-->0;b[i]^=t)a[i]^=t=(a[i]^b[i])&32;}

Çevrimiçi deneyin!

açıklamalar

a->b->{                           // Curried lambda
 for(int i=a.length,t;i-->0;      //  Descending loop on i,
                                  //  Declare t
     b[i]^=t                      //   Apply the case difference to b[i]
   )
  a[i]^=t=(a[i]^b[i])&32;         //   Assign the case difference of the two letters to t, and apply it to a[i].
}

C (gcc) , 86 58 55 53 bayt

• İnekler yarışması sayesinde yirmi sekiz bayt kaydedildi .
• Üç bayt kaydedildi.
• Olivier Grégoire sayesinde iki bayt kurtarıldı .

c(a,s,e)char*a,*s;{for(;*s++^=e=(*s^*a)&32;)*a++^=e;}

Çevrimiçi deneyin!

Jöle , 9 bayt

O&32^/^OỌ

Çevrimiçi deneyin!

Nasıl çalışır

O&32^/^OỌ  Main link. Argument: [s, t] (pair of strings)

O          Ordinal; replace each character with its code point.
 &32       Perform bitwise AND with 32, yielding 32 for lowercase letters, 0 for
           uppercase ones.
    ^/     Reduce by XOR, yielding 32 for letter pairs with different 
           capitalizations, 0 for letter pair with matching capitalizations.
      ^O   XOR the result with each of the code points.
        Ọ  Unordinal; replace each code point with its character.

APL (Dyalog Klasik) , 13 12 bayt

⊖⊖819⌶¨⍨∊∘⎕a

Çevrimiçi deneyin!

giriş ve çıkış 2 × N karakter matrisidir

⎕a Büyük harf İngilizce alfabedir 'ABC...Z'

∊∘⎕a girdideki hangi harflerin büyük harf olduğunu gösteren bir boolean matrisini döndürür

819⌶ boolean sol argümanına bağlı olarak sağ argümanını büyük veya küçük harfe dönüştürür ("819", "BIG" için leetspeak'dir)

819⌶¨⍨Bunu her ( ¨) karakter için yapar ⍨, değişkenleri değiştirerek ( )

⊖dikey olarak ters anlamına gelir; biri ⊖sol argüman gibi davranır 819⌶, diğeri ise son eylemdir

Pyth , 10 bayt

rVV_mmrIk1

Burada dene!

Açıklama ve düzgün Pyth kullanılan hileler

• rVV_mmrIk1- Tam program. Girdi, iki dizginin listesi olarak STDIN'den alınır ve çıktı iki karakter listesinin listesi olarak STDOUT'a yazılır.

• mm - Dizelerin her birindeki her karakter için:

  • Ik - Altında değişmeyen olup olmadığını kontrol et ...
  • r...1- ... Büyük harfe dönüştürme. Verim Gerçek büyük harfli karakterler için ve yanlış küçük olanlar için.

• _ - Listeyi tersine çevir.

• VV - Ve aşağıdaki fonksiyonu iki liste üzerinde çift-lineize edin:

  • r- Değer True(aka 1) ise büyük harfe dönüştür, aksi takdirde küçük harfe dönüştürülür.

Bu gönderim kötüye gerçeği r0ve r1Pyth içinde Küçük ve büyük harf fonksiyonları vardır ve biz gerçeği değerleri (her karakter büyük harfli ise kontrol ederek elde edilen değerlerin tersine) kullanan verimli Trueharfe ve Falseküçük harf için. Booleanların Python'daki bir tamsayı alt sınıfı olması, bu cevabın kullandığı yaklaşım için çok kullanışlıdır. Dennis ve Jonathan'ın Jelly yaklaşımlarının her ikisi de 18 bayttan fazla sonuç verdi, bu yüzden burada kullanılan Pyth'e özgü numaralardan çok memnunum.

MATL , 11 bayt

kG91<P32*-c

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

açıklama

k      % Implicit input: 2-row char matrix. Convert to lower-case
G      % Push input again 
91<    % Less than 91?, element-wise. Gives 1 for upper-case
P      % Flip vertically
32*    % Multiply by 32, element-wise
-      % Subtract, element-wise
c      % Convert to char. Implicit display

Haskell , 78 bayt

import Data.Char
c x|isUpper x=toUpper|1<2=toLower
(!)=zipWith c
x#y=(y!x,x!y)

Çevrimiçi deneyin!

J , 36 31 27 bayt

FrownyFrog sayesinde -9 bayt!

(XOR"$32*[:~:/97>])&.(3&u:)

Çevrimiçi deneyin!

Önceki çözüm şuydu:

J , 36 31 bayt

FrownyFrog sayesinde -5 bayt!

|:@(XOR 32*0~:/@|:97>])&.(3&u:)

Çevrimiçi deneyin!

Nasıl çalışır:

                          (3&u:)  converts the strings to code points
   (                    )&.       then do the following and convert back to chars
                    97>]          check if they are uppercase letters 
             0~:/@|:              transpose and check if the two values are different
          32*                     multiply by 32 (32 if different, 0 otherwise)
      XOR                         xor the code point values with 32 or 0
 |:@                              and transpose

R , 118 94 75 72 bayt

m=sapply(scan(,""),utf8ToInt);w=m>96;apply(m-32*(w-w[,2:1]),2,intToUtf8)

Çevrimiçi deneyin!

Çok daha golfçü bir yol olmalı. -43 bayt, beni Luis Mendo'nun MATL çözümüne yönlendiren Giuseppe sayesinde . TIO bağlantısı aynı bayt sayısı için bir fonksiyon çözümü içerir.

m=sapply(a<-scan(,""),utf8ToInt)    # Turns input into a matrix of bytecode (2 columns)
w=m>96                              # Predicate : which chars are lower?
apply(m-32*(w-w[,2:1]),2,intToUtf8) # -32*w turns the string to UPPER
                                    # +32*w[,2:1] swaps capitalization
                                    # intToUtf8 turns bytecode to strings

Bonus: Çıktı, isimleri orijinal girdi dizeleri olan isimlendirilmiş bir vektördür!

x86-64 makine kodu, 14 bayt

Bu prototip ile C'den (x86-64 SysV arama sözleşmesi) aranabilir:

void casexchg(char *rdi, char *rsi);  // modify both strings in place

Uzunluğu olan açık uzunluklu bir sürüm rcxaynı boyuttadır. void casexchg(char *rdi, char *rsi, int dummy, size_t len);

Bu, C ve Java cevaplarıyla aynı bit değişimi algo kullanır: Her iki harf aynı ise, her ikisinin de değişmesi gerekmez. Karşı dava ise ikisinin de değişmesi gerekiyor.

İki dizenin büyük / küçük harfini farklılaştırmak için XOR kullanın. mask = (a XOR b) AND 0x20Aynı için 0, farklı için 0x20. a ^= mask; b ^= maskher iki harften farklı olsa da caseflip. (Çünkü ASCII üst ve alt harflerin kodları sadece 5 bitinde değişir.)

NASM listelemesi (den nasm -felf64 -l/dev/stdout). cut -b 26- <casexchg.lst >casexchg.lstBunu tekrar monte edebileceğiniz bir şeye dönüştürmek için kullanın .

   addr    machine
 6         code          global casexchg
 7         bytes         casexchg:
 8                       .loop:
 9 00000000 AC               lodsb                ; al=[rsi] ; rsi++
10 00000001 3207             xor   al, [rdi]
11 00000003 2420             and   al, 0x20       ; 0 if their cases were the same: no flipping needed
12                       
13 00000005 3007             xor   [rdi], al      ; caseflip both iff their cases were opposite
14 00000007 3046FF           xor   [rsi-1], al
15                       
16 0000000A AE               scasb                ; cmp al,[rdi] / inc rdi
17                           ; AL=0 or 0x20.
18                           ; At the terminating 0 in both strings, AL will be 0 so JNE will fall through.
19                           ; 0x20 is ASCII space, which isn't allowed, so AL=0x20 won't cause early exit
20 0000000B 75F3             jne  .loop
21                       ;    loop  .loop            ; caller passes explict length in RCX
22                       
23 0000000D C3               ret

  size = 0xe bytes = 14
24 0000000E 0E           db $ - casexchg_bitdiff

Yavaş loopkomut, kısa olarak aynı 2 bayttır jcc. scasbhala rdibir tek baytlık komut ile artmanın en iyi yoludur . Ben yapabiliriz sanırım xor al, [rdi]/ stosb. Bu aynı boyutta olacaktır ancak loopdurum için muhtemelen daha hızlıdır (memory src + store, hafıza dst + yeniden yüklemesinden daha ucuzdur). Ve yine ZF'yi örtük uzunlukta davaya uygun şekilde ayarlayabilir!

Çevrimiçi deneyin! argv [1] üzerinde çağıran bir _start ile, argv [2] ve sonuçta sys_write kullanılır

k , 14 bayt

{`c$l+|x-l:_x}

Çevrimiçi deneyin! Giriş / çıkış iki dizenin bir listesidir.

Python 3 , 83 bayt

lambda a,b:(g(a,b),g(b,a))
g=lambda*a:[chr(ord(x)&95|(y>'Z')<<5)for x,y in zip(*a)]

Çevrimiçi deneyin!

Bay Xcoder
sayesinde -3 bayt Chas Brown sayesinde -3 bayt

Haskell , 78 bayt

c!d=([c..'z']++[';'..])!!sum[32|(c>'Z')/=(d>'Z')]
(#)=zipWith(!)
s%t=(s#t,t#s)

Çevrimiçi deneyin!

QBasic, 133 bayt

INPUT a$,b$
FOR i=1TO LEN(a$)
c=ASC(MID$(a$,i,1))
d=ASC(MID$(b$,i,1))
s=32AND(c XOR d)
?CHR$(c XOR s);
r$=r$+CHR$(d XOR s)
NEXT
?
?r$

İki dizgiyi virgülle ayrılmış olarak alır ve yeni satırla ayrılmış sonuçları çıkarır. Dennis'in Jelly cevabındaki bit toplama algoritmasını kullanır . Bunun dışında, buradaki ana golf numarası, ilk sonuç dizgisinin doğrudan basıldığı, bir seferde bir karakter olduğu, bu sonuçların hem sonuç dizgilerini değişkenlere kaydetmekten hem de döngü dışına yazdırmaktan biraz daha kısa olmasıdır.

JavaScript, 77 74 73 bayt

W=>W.map((w,x)=>w.map((c,i)=>W[+!x][i][`to${c>{}?'Low':'Upp'}erCase`]()))

f=
W=>W.map((w,x)=>w.map((c,i)=>W[+!x][i][`to${c>{}?'Low':'Upp'}erCase`]()))

console.log(
    f([[...'CodeGolf'],[...'xxPPCGxx']])
)

Bir dizi char dizisi alır, bir dizi char dizisi çıkarır.

_{-1 bayt ( @Arnauld ): c>'Z'→c>{}}

Retina , 75 bayt

^
¶
+`¶(([A-Z])|(.))(.*)¶(([A-Z])|(.))
$#6*$u$1$#7*$l$1¶$4$#2*$u$5$#3*$l$5¶

Çevrimiçi deneyin! Açıklama: Yeni satırlar, dizenin ne kadarının işlendiğini belirlemek için işaretçiler olarak kullanılır. Düzenli ifade, büyük harflerle eşleşmeye veya herhangi bir karakterde başarısızlığa uğramaya çalışır. Eğer bir büyük harfle eşleştirilirse, diğer karakter büyük harfe dönüştürülür, aksi halde küçük harfe dönüştürülür, aksi halde yeni satırlar bir sonraki karaktere ilerletilir.

Python 3 , 76 75 bayt

lambda a,b:''.join(chr(ord(x)&95|ord(y)&32)for x,y in zip(a+' '+b,b+'a'+a))

Çevrimiçi deneyin!

Sonucu, tek karakterli bir ayırıcıyla bir dize olarak çıkarır.

Jonathon Allan'a 1 bayt için Thx .

Montaj (nasm, x64, Linux) , 25 bayt (123 bayt kaynak)

Hex bayt:

0x88, 0xE6, 0x30, 0xC6, 0x80, 0xE6, 0x20, 0x88
0xF2, 0x66, 0x31, 0xD0, 0x88, 0x26, 0xAA, 0xAC
0x8A, 0x26, 0x8A, 0x07, 0x08, 0xE4, 0x75, 0xE8, 0xC3

Fonksiyon giriş noktası olan adizeleri kullanılarak geçilen ile, RDIve RSI.

b:MOV DH,AH
XOR DH,AL
AND DH,32
MOV DL,DH
XOR AX,DX
MOV [RSI],AH
STOSB
LODSB
a:MOV AH,[RSI]
MOV AL,[RDI]
OR AH,AH
JNZ b
RET

Çevrimiçi deneyin!

Jöle , 13 bayt

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

Çevrimiçi deneyin!

Ayrıca 13: =ŒuṚ×32ạŒlO$Ọ(veya =ŒuṚæ«5ạŒlO$Ọ)

Kömür , 17 bayt

Ｅθ⭆ι⎇№α§§θ¬κμ↥λ↧λ

Çevrimiçi deneyin! Bağlantı, kodun ayrıntılı bir versiyonudur. Girdiyi iki karakter dizisi olarak alır. Açıklama:

 θ                  Input array
Ｅ                   Map over strings
   ι                Current string
  ⭆                 Map over characters
         θ          Input array
           κ        Outer loop index
          ¬         Logical Not
        §           Index into array
            μ       Inner loop index
       §            Index into array
      α             Uppercase characters
     №              Count number of matches
              λ λ   Current character
             ↥      Uppercase
               ↧    Lowercase
    ⎇               Ternary
                    Implicitly print

F #, 120 bayt

Kahretsin.

open System
let g=Seq.fold2(fun a x y->a+string(x|>if y>'Z'then Char.ToLower else Char.ToUpper))""
let b f s=g f s,g s f

Çevrimiçi deneyin!

İşlev giki dizgiyi parametre olarak alır. dizgilerdeki her bir öğeye ( ve ) Seq.fold2bir toplayıcı ( a) içeren bir işlev uygular . Başlangıçta boş bir dizedir ve dönüştürülen karakteri her yinelemede ekler.xya

bana işlevidir. İlk önce fona göre s, sonra sona göre değişir f. Daha sonra her iki değerle birlikte bir tuple döndürür.

Prolog (SWI) , 121 bayt

[H|T]-[I|U]-[J|V]-[K|W]:-((H>96,I>96;H<92,I<92),J=H,K=I;H>96,J is H-32,K is I+32;J is H+32,K is I-32),T-U-V-W.
_-_-[]-[].

Çevrimiçi deneyin!

Ruby , 74 69 bayt

->a,b{a.zip(b).map{|x|x.one?{|y|y>?_}?x.map(&:swapcase):x}.transpose}

Çevrimiçi deneyin!

Girdi ve çıktı, karakter dizileridir, bu nedenle altbilgi dizgilerden ileri geri dönüşümler yapar.

Bunun soruna iyi bir yaklaşım olup olmadığından henüz emin değilim, ancak bu zorluk kesinlikle swapcaseyöntem için iyi bir kullanım senaryosuna benziyor .

PHP 4.1.2 , 40 bayt

Gösterilen bayt sayısını almak için bayt A0 ile (ISO-8859-1 veya Windows-1252'de, bu NBSP'dir) çift tırnak işaretini değiştirin, ardından bir web tarayıcıdan çalıştırın (veya komut satırından). sorgu dizesi argümanları (veya ortam değişkenleri) ave b.

<?=$a^$c=($a^$b)&str_pad("",2e5),_,$b^$c;

PHP'nin bu sürümünde, register_globals varsayılan olarak açıktır, dolayısıyla dizgeler otomatik olarak değişkenlere atanır $ave $b. 2e5Gerekirse değerini (200000) arttırın .

PHP 7.1+, 58 bayt

Komut satırında çalıştırın php -r 'code here' string1 string2:

[,$a,$b]=$argv;echo("$b $a"^$a.=" $b")&str_pad("",3e5)^$a;

Değer 3e5(300000), Linux sistemlerinde (özellikle, PAGE_SIZE'ın 4096 ve MAX_ARG_STRLEN'in bu nedenle 131072 olduğu diğer x86 ve diğer mimarilerde 131072) aşılması (MAX_ARG_STRLEN * 2 + 1) olarak seçilmiştir. Gerekirse arttırın.

Çevrimiçi deneyin!

Stax , 10 bayt

▌Ö↑o╓→ì]yç

Koş ve hata ayıkla

İşte nasıl çalıştığını göstermek için aynı programın asılsız bir gösterimi.

        Example
        ["Ab", "cd"]                    
:)      [["Ab", "cd"], ["cd", "Ab"]]    Get all rotations of input
m       ["cd", "Ab"]                    For each, run the rest of program; print result
  M     ["cA", "db"]                    Transpose matrix
  {     "cA"                            Begin block for mapping to result
    B   "A" 99                          "Pop" first element from string array; leave the rest
    96> "A" 1                           Is the character code > 96?
    :c  "a"                             Set case of string; 0 -> upper,  1 -> lower
  m     "ab"                            Perform the map using the block

Bunu çalıştır

Kristal , 108 bayt

def f(a,b)r=s=""
a.zip(b){|x,y|r+="`"<x<"{"?y.downcase: y.upcase
s+="`"<y<"{"?x.downcase: x.upcase}
{s,r}end

Çevrimiçi deneyin!

Nasıl çalışır?

def f(a, b)                       # Strings as list of characters
r = s = ""                        # Strings buffers initialization
a.zip(b) do |x, y|                # Join two arrays to paired tuples and iterate
r+="`"<x<"{"?y.downcase: y.upcase # Check if character is downcase using triple
s+="`"<y<"{"?x.downcase: x.upcase # comparison and ascii table. Then apply it to
end                               # the other character using String methods
{s, r}                            # Return two new strings using a tuple
end                               # PS: Tuples are inmutable structures in Crystal