ให้ตัวอักษรสองสายโอนรูปแบบการใช้อักษรตัวพิมพ์ใหญ่ของแต่ละสายไปยังอีกสายหนึ่ง ไบต์ที่น้อยที่สุดจะเป็นผู้ชนะ

Input:   CodeGolf xxPPCGxx  
Output:  coDEGOlf XxppCgxx

• สตริงทั้งสองจะมีความยาวเท่ากันและไม่ว่างเปล่ามีเพียงตัวอักษรa..zและA..Z
• คุณสามารถส่งออกทั้งสองสตริงที่เกิดขึ้นในลำดับใด ๆ ที่เกี่ยวข้องกับการป้อนข้อมูล
• คุณอาจแสดงคู่ของสตริงเป็นหนึ่งสตริงที่มีตัวคั่นอักขระเดี่ยวที่ไม่ใช่ตัวอักษรสำหรับอินพุตและ / หรือเอาท์พุท
• คุณอาจแสดงสตริงเป็นรายการของอักขระหรือสตริงอักขระหนึ่งตัว แต่ไม่สามารถใช้เป็นลำดับของค่าจุดโค้ดยกเว้นว่าเป็นสตริงในภาษาของคุณ
• อินพุตและเอาต์พุตของคุณอาจแทนสตริงที่แตกต่างกัน

กรณีทดสอบ:

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

Java (JDK 10) , 66 ไบต์

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

ลองออนไลน์!

คำอธิบาย

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 ไบต์

• ที่บันทึกไว้ยี่สิบแปดไบต์ขอบคุณที่วัวต้มตุ๋น
• บันทึกสามไบต์
• ที่บันทึกไว้สองไบต์ขอบคุณที่โอลิเวียGrégoire

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

ลองออนไลน์!

เยลลี่ขนาด 9 ไบต์

O&32^/^OỌ

ลองออนไลน์!

มันทำงานอย่างไร

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 Classic) , 13 12 ไบต์

⊖⊖819⌶¨⍨∊∘⎕a

ลองออนไลน์!

อินพุตและเอาต์พุตเป็นเมทริกซ์อักขระ 2 × N

⎕a เป็นตัวอักษรภาษาอังกฤษตัวพิมพ์ใหญ่ 'ABC...Z'

∊∘⎕a ส่งกลับเมทริกซ์บูลีนที่ระบุว่าตัวอักษรตัวใดในอินพุตเป็นตัวพิมพ์ใหญ่

819⌶ แปลงอาร์กิวเมนต์ที่เหมาะสมเป็นตัวพิมพ์ใหญ่หรือตัวพิมพ์เล็กขึ้นอยู่กับอาร์กิวเมนต์บูลีนซ้าย ("819" คือ leetspeak สำหรับ "BIG")

819⌶¨⍨ทำเช่นนั้นสำหรับ¨อักขระ( ) แต่ละตัวการสลับ ( ⍨) อาร์กิวเมนต์

⊖หมายถึงย้อนกลับในแนวตั้ง หนึ่ง⊖ทำหน้าที่เป็นอาร์กิวเมนต์ซ้าย819⌶และอื่น ๆ คือการกระทำสุดท้าย

Pyth , 10 ไบต์

rVV_mmrIk1

ลองที่นี่!

คำอธิบาย & เทคนิค Pyth ที่ใช้เรียบร้อย

• rVV_mmrIk1- โปรแกรมเต็มรูปแบบ อินพุตถูกนำมาจาก STDIN เป็นรายการของสองสตริงและเอาต์พุตถูกเขียนไปยัง STDOUT เป็นรายการของอักขระสองรายการ

• mm - สำหรับอักขระแต่ละตัวในแต่ละสตริง:

  • Ik - ตรวจสอบว่ามีค่าคงที่ภายใต้ ...
  • r...1- ... กำลังแปลงเป็นตัวพิมพ์ใหญ่ ผลตอบแทนจริงสำหรับตัวพิมพ์ใหญ่และเท็จสำหรับตัวพิมพ์เล็ก

• _ - ย้อนกลับรายการนั้น

• VV - และดับเบิลเวกเตอร์ฟังก์ชันต่อไปนี้เหนือรายการทั้งสอง:

  • r- แปลงเป็นตัวพิมพ์ใหญ่หากค่าคือTrue(aka 1) มิฉะนั้นจะแปลงเป็นตัวพิมพ์เล็ก

การส่งนี้ละเมิดความจริงที่ว่าr0และr1เป็นฟังก์ชันตัวพิมพ์เล็กและตัวพิมพ์ใหญ่ใน Pyth และเราใช้ค่าความจริง (ค่าที่ได้จากการตรวจสอบว่าอักขระแต่ละตัวเป็นตัวพิมพ์ใหญ่กลับรายการ) ให้Trueตัวพิมพ์ใหญ่และFalseตัวพิมพ์เล็ก ความจริงที่ว่า booleans เป็น subclasses ของจำนวนเต็มใน Python มีประโยชน์มากสำหรับวิธีที่คำตอบนี้ใช้ การย้ายเดนนิสและโจนาธานเจลลี่เข้าหาทั้งคู่ทำให้ได้มากกว่า 18 ไบต์ดังนั้นฉันจึงมีความสุขมากกับเทคนิคเฉพาะของพี ธ ที่ใช้ที่นี่

MATL 11 ไบต์

kG91<P32*-c

ลองออนไลน์! หรือตรวจสอบกรณีทดสอบทั้งหมด

คำอธิบาย

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 ไบต์

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

ลองออนไลน์!

J , 36 31 27 ไบต์

-9 ไบต์ขอบคุณ FrownyFrog!

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

ลองออนไลน์!

วิธีแก้ไขก่อนหน้าคือ:

J , 36 31 ไบต์

-5 ไบต์ขอบคุณ FrownyFrog!

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

ลองออนไลน์!

มันทำงานอย่างไร:

                          (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 ไบต์

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

ลองออนไลน์!

จะต้องมีวิธีนักกอล์ฟมาก -43 bytes ขอบคุณ Giuseppe ที่แนะนำให้ฉันใช้วิธีการแก้ปัญหา MATL โดย Luis Mendo ลิงก์ TIO มีโซลูชันฟังก์ชั่นสำหรับจำนวนไบต์เดียวกัน

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

โบนัส: ผลลัพธ์เป็นเวกเตอร์ที่มีชื่อซึ่งมีชื่อเป็นสตริงอินพุตดั้งเดิม!

รหัสเครื่อง x86-64 ขนาด 14 ไบต์

เรียกได้จาก C (x86-64 SysV เรียกประชุม) กับต้นแบบนี้:

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

รุ่นความยาวอย่างชัดเจนที่มีความยาวrcxเป็นขนาดเดียวกัน void casexchg(char *rdi, char *rsi, int dummy, size_t len);

สิ่งนี้ใช้อัลโกแลกเปลี่ยนบิตเดียวกันกับคำตอบ C และ Java: หากตัวอักษรทั้งสองเป็นตัวพิมพ์เล็กไม่จำเป็นต้องเปลี่ยน หากพวกเขาเป็นกรณีตรงข้ามพวกเขาทั้งสองต้องเปลี่ยน

ใช้ XOR เพื่อ diff บิตเคสของสองสตริง mask = (a XOR b) AND 0x20เป็น 0 สำหรับเดียวกันหรือ 0x20 สำหรับการแตกต่างกัน a ^= mask; b ^= maskcaseflip ตัวอักษรทั้งสอง iff พวกเขาเป็นกรณีตรงข้าม (เนื่องจากรหัสตัวอักษร ASCII สำหรับบนและล่างแตกต่างกันในบิตที่ 5 เท่านั้น)

รายชื่อ NASM (จากnasm -felf64 -l/dev/stdout) ใช้cut -b 26- <casexchg.lst >casexchg.lstเปลี่ยนสิ่งนี้ให้เป็นสิ่งที่คุณสามารถรวบรวมได้

   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

ช้าloopการเรียนการสอนยังเป็น 2 jccไบต์เช่นเดียวสั้น scasbยังคงเป็นวิธีที่ดีที่สุดในการเพิ่มrdiโดยใช้คำสั่งแบบหนึ่งไบต์ ผมคิดว่าเราจะทำได้/xor al, [rdi] stosbซึ่งอาจมีขนาดเท่ากัน แต่อาจเร็วกว่าสำหรับloopเคส (หน่วยความจำ src + store ราคาถูกกว่า memory dst + reload) และจะยังคงตั้งค่า ZF อย่างเหมาะสมสำหรับกรณีความยาวโดยนัย!

ลองออนไลน์! ด้วย _start ที่เรียกใช้บน argv [1], argv [2] และใช้ sys_write กับผลลัพธ์

k , 14 ไบต์

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

ลองออนไลน์! อินพุต / เอาต์พุตเป็นรายการของสองสตริง

Python 3 , 83 ไบต์

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

ลองออนไลน์!

-3 ไบต์ขอบคุณ Mr. Xcoder
-3 ไบต์ขอบคุณ Chas Brown

Haskell , 78 ไบต์

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

ลองออนไลน์!

QBasic, 133 ไบต์

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$

รับทั้งสองสตริงคั่นด้วยเครื่องหมายจุลภาคและส่งผลลัพธ์ผลลัพธ์ขึ้นบรรทัดใหม่คั่น ใช้ขั้นตอนวิธีการเล่นซอบิตจากเดนนิสคำตอบของวุ้น นอกเหนือจากนั้นเคล็ดลับกอล์ฟหลักที่นี่คือสตริงผลลัพธ์แรกถูกพิมพ์โดยตรงหนึ่งตัวอักษรในแต่ละครั้งซึ่งสั้นกว่าการบันทึกทั้งสองสตริงผลลัพธ์ในตัวแปรและพิมพ์ออกนอกวง

JavaScript, 77 74 73 ไบต์

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']])
)

ใช้อาร์เรย์ของถ่านอาร์เรย์ส่งออกอาร์เรย์ของถ่านอาร์เรย์

_{-1 ไบต์ ( @Arnauld ): c>'Z'→c>{}}

เรติน่า 75 ไบต์

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

ลองออนไลน์! คำอธิบาย: การขึ้นบรรทัดใหม่ถูกใช้เป็นเครื่องหมายเพื่อพิจารณาจำนวนของสตริงที่ถูกประมวลผล regex พยายามที่จะจับคู่กับตัวอักษรตัวพิมพ์ใหญ่หรือความล้มเหลวที่ตัวละครใด ๆ หากตัวอักษรตัวพิมพ์ใหญ่ถูกจับคู่แล้วตัวละครอื่น ๆ ที่เป็นตัวพิมพ์ใหญ่มิฉะนั้นมันจะลดลงและในทางกลับกันในขณะที่ขึ้นบรรทัดใหม่จะก้าวไปสู่ตัวละครต่อไป

Python 3 , 76 75 ไบต์

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

ลองออนไลน์!

ส่งออกผลลัพธ์เป็นหนึ่งสตริงที่มีตัวคั่นอักขระเดียว

ขอบคุณJonathon Allan เป็นเวลา 1 ไบต์

ชุดประกอบ (nasm, x64, Linux) , 25 ไบต์ (แหล่ง 123 ไบต์)

ไบต์สิบหก:

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

จุดเริ่มต้นที่ฟังก์ชั่นที่aมีสายที่ผ่านมาในการใช้และRDIRSI

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

ลองออนไลน์!

เยลลี่ขนาด 13 ไบต์

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

ลองออนไลน์!

13: =ŒuṚ×32ạŒlO$Ọ(หรือ=ŒuṚæ«5ạŒlO$Ọ)

ถ่าน 17 ไบต์

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

ลองออนไลน์! การเชื่อมโยงคือการใช้รหัสเวอร์ชันอย่างละเอียด รับอินพุตเป็นอาร์เรย์ของสองสตริง คำอธิบาย:

 θ                  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 ไบต์

คนเสพเวจมรรค

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

ลองออนไลน์!

ฟังก์ชั่นgใช้ทั้งสองสายเป็นพารามิเตอร์ Seq.fold2ใช้ฟังก์ชั่นที่มีตัวสะสม ( a) กับแต่ละองค์ประกอบ ( xและy) ในสตริง เริ่มแรกaเป็นสตริงว่างและเพิ่มอักขระที่แปลงไปแล้วในแต่ละการวนซ้ำ

bเป็นหน้าที่หลัก มันจะแปลงเป็นครั้งแรกfด้วยความเคารพsแล้วแปรรูปด้วยความเคารพs fจากนั้นส่งคืน tuple ด้วยค่าทั้งสอง

Prolog (SWI) , 121 ไบต์

[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.
_-_-[]-[].

ลองออนไลน์!

Ruby , 74 69 ไบต์

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

ลองออนไลน์!

อินพุทและเอาท์พุทเป็นอาร์เรย์ของตัวอักษรดังนั้นส่วนท้ายจึงแปลงกลับไปกลับมาจากสตริง

ฉันยังไม่แน่ใจว่านี่เป็นวิธีการแก้ปัญหาที่ดีหรือไม่ แต่ความท้าทายนี้ดูเหมือนจะเป็นสถานการณ์การใช้งานที่ดีสำหรับswapcaseวิธีการ

PHP 4.1.2 , 40 ไบต์

แทนที่คู่ของเครื่องหมายคำพูดด้วยไบต์ A0 (ใน ISO-8859-1 หรือ Windows-1252 นี่คือ NBSP) เพื่อรับจำนวนไบต์ที่แสดงแล้วเรียกใช้จากเว็บเบราว์เซอร์ (หรือจากบรรทัดคำสั่ง) โดยให้สตริงเป็น ข้อโต้แย้งสตริงแบบสอบถาม (หรือตัวแปรสภาพแวดล้อม) และab

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

ในรุ่นของ PHP นี้register_globalsตามค่าเริ่มต้นดังนั้นสตริงจะถูกกำหนดโดยอัตโนมัติไปยังตัวแปรและ$a $bเพิ่มมูลค่า2e5(20,000) หากจำเป็น

PHP 7.1+, 58 ไบต์

ทำงานบนบรรทัดคำสั่งโดยใช้php -r 'code here' string1 string2:

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

ค่า3e5(300000) ถูกเลือกให้เกิน (MAX_ARG_STRLEN * 2 + 1) ในระบบ Linux ส่วนใหญ่ (โดยเฉพาะ x86 และสถาปัตยกรรมอื่น ๆ ที่ PAGE_SIZE คือ 4096 และ MAX_ARG_STRLEN คือ 131072) เพื่อหลีกเลี่ยงปัญหากับสตริงอินพุตใด ๆ ที่เป็นไปได้ เพิ่มขึ้นหากจำเป็น

ลองออนไลน์!

Stax , 10 ไบต์

▌Ö↑o╓→ì]yç

เรียกใช้และแก้ไขข้อบกพร่อง

ต่อไปนี้เป็นการนำเสนอโปรแกรมเดียวกันเพื่อแสดงว่ามันทำงานอย่างไร

        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

เรียกใช้อันนี้

คริสตัล 108 ไบต์

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

ลองออนไลน์!

มันทำงานอย่างไร?

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