दो तारों का स्वैप पूंजीकरण

Question

your shift key is broken. wheNever you type two lines, the cApitaL
LetteRs in them get swappeD. you must write a program to fiX THIS!

विवरण

इनपुट दो स्ट्रिंग्स है, s1और s2, लंबाई में बराबर है। उनमें प्रत्येक में केवल मुद्रण योग्य ASCII होगा और लंबाई में कम से कम एक वर्ण हो सकता है। आप दो तार, दो तार की एक सरणी, या के साथ एक एकल स्ट्रिंग के रूप में इन इनपुट हो सकता है s1और s2या तो एक टैब या नई पंक्ति से अलग कर दिया।

आउटपुट निम्नलिखित है:

• प्रत्येक चरित्र cके लिए s1:

  • यदि वर्ण कोई अक्षर नहीं है, तो यह अपरिवर्तित है।

  • अन्यथा, यदि cकोई पत्र है:

    • मिलान वर्ण (एक ही सूचकांक में एक) में खोजें s2।

      • यदि यह एक कैपिटल लेटर है, तो आउटपुट cकैपिटल हो जाता है।

      • यदि यह एक लोअरकेस अक्षर है, तो cलोअरकेस में आउटपुट ।

      • अन्यथा, आउटपुट cअपरिवर्तित है।

• फिर एक ही काम करें, सिवाय s1और s2स्विच किए हुए।

अनिवार्य रूप से, सभी अक्षर, s1जिनके लिए मिलान वर्ण s2कैपिटल में कैपिटल है, और सभी अक्षरों में s1एक ही इंडेक्स में एक लोअरकेस अक्षर के साथ s2लोअरकेस (और इसके विपरीत) बनना चाहिए।

परीक्षण के मामलों

इनपुट:

ABCDEfghijKlMnOpqrstuvwxyz
aaaaaaaaaaaaaaaa----------

आउटपुट:

abcdefghijklmnopqrstuvwxyz
AAAAAaaaaaAaAaAa----------

---

इनपुट:

PRogrammiNG puzZLes & CODe golf
SdlkhkfaladlKsdlalksdg7ldklDgsl

आउटपुट:

Programming Puzzles & Code Golf
SDlkhkfalADlksdLAlksdg7LDkldgsl

---

इनपुट:

AAAbbb111
Cc2Dd3Ee4

आउटपुट:

AaABbb111
CC2dd3Ee4

Comments

मैं अपने जीवन के लिए यह पता नहीं लगा सकता कि यह एक टूटी हुई शिफ्ट कुंजी के कारण कैसे हो सकता है, लेकिन मैं कौन हूँ जो सर्वशक्तिमान डोरकनॉब के साथ बहस करता हूं? : पी

— जियोबिट्स

क्या इनपुट एक ही लाइन पर होना चाहिए? या मैं उन्हें अलग करने के लिए कुछ अन्य चरित्र (एक टैब?) का उपयोग कर सकता हूं

— kirbyfan64sos

@ डेनिस नहीं, इनपुट प्रदान किया जाना चाहिए जैसा कि प्रश्न में दिखाया गया है।

— दरवाज़े

@ kirbyfan64sos आप या तो दो तार ले सकते हैं, तार की एक सरणी, या दो तार एक टैब या एक नई रेखा से अलग हो सकते हैं। मैं उस प्रश्न को संपादित करूँगा।

— दरवाज़े

एक अनुगामी न्यूलाइन की अनुमति है?

— डाउनगेट

Answer 1

पायथ, 19 18 बाइट्स

LCmrW&@dG@drG1d2Cb

यह एक फ़ंक्शन y को परिभाषित करता है जो स्ट्रिंग की एक सूची को स्वीकार करता है और वापस करता है।

Pyth Compiler / Executor में सभी परीक्षण मामलों को एक बार सत्यापित करें ।

1 बाइट को बंद करने के लिए @Jakube का धन्यवाद।

यह काम किस प्रकार करता है

                   " (implicit) Initialize G to 'abcdefghijklmnopqrstuvwxyz'.

L                  " Define y(b):
                Cb "   Zip to turn the two strings into an array of char pairs.
  m                "   Map (implicit variable d):
      @dG          "     Intersect d with G.
         @drG1     "     Intersect d with G.upper().
    W&             "     If both are non-empty:
   r          d2   "       Apply swapcase() to d.
 C                 "   Zip to turn the character pairs back into two strings.

Answer 2

सीजेएम, 25 बाइट्स

{z{_el_eu&\__:^32&f^?}%z}

यह एक अनाम फ़ंक्शन है जो स्टैक से स्ट्रिंग्स की एक सरणी को पॉप करता है और बदले में एक छोड़ देता है।

समर्थित ब्राउज़रों में, आप CJam दुभाषिया में एक बार में सभी परीक्षण मामलों को सत्यापित कर सकते हैं ।

परीक्षण के मामलों

कोड

qN/2/                     e# Read input and split into arrays of two strings.

{z{_el_eu&\__:^32&f^?}%z}

%                         e# Map the block over all string arrays.
:+N*                      e# Separate the strings by linefeeds.

इनपुट

ABCDEfghijKlMnOpqrstuvwxyz
aaaaaaaaaaaaaaaa----------
PRogrammiNG puzZLes & CODe golf
SdlkhkfaladlKsdlalksdg7ldklDgsl
AAAbbb111
Cc2Dd3Ee4

उत्पादन

abcdefghijklmnopqrstuvwxyz
AAAAAaaaaaAaAaAa----------
Programming Puzzles & Code Golf
SDlkhkfalADlksdLAlksdg7LDkldgsl
AaABbb111
CC2dd3Ee4

यह काम किस प्रकार करता है

z                       e# Zip to transform the array of strings into an array
                        e# of character pairs.
 {                  }%  e# For each character pair:
  _el                   e#   Push a copy and convert to lowercase.
     _eu                e#   Push a copy and convert to uppercase.
        &               e#   Intersect. The result will be an empty string if
                        e#   and only if both characters are letters.
         \              e#   Swap the character pair on top of the stack.
          __            e#   Push two copies.
            :^          e#   XOR both characters.
              32&       e#   Logical AND with 32. This pushes 32 for letters of
                        e#   different cases and 0 for letters of the same case.
                 f^     e#   XOR each character with the result.
                   ?    e#   Select the original copy for non-empty intersection
                        e#   and the modified one otherwise.
                      z e# Zip to turn the characters pairs back into two strings.

Answer 3

सी, 126 बाइट्स

यह एक कोड गोल्फ में मेरा पहला प्रयास है, कभी। अगर मैंने कुछ गलत किया तो मुझे बताएं।

मैं स्विचिंग करने के लिए बिटवाइज़ ऑपरेशन का उपयोग कर रहा हूँ

golfed:

main(u,a,s,t)char**a,*s,*t;{for(s=a[1],t=a[2];*t;s++,t++)isalpha(*s)*isalpha(*t)?u=(*t^*s)&32,*t^=u,*s^=u:0;*s=10;puts(a[1]);}

Ungolfed:

main(u,a,s,t) char**a,*s,*t; {       // K&R style arguments
    for(s=a[1],t=a[2];*t;s++,t++)    // initialize loop.
        isalpha(*s) * isalpha(*t) ? // ensure both characters are letters (if)
            u = (*t^*s) & 0x20,      // check if characters have swapped case
            *t^=u,                   // if so, xor the bit which represents case
            *s^=u                    // for both characters in the string.
        :0;                          // end ternary statement (endif)
    *s=10;                           // replace null terminator in first string 
    puts(a[1]);                      // with newline. This allows both output to 
}                                    // be printed out all at once

संपादित करें: प्रतिस्थापित && के साथ *

Answer 4

SQL (PostGreSQL), 427 बाइट्स

विशाल आकार के बावजूद, यह मेरी अपेक्षा से काफी छोटा था। मुझे पूरा यकीन नहीं था कि मैं इसे ईमानदारी से करने में सक्षम होने जा रहा हूं। मुझे संदेह है कि बहुत कुछ है जो अभी भी किया जा सकता है :)

CREATE FUNCTION F(TEXT,TEXT)RETURNS TABLE(S TEXT) AS'SELECT unnest(array[string_agg(CASE WHEN T~''[A-Z]''THEN upper(S)WHEN T~''[a-z]''THEN lower(S)ELSE S END,''''),string_agg(CASE WHEN S~''[A-Z]''THEN upper(T)WHEN S~''[a-z]''THEN lower(T)ELSE T END,'''')])FROM(SELECT ROW_NUMBER()OVER()N,S FROM regexp_split_to_table($1,'''')X(S))A JOIN(SELECT ROW_NUMBER()OVER()M,T FROM regexp_split_to_table($2,'''')Y(T))B ON N=M'LANGUAGE SQL

प्रारूपित और टिप्पणी की गई

-- Declare the function spec
CREATE FUNCTION F(TEXT,TEXT)RETURNS TABLE(S TEXT) AS  
'SELECT unnest(   -- turns array into a table
    array[        -- build array of the column results
    string_agg( -- Aggregate the result into a string
        CASE 
        WHEN T~''[A-Z]''THEN upper(S) -- uppercase it if corresponding char is uppercase
        WHEN T~''[a-z]''THEN lower(S) -- lowercase it if corresponding char is lowercase
        ELSE S END
        ,''''),
    string_agg( -- Same as the previous but swap strings
        CASE 
        WHEN S~''[A-Z]''THEN upper(T)
        WHEN S~''[a-z]''THEN lower(T)
        ELSE T END
        ,'''')
    ])
FROM
    -- split the first string
   (SELECT ROW_NUMBER()OVER()N,S FROM regexp_split_to_table($1,'''')X(S))A
    JOIN
    -- split the second string
   (SELECT ROW_NUMBER()OVER()M,T FROM regexp_split_to_table($2,'''')Y(T))B 
   ON N=M
'
LANGUAGE SQL

परीक्षण चालन

SELECT F(A,B) AS Result
FROM (VALUES 
    ('AAAbbb111', 'Cc2Dd3Ee4'), 
    ('ABCDEfghijKlMnOpqrstuvwxyz', 'aaaaaaaaaaaaaaaa----------'), 
    ('PRogrammiNG puzZLes & CODe golf', 'SdlkhkfaladlKsdlalksdg7ldklDgsl')
    )A(A,B)

Result
-----------------------------
AaABbb111
CC2dd3Ee4
abcdefghijklmnopqrstuvwxyz
AAAAAaaaaaAaAaAa----------
Programming Puzzles & Code Golf
SDlkhkfalADlksdLAlksdg7LDkldgsl

Answer 5

जूलिया, 140 बाइट्स

f(s,t)=(C(x,y)=(i=0;z="";for c=x i+=1;z*=string(isalpha(c)?isupper(y[i])?uppercase(c):islower(t[i])?lowercase(c):c:c)end;z);(C(s,t),C(t,s)))

यह एक ऐसा फंक्शन बनाता है जो दो स्ट्रिंग्स को स्वीकार करता है और स्ट्रिंग्स का एक टपल देता है। कुछ भी विशेष रूप से चालाक यहाँ नहीं चल रहा है; हम केवल एक आंतरिक फ़ंक्शन को परिभाषित करते हैं जो सीधे कल्पना में एल्गोरिथ्म को लागू करता है और इसे दो बार कॉल करता है।

Ungolfed:

function f(s, t)
    C(x, y) = begin
        i = 0
        z = ""
        for c in x
            i += 1
            if isalpha(c)
                if isupper(y[i])
                    z *= string(uppercase(c))
                elseif islower(y[i])
                    z *= string(lowercase(c))
                else
                    z *= string(c)
                end
            else
                z *= string(c)
            end
        end
        return z
    end

    return (C(s, t), C(t, s))
end

Answer 6

जावास्क्रिप्ट ईएस 6, 128 108 बाइट्स

s=(a,b,t)=>[...a].map((l,i)=>/[^a-z]/.exec(b[i])?l.toUpperCase():l.toLowerCase()).join``+(t?'':`
`+s(b,a,1))

जावास्क्रिप्ट toUpperCase()और toLowerCase()बहुत से बाइट्स लेते हैं, लेकिन String.fromCharCode()अधिक लंबा है

Comments

यह उस स्थिति के लिए जिम्मेदार नहीं है, जिसमें एक चरित्र s2एक अक्षर नहीं है और एक ही वर्ण s1अपरकेस है। इस मामले में, cमें s1अपरिवर्तित वापस करना होगा।

— cPu1

@ cPu1 मैंने संबोधित किया है कि :)

— डाउनगेट

Answer 7

गणितज्ञ, 173 169 155 बाइट्स

f=0>1;t=!f;c=Characters;u=ToUpperCase;StringJoin/@MapThread[#@#2&,{Reverse[{LetterQ@#,#==(u@#)}&/@c@#/.{{f,_}->(#&),{t,t}->u,{t,f}->ToLowerCase}&/@#],c/@#},2]&

यह दो तारों की एक सरणी लेने वाला एक फ़ंक्शन है, उदाहरण के लिए {"Foo","bAR"}और दो तारों की एक सरणी आउटपुट। यह संयुक्त राष्ट्र के स्थानिक संपीड़ित योजना को फिर से लिखने, f@xके रूप में f[x], जहाँ भी यह प्रतीत होता है अंकन कोड (विस्तार हो रहा f=0>1उर्फ False, t=!fउर्फ True, c=Charactersऔर u=ToUpperCaseQ), और अन-जगह साथ UpperCaseQ [#] #==u@#(इस चरित्र अपने uppercased संस्करण के बराबर होती है), यह है:

StringJoin /@ MapThread[#[#2] &, {
    Reverse[
        { LetterQ[#], UpperCaseQ[#] } & /@ Characters[#] /. 
        { {False, _} -> (# &), {True, True} -> ToUpperCase, 
          {True, False} -> ToLowerCase } & /@ #
    ],
    Characters /@ #
}, 2] &

Interfacing: अनुगामी &यह एक कार्य करता है। इसके तर्क को "#" के रूप में डाला जाता है /@ #। उदाहरण के लिए f=0>1; ... & [{"AAAbbb111", "Cc2Dd3Ee4"}]आउटपुट का उत्पादन करता है {AaABbb111,CC2dd3Ee4}।

प्रसंस्करण: सामान्य रूप से बाहर क्रम में बताया:

• का आउटपुट MapThread[...]वर्णों की दो सूचियों की एक सूची है। StringJoin इन दो सूचियों में से प्रत्येक पर लागू होता है दो तार की एक सूची का उत्पादन करने के लिए, आउटपुट।
• MapThread[#[#2]&, ... , 2]दो 2-दर-n तत्व सूचियों के एक सरणी पर कार्य करता है। पहली सूची फ़ंक्शंस का 2-बाय-एन सरणी है। दूसरी सूची वर्णों की 2-दर-n सरणी है, Characters /@ #दो इनपुट स्ट्रिंग्स में वर्णों की सूची। यह गहराई 2 पर कार्य करता है, अर्थात्, कार्यों और व्यक्तिगत पात्रों पर।
• Reverse[...] फ़ंक्शंस के दो सब्लिस्ट्स को स्वैप करता है ताकि MapThread दूसरे स्ट्रिंग के फ़ंक्शंस को पहले स्ट्रिंग पर लागू करे और इसके विपरीत।
• { ... } & एक अनाम फ़ंक्शन है जो दो इनपुट स्ट्रिंग्स में से प्रत्येक पर लागू होता है।
• {LetterQ[#], UpperCaseQ[#]} & /@ Characters[#]एक स्ट्रिंग को वर्णों की सूची में विभाजित करता है, फिर प्रत्येक चरित्र को दो तत्व सूचियों से बदल देता है। इन दो तत्व सूचियों में, पहला तत्व है Trueयदि चरित्र एक अक्षर है और Falseअन्यथा, इसी तरह, दूसरा तत्व इंगित करता है कि चरित्र ऊपरी मामला है या नहीं। UpperCaseQ[]यदि यह एक पत्र प्राप्त नहीं करता है तो सही नहीं लौट सकता।
• /. {{False, _} -> (# &), {True, True} -> ToUpperCase, {True, False} -> ToLowerCase}इन दो तत्व सूचियों को कार्यों के साथ बदल देता है। ( किसी भी मिलान का प्रयास करने से पहले संक्षिप्तीकरण का विस्तार tऔर fघटित होता है।) यदि दो तत्व सूची Falseमें इसका पहला तत्व है, तो इसे फ़ंक्शन (# &), पहचान फ़ंक्शन से बदल दिया जाता है । (कोष्ठक आवश्यक हैं, अन्यथा तीर एम्परसेंड की तुलना में अधिक कसकर बांधता है।) अन्यथा दो तत्व सूची के साथ शुरू होता है True, चरित्र एक पत्र था, और हम फ़ंक्शन ToUpperCaseऔर ToLowerCaseइसके मामले के अनुरूप आउटपुट करते हैं । (इस अंतिम के लिए जाँच करना Falseअनावश्यक है, वास्तव में {_,_}->ToLowerCaseकाम करेगा, ऐसी किसी भी चीज़ को पकड़ना जो अभी तक प्रतिस्थापित नहीं की गई थी, लेकिन यह कोई छोटी और अधिक अस्पष्ट नहीं होगी।)

एकमात्र चुनौती यह थी कि कार्यों के दो आयामी सरणी को तर्कों की एक सरणी के रूप में ज़िप करने के लिए एक शानदार तरीका है।

संपादित करें: "मददगार" कट / पेस्ट लाइनब्रेक बैकस्लैश, 1>0और 1<0संक्षिप्तीकरण को पकड़ने के लिए @ मर्टिन ब्यूटनर को धन्यवाद , और बाइट्स में लंबाई गिनने के लिए मार्गदर्शन के लिए भी पात्र नहीं (जो भी हैं :-))

Edit2: आगे @Martin Büttner का धन्यवाद कि वैश्विक नाम स्थान को प्रदूषित करने के लिए स्वीकार्य गोल्फ है, मुझे एक वर्ण फ़ंक्शन एप्लिकेशन की याद दिलाता है, और एक के लिए एक संक्षिप्त नाम के साथ दो अपरकेस कार्यों को बदलने और दूसरे का अनुकरण करने के लिए एक का उपयोग करके बचत करने का सुझाव देता है चार अक्षर)। (मुझे लगता है कि उसने पहले भी ऐसा किया है। :-))

Comments

अधिक गोल्फ: (आपके कोड में) के f@gबजाय का उपयोग f[g]करें। मुझे भी पूरा यकीन है कि आपको ब्लॉक की जरूरत नहीं है। बस करो (f=0>1;t=!f;c=Characters;StringJoin/@...)&। यह ग्लोबल नेमस्पेस को प्रदूषित करता है, लेकिन हम उस समय पूरी तरह से ठीक हैं जब गोल्फिंग करते हैं। इसके अलावा, मैंने कोई गिनती नहीं की है, लेकिन आप ToUpperCaseएक चर ( u, कहते हैं) और के UpperCaseQ@#साथ प्रतिस्थापित करके बाइट्स को बचाने में सक्षम हो सकते हैं #==u@#।

— मार्टिन एंडर

Answer 8

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

def j(s,g):p=lambda s,g:''.join(i.upper()if j.istitle()else i.lower()if j.islower()else i for i,j in zip(s,g));return p(s,g),p(g,s)

समारोह में एक टूपल में तार लौटता है

Comments

@ mbomb007 क्या मैं अपनी पोस्ट को संपादित करने की बात पूछ सकता हूं? मेरी राय में स्ट्राइकथ्रू गन्दा है, इसीलिए मैं कभी भी उनका उपयोग नहीं करता।

— बीटा डेके

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

— mbomb007

यह क्यों उपयोगी है, इसके आगे के विवरण के लिए यह मेटा पोस्ट देखें ।

— mbomb007

@ mbomb007 आपके द्वारा लिंक किए गए मेटा पोस्ट का स्वीकृत उत्तर है, इस बारे में कोई नीति नहीं है और इसके लिए कोई नीति बनाने की आवश्यकता नहीं है, भले ही इसके कारण उनमें से किसी एक को शामिल करना पसंद हो, इसलिए मुझे लगता है कि यह प्रत्येक पोस्टर पर निर्भर है।

— xnor

@ एक्सनोर ने उपर्युक्त बातों को संक्षेप में बताने के लिए धन्यवाद। बहुत उपयोगी।

— mbomb007

Answer 9

एर्लैंग, 157 बाइट्स

f(A,B)->S=string,G=fun(A,B)->[if Q>64andalso Q<91->S:to_upper(P);Q>96andalso Q<123->S:to_lower(P);true->P end||{P,Q}<-lists:zip(A,B)]end,G(A,B)++"\n"++G(B,A).

दो तारों (वास्तव में, सूचियों) को दो-वर्ण-सूची सूची में जोड़ देता है और प्रत्येक पात्र को सूची-बोध का उपयोग करके उपयुक्त स्थिति में मैप करता है।

Answer 10

पायथन 2, 101 बाइट्स

lambda*I:["".join([a.upper(),a.lower(),a][~-b.isalpha()or"Z"<b]for a,b in zip(*X))for X in I,I[::-1]]

एक अनाम फ़ंक्शन जो दो स्ट्रिंग्स लेता है और एक सूची में आउटपुट स्ट्रिंग्स को वापस करता है। मैंने इसे पायथन 2 के रूप में चिह्नित किया है क्योंकि पायथन 3 I,I[::-1]उस तरह से अंत में अकेले बैठने की अनुमति नहीं देता है।

Answer 11

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

t="".join;s="low","upp";y=lambda a,b:eval("a"+".%ser()"%s[b.isupper()]*b.isalpha());f=lambda a,b:(t(map(y,a,b)),t(map(y,b,a)))

समारोह fमें एक टूपल में रिटर्न देता है

Comments

यह अब तय हो गया है, यह अब सभी परीक्षण मामलों के लिए काम करता है।

— ब्लू

Answer 12

सी, 181 बाइट्स

char*x,*y;main(int a,char**_){a?x=_[2],y=_[1],main(0,0),putchar(10),x=_[1],y=_[2],main(0,0):(*x?putchar(!isupper(*x)?!islower(*x)?*y:tolower(*y):toupper(*y)),x++,y++,main(0,0):0);}

एक मानक तरीके से मानक पुस्तकालय नामों को छोटा करने में समस्या थी, (# उन्हें परिभाषित करने से ओवरहेड के 11 अक्षर लगते हैं)। तर्क के रूप में मुख्य पुनरावृत्ति और वैश्विक चर x और y का उपयोग करता है।

main (<non-zero>, argv) = call main (0, {argv [1], argv [2]}) उसके बाद newline प्रिंट करें फिर call main (0, {argv [2], argv [1]})

main (0, {x, y}) = यदि x स्ट्रिंग वापसी 0 का अंत है, तो x के पहले वर्ण का सही मामला प्रिंट करें और मुख्य (0, {x + 1, y + 1}) को कॉल करें।

दो तार के साथ तर्क के रूप में चलाएं।

Comments

क्या आप मेरा उपयोगकर्ता नाम चुरा रहे हैं? ;)

— बीटा डेके

Answer 13

सी - 164 153 बाइट्स - जीसीसी

#define r z[_][w]
main(_,z,w)char**z;{while(--_)for(w=0;r;r+=r<25?97:r<91&&r>64?z[!(_-1)+1][w]-=32,_-1?z[_-1][w]-=97:0,32:0,w++);puts(z[1]),puts(z[2]);}

gcc prog.c

./a.out AfdgF a2dfsd

अगर मैं wc -c डाउन कर सकूं तो अपडेट हो जाएगा। वास्तव में बहुत अच्छी तरह से काम करता है

Comments

क्या आप एक अनप्लग्ड संस्करण पोस्ट कर सकते हैं? मैं उत्सुक हूं कि यह कैसे काम करता है, लेकिन आपके प्रतीकों के माध्यम से पढ़ने में कठिन समय लगता है;)

— वर्टन

ज़रूर। मुझे एक मिनट दो।

— जेक

Answer 14

एफ #, 211 वर्ण

let n x y=List.fold2(fun a i j->a@match j with|c when c>='A'&&c<='Z'->[Char.ToUpper i]|c when c>='a'&&c<='z'->[Char.ToLower i]|_->[i])[](x|>Seq.toList)(y|>Seq.toList)|>String.Concat
let m a b =n a b+"\n"+n b a

बेहतर हो सकता था ...

Answer 15

मतलब, 140

function [s,t]=f(s,t)
c=s>96&s<123;C=s>64&s<91;d=t>96&t<123;D=t>64&t<91;s(c&D)=s(c&D)-32;s(C&d)=s(C&d)+32;t(d&C)=t(d&C)-32;t(D&c)=t(D&c)+32;

Ungolfed:

function [s,t] = f(s,t)
c = s>96 & s<123;         % letters that are lowercase in 1st string
C = s>64 & s<91;          % letters that are uppercase in 1st string
d = t>96 & t<123;         % letters that are lowercase in 2nd string
D = t>64 & t<91;          % letters that are uppercase in 2nd string
s(c&D) = s(c&D) - 32;     % make uppercase in 1st string
s(C&d) = s(C&d) + 32;     % make lowercase in 1st string
t(d&C) = t(d&C) - 32;     % make uppercase in 2nd string
t(D&c) = t(D&c) + 32;     % make lowercase in 2nd string

उदाहरण:

>> [s,t]=f('PRogrammiNG puzZLes & CODe golf','SdlkhkfaladlKsdlalksdg7ldklDgsl')
s =
Programming Puzzles & Code Golf
t =
SDlkhkfalADlksdLAlksdg7LDkldgsl

Answer 16

सी, 164 बाइट्स

समस्या में वर्णित एल्गोरिदम को बहुत अधिक लागू करना। इनपुट मानकों के रूप में 2 तार लेता है।

char*a,*b;main(c,v)char**v;{for(a=v[1],b=v[2];*a&&*b;++a,++b)isupper(*a)&&islower(*b)?*a+=32,*b-=32:isupper(*b)&&islower(*a)?*b+=32,*a-=32:0;puts(v[1]);puts(v[2]);}

Ungolfed:

char *a, *b; /* Helpers */

main(c, v)
char **v;
{
    /* While strings not terminated... */
    for (a = v[1], b = v[2]; *a && *b; ++a, ++b)
        isupper(*a) && islower(*b)
            ? *a += 32, *b -= 32 /* Make first string lowercase, second uppercase */
            : isupper(*b) && islower(*a)
                ? *b += 32, *a -= 32; /* Make second string lowercase, first uppercase */

    puts(v[1]); /* print out first string */
    puts(v[2]); /* print out second string */
}

Answer 17

रूबी, 102

$><<gets.chars.zip(gets.chars).map{|i|/[a-z][A-Z]|[A-Z][a-z]/=~i*''?(i.map &:swapcase):i}.transpose*''

मूल तार लेता है, सरणियों में अक्षरों को जोड़े। यदि वे या तो कम / टोपी या टोपी / निचले हैं, तो दोनों पर स्वैप करें। फिर सरणियों को वापस हमारे आदेशित सरणी में स्थानांतरित करें।

इसके लिए इनपुट में अनुगामी न्यूलाइन की आवश्यकता होती है।

Answer 18

पर्ल 5.10+, 101 99 बाइट्स

perl -p00e '/\n/;s/([a-z])(?=.{$-[0]}([a-z]))/$x=($1^$2)&" ";$s{$-[2]}=$2^$x;$1^$x/egis;s|.|$s{$-[0]}//$&|eg'

कमांड लाइन के झंडे के लिए 96 बाइट्स + 3 बाइट्स p00। इनपुट के रूप में एक सिंगल न्यूलाइन-सीमांकित स्ट्रिंग लेता है:

$ echo -e "AAAbbb111\nCc2Dd3Ee4" | perl -p00e '...'

या आप STDIN पर इनपुट दर्ज कर सकते हैं:

$ perl -p00e '...'
AAAbbb111 <Enter>
Cc2Dd3Ee4 <Ctrl+D>

टूटा:

perl -p00e'  # Slurp everything into $_, print $_ automatically at the end
    /\n/;    # Match first newline, setting $-[0] to length(s1)

    s/
        ([a-z])  # Match a single letter in s1
        (?=
            .{$-[0]}  # Match n chars where n is length(s1) (until corresponding char in s2)
            ([a-z])   # Corresponding letter in s2
        )
    /
        $x=($1^$2)&" ";   # Check whether bit 6 is the same for both chars.
                          # (Only difference between a lowercase and uppercase ASCII letter
                          # is bit 6; ASCII space is 100000 in binary)

        $s{$-[2]}=$2^$x;  # Swap case of corresponding char in s2 and store in %s,
                          # with position as the key

        $1^$x             # Swap case of current char
    /egis;

    s|.|$s{$-[0]}//$&|eg  # Do a second pass through $_. If there's a value stored in %s
                          # corresponding to this position, use it
'

Answer 19

स्कैला में पहला प्रयास, 138 वर्ण

def f(s:String,t:String)={val g=(a:Char,o:Char)=>if(o.isUpper)a.toUpper else a.toLower;s.zip(t).map(c=>(g.tupled(c),g(c._2, c._1))).unzip}

f एक ऐसा फंक्शन है जो दो इनपुट स्ट्रिंग्स को लेता है और स्ट्रिंग्स के बदलते मामले के लिए दो बार उपयोग किए जाने वाले एक स्थानीय फ़ंक्शन के साथ काम करता है।

एक ही कोड, इंडेंटेशन के साथ और बस एक पठनीय अधिक पठनीय नाम:

def f_ungolfed(first : String, second : String) = {
  val aux = (c1: Char, c2: Char) => if (c2.isUpper) c1.toUpper else c1.toLower
    first.zip(second).map(
         c => (aux.tupled(c), aux.tupled(c.swap))
    ).unzip
} 

Answer 20

जेली , 13 बाइट्स

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

दो "स्ट्रिंग्स" (जेली में पात्रों की सूची) की सूची को स्वीकार करने और लौटने वाली एक राक्षसी लिंक।

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

Answer 21

पायथन 2 , 97 बाइट्स

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

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

Answer 22

Tcl , 194 बाइट्स

proc C a\ b {proc L x\ y {expr [[set S string] is u $y]?"[$S tou $x]":"[$S is lo $y]"?"[$S tol $x]":"$x"}
lmap x [split $a ""] y [split $b ""] {append s [L $x $y]
append t [L $y $x]}
list $s $t}

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

Answer 23

हास्केल , 109 91 बाइट्स

import Data.Char
(!)=zipWith f
f c|isUpper c=toUpper|isAlpha c=toLower|1<3=id
a#b=[b!a,a!b]

@ बाइटोनी को 16 बाइट्स के लिए धन्यवाद!

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