विनिमय पूंजीकरण

35

अक्षरों के दो तारों को देखते हुए, प्रत्येक स्ट्रिंग के कैपिटलाइज़ेशन पैटर्न को दूसरे पर स्थानांतरित करें। सबसे कम बाइट्स जीतता है।

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
code-golf  string 
— XNOR
स्रोत

जवाबों:

14

जावा (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].
}
— ओलिवियर ग्रेजायर
स्रोत
9
पूरी तरह से आपके इस जवाब से असंबंधित है, लेकिन यह एक चैट बनाने की तुलना में आसान है। ? क्या आपने देखा कि Java-10 TIO का उपयोग करते समय एक बग है array[i++%n]+=...;? array[t=i++%n]=array[t]+...;ठीक काम करता है; और array[i%n]+=...;i++;ठीक काम करता है, लेकिन एक modulo का उपयोग करके i++या किसी सरणी में एक पंक्ति में संलग्न करने के लिए काम नहीं करता है .. यहाँ एक जावा 10 TIO उदाहरण के रूप में समस्या को देखने के लिए। क्या यह जावा 10 JDK में या जावा 10 TIO कंपाइलर में बग (या फीचर: S) है? ++i+=
— केविन क्रूज़सेन
1
@ केविनक्रूजसेन मैं इस मुद्दे को देखता हूं, लेकिन यह अजीब लगता है। मैं देखता हूं कि TIO पर उपयोग किया जाने वाला संस्करण 10.0.0_46 (20-03-2018 का) है। नवीनतम संस्करण 10.0.1 है। हमें संभवतः जावा के अपने संस्करण को अपडेट करने के लिए टीआईओ से पूछना चाहिए।
— ओलिवियर ग्रेजायर
3
@KevinCruijssen डेनिस ने 10.0.1 के संस्करण को अपडेट किया और समस्या अभी भी हो रही है (मेरे पास जावा 10 स्थापित नहीं है फिर भी मैं TIO पर भरोसा करता हूं, आपकी तरह)। मैंने स्टैक ओवरफ्लो पर पूछा है क्योंकि मुझे नहीं पता कि यहां क्या होता है ... यह चकरा देने वाला है!
— ओलिवियर ग्रेजायर
5
@ केविनक्रूजसेन यह ठीक है, यह ऐसा नहीं है कि यह उत्तर बहुत अधिक आकर्षित करता है: पी वैसे भी ... बात यह है कि आप वास्तव में एक बग मिला है । चूँकि कल्पना कहती है कि यह अभिनय करना चाहिए जैसा कि आप सोचते हैं कि यह होगा, तो अपना उत्तर उसी तरह से लिखते रहें, यदि आपको ऐसा करने की आवश्यकता हो तो जावा 10 के लिए अनुकूलित किया जाए। इस तरह, आपके पास एक मान्य जावा 10 उत्तर है, लेकिन उस बग के कारण अप्राप्य है। बस इसे लिखें और इसे जावा 8 में परीक्षण करें, फिर बदलने के Stringलिए उचित जावा 10 परिवर्तन करें var।
— ओलिवियर ग्रेजायर
6
मुझे लगता है कि यह वास्तव में साफ है कि आपको JDK 10 में एक बग मिला। अच्छा काम:]
— प्रहार
13

सी (जीसीसी) , 86 58 55 53 बाइट्स

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

इसे ऑनलाइन आज़माएं!

— जोनाथन फ्रेच
स्रोत
बिट हेरफेर देता हैf(S,Z)char*S,*Z;{for(int d;d=(*Z^*S)&32,*Z++^=d;)*S++^=d;}
— क्रिक्सी लिथोस
@ कौवे वाह; बहुत बहुत धन्यवाद।
— जोनाथन फ्रीच
— ओलिवियर ग्रेजायर
@ ओलिवियरग्रैगो धन्यवाद।
— जोनाथन फ्रीच
8

जेली , 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.
— डेनिस
स्रोत
1
... हमें पता था कि यह होने वाला है: D
— जोनाथन एलन
7

APL (Dyalog Classic) , 13 12 बाइट्स

⊖⊖819⌶¨⍨∊∘⎕a

इसे ऑनलाइन आज़माएं!

इनपुट और आउटपुट 2 × N वर्ण का मैट्रिक्स है

⎕a अपरकेस अंग्रेजी वर्णमाला है 'ABC...Z'

∊∘⎕a एक बूलियन मैट्रिक्स लौटाता है जो दर्शाता है कि इनपुट में कौन से अक्षर अपरकेस हैं

819⌶ अपने बूलियन लेफ्ट लॉजिक ("819" के लिए "BIG" के आधार पर लेफ़्टपेक के आधार पर इसके सही तर्क को अपरकेस या लोअरकेस में कनवर्ट करता है)

819⌶¨⍨प्रत्येक ( ¨) चरित्र, स्वैपिंग ( ⍨) तर्कों के लिए करता है

⊖सीधा उल्टा अर्थ है; एक ⊖बाएं तर्क के रूप में कार्य करता है 819⌶और दूसरा अंतिम क्रिया है

— NGN
स्रोत
1
"819" is leetspeak for "BIG"... गंभीरता से? यही कारण है कि यह 819 का वास्तविक विवरण है? 0_o
— DLosc
@DLosc हाँ :) चैट देखना
— NGN
5

अजगर , 10 बाइट्स

rVV_mmrIk1

यहाँ यह कोशिश करो!

व्याख्या और साफ-सुथरी पाइथ ट्रिक्स

  • rVV_mmrIk1- पूर्ण विषय। इनपुट को एसटीडीआईएन से दो तारों की एक सूची के रूप में लिया जाता है, और आउटपुट को STDOUT को पात्रों की दो सूचियों की सूची के रूप में लिखा जाता है।

  • mm प्रत्येक तार में प्रत्येक वर्ण के लिए:

    • Ik - जाँच करें कि क्या यह अनियंत्रित है ...
    • r...1- ... अपरकेस करने के लिए परिवर्तित। पैदावार सच अपरकेस वर्णों के लिए और झूठी लोअरकेस लोगों के लिए।

  • _ - उस सूची को उलट दें।

  • VV - और दो सूची में निम्नलिखित कार्य को दोहराएं:

    • r- यदि मान True(उर्फ 1) है तो अपरकेस में कन्वर्ट करें , अन्यथा लोअरकेस में बदलें ।

इस प्रविष्टि को गाली तथ्य यह है कि r0और r1लोअरकेस और Pyth में अपरकेस कार्य हैं, और हम सच मान (पता चल सके कि प्रत्येक वर्ण अपरकेस है के द्वारा प्राप्त किया, उलट) का उपयोग उपज Trueअपरकेस के लिए और Falseलोअरकेस के लिए। तथ्य यह है कि बूलियन पायथन में पूर्णांक के उपवर्ग हैं जो इस उत्तर का उपयोग कर रहे हैं। पोर्टिंग डेनिस और जोनाथन के जेली दृष्टिकोण दोनों के परिणामस्वरूप 18 से अधिक बाइट्स हुए, इसलिए मैं यहां इस्तेमाल किए गए पायथ-विशिष्ट ट्रिक्स से काफी खुश हूं।

— मिस्टर एक्सकोडर
स्रोत
4

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
— लुइस मेंडो
स्रोत
3

जे , 36 31 27 बाइट्स

-9 बाइट्स FrownyFrog के लिए धन्यवाद!

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

इसे ऑनलाइन आज़माएं!

पिछले समाधान था:

जे , 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
— गैलेन इवानोव
स्रोत
कैन [:0 हो सकता है और (22 b.)हो सकता है XOR। &.(3&u:)1 बाइट बचाता है।
— FrownyFrog
@FrownyFrog बहुत अच्छे गोल्फ, धन्यवाद! तुम वास्तव में अच्छे हो!
— गैलेन इवानोव
27
— FrownyFrog
@FrownyFrog वाह! क्या आप "और के उपयोग की व्याख्या कर सकते हैं $? धन्यवाद!
— गैलेन इवानोव
इनपुट के साथ किया जाता है ,:, बाईं ओर 2 पंक्तियाँ हैं। हमें जरूरत है, "(1)लेकिन "$काम भी करना है, क्योंकि यह खड़ा है "1 _। $ b.0$ की रैंक देता है (मोनैडिक, डाइएडिक लेफ्ट, डाइएडिक राइट)।
— FrownyFrog
3

आर , 118 94 75 72 बाइट्स

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

इसे ऑनलाइन आज़माएं!

वहाँ एक बहुत गोल्फ रास्ता होना चाहिए। -43 बाइट्स गियुसेपे को धन्यवाद जिन्होंने मुझे लुईस मेंडो द्वारा MATL समाधान के लिए इशारा किया। 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

बोनस: आउटपुट एक नामित वेक्टर है जिसका नाम मूल इनपुट स्ट्रिंग्स हैं!

— Jayce
स्रोत
आप ड्रॉप करने में सक्षम होना चाहिए a<-क्योंकि आप aकहीं और उपयोग नहीं करते हैं।
— Giuseppe
@Giuseppe क्या आप मेरे दिमाग को पढ़ रहे थे? ;)
— जेसी
3

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

यह सी और जावा के उत्तर के समान बिट-एक्सचेंज एल्गो का उपयोग करता है: यदि दोनों अक्षर एक ही मामले हैं, तो न तो बदलने की आवश्यकता है। यदि वे विपरीत मामले में हैं, तो उन्हें बदलने की आवश्यकता है।

दो तारों के मामले को अलग करने के लिए XOR का उपयोग करें। mask = (a XOR b) AND 0x20भिन्न के लिए 0 या समान 0x20 है। a ^= mask; b ^= maskकेसफ्लिप दोनों पत्र यदि वे विपरीत मामले थे। (क्योंकि ऊपरी और निचले के लिए ASCII पत्र कोड केवल बिट 5 में भिन्न होते हैं)

एनएएसएम लिस्टिंग (से 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 + स्टोर मेमोरी dst + reload की तुलना में सस्ता है)। और फिर भी निहित लंबाई के मामले के लिए उचित रूप से ZF सेट करेगा!

इसे ऑनलाइन आज़माएं! _start के साथ जो इसे argv [1] पर कॉल करता है, argv [2] और परिणाम पर sys_write का उपयोग करता है

— पीटर कॉर्डेस
स्रोत
2

पायथन 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 बाइट्स धन्यवाद मिस्टर एक्सकोडर
-3 बाइट्स चास ब्राउन को धन्यवाद

— HyperNeutrino
स्रोत
बिट-ट्विडलिंग के साथ 83 बाइट्स ।
— चास ब्राउन
@ChasBrown ओह अच्छा, अच्छा। धन्यवाद!
— हाइपरएनुट्रिनो
2

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$

दो तारों को अल्पविराम से अलग कर देता है और परिणामों को न्यूलाइन-अलग कर देता है। डेनिस के जेली उत्तर से बिट-फ़िडलिंग एल्गोरिथ्म का उपयोग करता है । इसके अलावा, यहां मुख्य गोल्फ चाल यह है कि पहला परिणाम स्ट्रिंग सीधे मुद्रित किया जाता है, एक समय में एक चरित्र, जो चर में दोनों परिणाम तार को बचाने और उन्हें लूप के बाहर मुद्रित करने की तुलना में थोड़ा कम है।

— DLosc
स्रोत
2

जावास्क्रिप्ट, 77 74 73 बाइट्स

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

कोड स्निपेट दिखाएं

चार सरणियों की एक सरणी लेता है, चार सारणियों की एक सरणी आउटपुट करता है।

-1 बाइट ( @ अरनल्ड ): c>'Z'→c>{}

— darrylyeo
स्रोत
1
आप के साथ एक बाइट बचा सकते हैं c>{}।
— अरनुलद
1

रेटिना , 75 बाइट्स

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

इसे ऑनलाइन आज़माएं! स्पष्टीकरण: स्ट्रिंग को कितना संसाधित किया गया है, यह निर्धारित करने के लिए मार्कर के रूप में नईलाइनों का उपयोग किया जाता है। रेगेक्स अपरकेस अक्षरों के विरुद्ध या किसी भी वर्ण को विफल करने का प्रयास करता है। यदि एक अपरकेस अक्षर का मिलान किया गया था, तो दूसरे वर्ण को अपरकेस किया गया है अन्यथा इसे नीचा दिखाया गया है और इसके विपरीत, जबकि नए वर्ण अगले चरित्र के लिए उन्नत हैं।

— नील
स्रोत
1

पायथन 3 , 76 75 बाइट्स

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

इसे ऑनलाइन आज़माएं!

एकल-वर्ण विभाजक के साथ एक स्ट्रिंग के रूप में परिणाम को आउटपुट करता है।

Thx to Jonathon Allan 1 बाइट के लिए।

— चास ब्राउन
स्रोत
(y>'Z')*32->ord(y)&32
— जोनाथन एलन
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प्रयोग में आने वाले स्ट्रिंग्स के साथ RDIऔर है 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

इसे ऑनलाइन आज़माएं!

— ErikF
स्रोत
मुझे बस एहसास हुआ कि आप मशीन-कोड के आकार का नहीं, बल्कि एसएसएम स्रोत को गोल्फ कर रहे हैं। यह आमतौर पर अधिक मजेदार होता है, क्योंकि यह वास्तविक जीवन में कभी-कभी उपयोगी होता है। (बाकी सभी समान हैं, छोटा आम तौर पर फ्रंट-एंड और कैश कैश घनत्व के लिए बेहतर है।) x86 / x64 मशीन कोड में गोल्फ के लिए टिप्स ।
— पीटर कॉर्ड्स
@PeterCordes टिप के लिए धन्यवाद। मैंने हेक्स बाइट्स को जोड़ा है। मेरी असेंबली थोड़ी रस्टी है (मुझे पिछली बार DOS 3.3 के लिए थोड़ा डिवाइस ड्राइवर लिखना पड़ा था!) ​​लेकिन मुझे लगता है कि मुझे अधिकांश अनुकूलन मिल गए।
— ErikF
हाँ, यह बहुत अच्छा लग रहा है। दिलचस्प आंशिक-रजिस्टर हैक। and al,32केवल 2 बाइट्स है, विशेष AL का उपयोग करते हुए, जो कि ज्यादातर ALU निर्देश है, imm8 एन्कोडिंग है। आपको RCX और उपयोग में स्ट्रिंग की लंबाई की आवश्यकता हो सकती हैloop । मैं कहना है आपको चाहिए जा रहा था test ah,ahक्योंकि कि और अधिक कुशल है की तुलना मेंor , जबकि एक ही लंबाई किया जा रहा है, लेकिन यह एएसएम स्रोत में लंबे समय तक है, इसलिए crusty पुराने मुहावरे वास्तव में एएसएम स्रोत कोड गोल्फ के लिए योग्यता है: पी
— पीटर Cordes
मेमोरी-डेस्टिनेशन एक्सोर और एक तंग लूप संरचना का उपयोग करते हुए, मेरा संस्करण x86-64 मशीन कोड के 14 बाइट्स में आया । गिनती अंतर्निहित लंबाई या स्पष्ट लंबाई के तार के लिए भी। इसका NASM स्रोत शायद 123 बाइट्स से भी छोटा हो सकता है। मुझे यकीन नहीं है कि स्काईलेक या रायज़ेन जैसे आधुनिक सीपीयू पर तेजी से चलेगा (डीएक्स पढ़ने पर डीएच को मर्ज करने के लिए राइजन की कोई अतिरिक्त लागत नहीं होगी, लेकिन एसकेएल को विलय के लिए एक अतिरिक्त चक्र की आवश्यकता होगी।)
— पीटर
0

चारकोल , 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
— नील
स्रोत
0

एफ #, 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) के साथ एक फ़ंक्शन लागू करता है । शुरू मेंxya में एक खाली स्ट्रिंग है, और यह प्रत्येक पुनरावृत्ति में परिवर्तित वर्ण जोड़ता है।

bमुख्य कार्य है। यह पहले fसम्मान के साथ परिवर्तित होता है s, और फिर sसम्मान के साथ परिवर्तित होता है f। इसके बाद दोनों मानों के साथ एक ट्यूपल लौटाता है।

— Ciaran_McCarthy
स्रोत
0

रूबी , 74 69 बाइट्स

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

इसे ऑनलाइन आज़माएं!

इनपुट और आउटपुट वर्णों के सरणियाँ हैं, इसलिए पाद तार से आगे और पीछे परिवर्तन करता है।

मुझे अभी तक यकीन नहीं है कि यह समस्या के लिए एक अच्छा तरीका है, लेकिन यह चुनौती निश्चित रूप से swapcaseविधि के लिए एक अच्छा उपयोग परिदृश्य जैसा दिखता है ।

— किरिल एल।
स्रोत
0

PHP 4.1.2 , 40 बाइट्स

बाइट A0 के साथ उद्धरण चिह्नों की जोड़ी को बदलें (ISO-8859-1 या Windows-1252 में, यह NBSP है) बाइट की गिनती दिखाए जाने के लिए, फिर वेब ब्राउजर से (या कमांड लाइन से), स्ट्रिंग्स प्रदान करें। क्वेरी स्ट्रिंग तर्क (या पर्यावरण चर) aऔर b।

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

पीएचपी के इस संस्करण में, रजिस्टर_ग्लोबल्स तो तार स्वचालित रूप से चर को सौंपा जाएगा, डिफ़ॉल्ट रूप से चालू है $aऔर $b। 2e5यदि आवश्यक हो तो मूल्य (200000) बढ़ाएं ।

PHP 7.1+, 58 बाइट्स

कमांड लाइन पर, का उपयोग कर चलाएँ php -r 'code here' string1 string2:

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

महत्व 3e5अधिकांश लिनक्स सिस्टम (विशेष रूप से, x86 और अन्य आर्किटेक्चर, जिसके लिए PAGE_SIZE 4096 है, और MAX_ARG_STRLEN इस प्रकार 131072 है) पर (300000) से अधिक (MAX_ARG_STRLEN * 2 + 1) चुना जाता है, किसी भी संभावित इनपुट स्ट्रिंग की समस्याओं से बचने के लिए। यदि आवश्यक हो तो बढ़ाएँ।

इसे ऑनलाइन आज़माएं!

— कृपया उठो
स्रोत
0

स्टैक्स , 10 बाइट्स

▌Ö↑o╓→ì]yç

इसे चलाएं और डीबग करें

यहां यह दिखाने के लिए कि यह कैसे काम करता है, उसी कार्यक्रम का एक ungolfed प्रतिनिधित्व है।

        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

इसको चलाओ

— पुनरावर्ती
स्रोत
0

क्रिस्टल , 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
— user80978
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.