आपकी चुनौती एक प्रोग्राम या फ़ंक्शन लिखने की है, जो समान लंबाई के दो स्ट्रिंग्स दिए जाने पर, हर दूसरे वर्ण को स्वैप करता है और आउटपुट / परिणामी स्ट्रिंग्स को किसी भी क्रम में देता है।

उदाहरण

"Hello," "world!" --> "Hollo!" "werld,"
"code" "golf" --> "codf" "gole"
"happy" "angry" --> "hnpry" "aagpy"
"qwerty" "dvorak" --> "qvertk" "dworay"
"1, 2, 3" "a, b, c" --> "1, b, 3" "a, 2, c"
"3.141592653589" "2.718281828459" --> "3.111291623489" "2.748582858559"
"DJMcMayhem" "trichoplax" --> "DrMcMoylex" "tJichapham"
"Doorknob" "Downgoat" --> "Doonkoot" "Dowrgnab"
"Halloween" "Challenge" --> "Hhlloeegn" "Caallwnee"

नियम

तार में केवल ASCII वर्ण (32-126) होंगे।
तार हमेशा एक ही लंबाई के होंगे, और कभी खाली नहीं होंगे।
आप किसी भी उपयुक्त प्रारूप में इनपुट स्वीकार कर सकते हैं: अलग पैरामीटर, एक सरणी में आइटम, एक या एक से अधिक newlines द्वारा अलग, यहां तक कि संक्षिप्त। केवल प्रतिबंध यह है कि एक स्ट्रिंग अन्य से पहले पूरी तरह से आना चाहिए है (उदाहरण के a1\nb2\nc3लिए "abc", "123"अमान्य है)।
आउटपुट या तो क्रम में हो सकता है (यानी आप पहले या दूसरे चार्ट से स्वैप करना शुरू कर सकते हैं), और ऊपर वर्णित किसी भी मान्य प्रारूप में। (2-आइटम एरे, न्यूलाइन (एस), कॉनकनेटेड, आदि द्वारा अलग किया गया)

स्कोरिंग

यह कोड-गोल्फ है , इसलिए प्रत्येक भाषा के लिए बाइट्स में सबसे छोटा कोड जीत जाता है।

code-golf string

— ETHproductions
स्रोत

11

के लिए +1 DrMcMoylex। : डी

— DJMcMayhem

3

"डाउग्राग्नाब" एनाग्राम्स टू "डाउनग्राब" (͜ʖ ° ͡) °)

— मामा फन रोल

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

— DLosc 5

@DrMcMoylex कोड, गोल्फ उदाहरण लें। यदि हम दूसरे वर्ण से शुरू करते हैं, तो हमें मिलता है: c o d f , g o l e । पहले चरित्र से शुरू: जी ओ एल ई, सी ओ डी एफ।

— DLosc

14

हास्केल, 37 बाइट्स

l=(,):flip(,):l
(unzip.).zipWith3($)l

बारी-बारी से दो तारों को घुमाते हैं, फिर पात्रों को अदला-बदली करते हैं, फिर उन्हें खोल देते हैं।

एक 37-बाइट पुनरावर्ती विकल्प:

(a:b)?(c:d)=a:d?b
e?_=e
a%b=(a?b,b?a)

— XNOR
स्रोत

9

पायथन, आई / ओ गोल्फ के साथ 42 बाइट्स

def f(a,b):a[1::2],b[1::2]=b[1::2],a[1::2]

दो सूचियों के हर दूसरे चरित्र को स्वैप करता है। वर्णों की इनपुट दो सूचियों और उन्हें संशोधित करके आउटपुट के रूप में लेता है ।

l=list('cat')
m=list('dog')    
print l,m

def f(a,b):a[1::2],b[1::2]=b[1::2],a[1::2]

f(l,m)
print l,m

देता है

['c', 'a', 't'] ['d', 'o', 'g']
['c', 'o', 't'] ['d', 'a', 'g']

— XNOR
स्रोत

1

यह चालाकी है। क्या आप इनपुट / आउटपुट फॉर्मेट्स को बहुत अधिक लचीला मानते हैं?

— ETHproductions 22

@ETHproductions यकीन नहीं है, यह ज्यादातर पायथन-विशिष्ट हो सकता है कि सूची स्ट्रिंग्स की तुलना में बहुत अधिक हेरफेर कर रही है।

— xnor

8

विम, 18 , 17 बाइट्स

qqyljvPkvPll@qq@q

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

पीछे की संगतता के कारण यह वी दुभाषिया का उपयोग करता है। इनपुट इस प्रारूप में आता है:

string1
string2

स्पष्टीकरण:

 qq                 " Start recording in register 'q'
   yl               " Yank one letter
     j              " Move down a row
      vP            " Swap the yanked letter and the letter under the cursor
        k           " Move back up a row
         vP         " Swap the yanked letter and the letter under the cursor
           ll       " Move two letters to the right. This will throw an error once we're done
             @q     " Call macro 'q' recursively
               q    " Stop recording.
                @q  " Start the recursive loop

— DJMcMayhem
स्रोत

दूसरे के बजाय जूस xका उपयोग करके दो अक्षरों को काटें :ylPvPlqqxjvPkPll@qq@q

— ह्यूलेथ

@lukasz मैंने शुरू में कोशिश की थी, लेकिन जो भी कारण से, वह इसे कई बार चलाता है और आखिरी अक्षरों को स्वैप करता है जब इसे नहीं करना चाहिए। मैं और अधिक है, हालांकि यह कुछ पर ध्यान देंगे

— DJMcMayhem

मेरे लिए v.tryitonline.net/…

— Hauleth

1

@ HasukaszNiemier उस लिंक में वही कोड है जो मैंने पोस्ट किया था। क्या आपने [save]बटन दबाया? किसी भी तरह से, यह मेरे लिए काम नहीं कर रहा है । असली कारण यह है कि जब आप xलाइन पर अंतिम वर्ण होते हैं, तो यह आपके कर्सर को बाईं ओर ले जाता है, जो स्वैप के स्थान को गड़बड़ कर देता है।

— DJMcMayhem

6

हास्केल, 41 बाइट्स

(a:b)#(c:d)=(a,c):d#b
_#_=[]
(unzip.).(#)

तार के साथ एक जोड़ी देता है। प्रयोग उदाहरण: ( (unzip.).(#) ) "Hello," "world!"-> ("Hollo!","werld,")।

सरल पुनरावर्ती दृष्टिकोण: प्रत्येक स्ट्रिंग के पहले चार को एक जोड़ी के रूप में लें और (शेष) तार की अदला-बदली के साथ एक पुनरावर्ती कॉल को जोड़ दें। unzipजोड़े की सूची में से एक सूची बनाता है।

— nimi
स्रोत

6

05AB1E , 11 10 बाइट्स

øvyNFÀ}})ø

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

व्याख्या

इनपुट = ["code", "golf"]उदाहरण के रूप में प्रयोग किया जाता है।

ø             # zip strings into list of pairs
              # STACK: ['cg', 'oo', 'dl', 'ef']
 vy           # for each pair
   NFÀ        # rotate left index times
      }}      # end-if, end-loop
              # STACK: 'cg, 'oo', 'dl', 'fe'
        )ø    # wrap in list and zip
              # OUTPUT: ['codf', 'gole']

— Emigna
स्रोत

5

पर्ल, 48 बाइट्स

Bytecount में कोड और -pध्वज के 47 बाइट्स शामिल हैं ।

say<>=~s%.\K(.)%"s/.{$-[0]}\\K(.)/$1/;\$1"%geer

साथ चलाएं -pऔर -Eझंडा। एक अलग लाइन पर प्रत्येक स्ट्रिंग की अपेक्षा करें:

perl -pE 'say<>=~s%.\K(.)%"s/.{$-[0]}\\K(.)/$1/;\$1"%geer' <<< "Hello
World"

स्पष्टीकरण :

-p: इनपुट कैप्चर करें $_और इसे अंत में प्रिंट करता है। (पहली स्ट्रिंग को प्राप्त करने और प्रिंट करने के लिए) और इसे बाहरी रेगेक्स के चरित्र के साथ बदलें (
<> : इनपुट की एक पंक्ति प्राप्त करें। (दूसरा तार पाने के लिए)।
=~: एक regex लागू करें <>:, s%%%geerजहां rसंशोधित स्ट्रिंग के लिए धन्यवाद लौटाया गया है (और फिर मुद्रित धन्यवाद say)।
रेगेक्स:
.\K(.)दो अक्षरों को खोजता है, और इस कोड के मूल्यांकन के परिणाम के साथ दूसरे को प्रतिस्थापित करेगा "s/.{$-[0]}\\K(.)/$1/;\$1":
पहला भाग, s/.{$-[0]}\\K(.)/$1/एक रेगेक्स को लागू करता है $_: .{$-[0]}बाहरी रेगेक्स के समान बिंदु पर पहुंचने के लिए पहले अक्षर को छोड़ देता है (क्योंकि $-[0]इसमें शामिल है) पहले कैप्चर ग्रुप का इंडेक्स, इसलिए उस स्थिति में अक्षरों के इंडेक्स को स्थानापन्न करना), और फिर हम एक चार्ट को कैप्चर करते हैं(.)$1 )। और फिर हम $1इसलिए जोड़ते हैं कि "s/.{$-[0]}\\K(.)/$1/;\$1"वह चरित्र है जिसे हमने आंतरिक रेगेक्स में कैप्चर किया है।
आपने ध्यान दिया होगा कि $1, चरित्र हम दोनों तार (तो दो अलग अलग वर्ण) में बदलना चाहते हैं का उल्लेख इसलिए हम साथ खेलते हैं /eeregex जो regex के दाईं ओर दो बार मूल्यांकन करता है के संशोधक: पहले एक ही विकल्प होगा $1कि isn 'से पहले नहीं था \।

— बापू
स्रोत

5

पायथन, 55 बाइट्स

lambda a,b:[(-~len(a)/2*s)[::len(a)+1]for s in a+b,b+a]

टुकड़ा करने की क्रिया!

58 बाइट्स:

def f(a,b):n=len(a);print[(s*n)[:n*n:n+1]for s in a+b,b+a]

64 बाइट्स:

f=lambda a,b,s='',t='':a and f(b[1:],a[1:],s+a[0],t+b[0])or[s,t]

पुनरावर्ती रूप से दो तारों के वर्णों को संचित करता है s और t, और अंत में उनमें से जोड़ी आउटपुट। प्रत्यावर्तन प्रत्येक पुनरावर्ती कॉल को इनपुट स्ट्रिंग स्विच करके किया जाता है। स्पेस-पृथक स्ट्रिंग को आउटपुट करना एक ही लंबाई थी:

lambda a,b,s='',t=' ':a and f(b[1:],a[1:],s+a[0],t+b[0])or s+t

यह प्रत्येक स्ट्रिंग से वैकल्पिक रूप से वर्ण लेने की एक अलग पुनरावर्ती रणनीति को हरा देता है, जिसमें से प्रत्येक में दो संभव तार पहले होते हैं। (65 बाइट्स)

g=lambda a,b:a and a[0]+g(b[1:],a[1:])
lambda a,b:(g(a,b),g(b,a))

— XNOR
स्रोत

4

MATL , 11 10 9 8 बाइट्स

1 बाइट के लिए ETHproductions का धन्यवाद!

"@X@YS&h

इनपुट एक 2 डी सरणी है जिसमें दो तार होते हैं, जैसे: ['Halloween'; 'Challenge'] :। आउटपुट स्ट्रिंग्स उल्टे क्रम में हैं।

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

व्याख्या

        % Input 2D array implicitly
"       % For each column
  @     %   Push current column
  X@    %   Push iteration index, starting at 1
  YS    %   Circularly shift the column by that amount
  &h    %   Concatenate horizontally with (concatenated) previous columns
        % End implicitly
        % Display implicitly

पुराना संस्करण: 9 बाइट्स

tZyP:1&YS

व्याख्या

        % Take input implicitly
t       % Duplicate 
        % STACK: ['Halloween'; 'Challenge'], ['Halloween'; 'Challenge']
Zy      % Size
        % STACK: ['Halloween'; 'Challenge'], [2 9]
P       % Flip array
        % STACK: ['Halloween'; 'Challenge'], [9 2]
:       % Range. Uses first element of the array as input
        % STACK: ['Halloween'; 'Challenge'], [1 2 3 4 5 6 7 8 9]
1&YS    % Circularly shift each column by those amounts respectively
        % STACK: [Caallwnee';'Hhlloeegn']
        % Display implicitly

— लुइस मेंडो
स्रोत

@ETHproductions हाँ! धन्यवाद!

— लुइस मेंडो

4

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

żṚż¥/

इनपुट अलग-अलग तर्क के रूप में है, आउटपुट को संक्षिप्त किया गया है।

इसे ऑनलाइन आज़माएं! या सभी परीक्षण मामलों को सत्यापित करें ।

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

żṚż¥/  Main link. Left argument: s (string). Right argument: t (string)

ż      Zipwith; yield the array of pairs of corresponding characters of s and t.
   ¥   Combine the two links to the left into a dyadic chain:
 Ṛ         Reverse the chain's left argument.
  ż        Zip the result with the chain's right argument.
    /  Reduce the return value of the initial ż by the quicklink Ṛż¥.

— डेनिस
स्रोत

4

जेली , ९ elly ६ बाइट्स

2 बाइट बचाने के लिए डेनिस के लिए धन्यवाद !

Zṙ"J$Z

जेली एन्कोडिंग का उपयोग करता है ।

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

— अदनान
स्रोत

आप उपयोग कर सकते हैं ṙ"J$के बजाय Ėṙ@/€। इसके अलावा, स्ट्रिंग को अलग करना आवश्यक नहीं है, इसलिए आप ड्रॉप कर सकते हैं Y।

— डेनिस

@ डेनिस आह, यह साफ है। धन्यवाद! :)

— अदनान

3

वी , 12 बाइट्स

lòyljvPkvPll

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

बहुत दिलचस्प कुछ भी नहीं है, बस मेरे विम जवाब का एक सीधा बंदरगाह ताकि मैं (लेकिन हरा नहीं) 05AB1E के साथ प्रतिस्पर्धा कर सकता हूं।

— DJMcMayhem
स्रोत

3

पाइके, 9 बाइट्स

,Fo2%I_(,

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

          - o = 0
,         -   transpose(input)
 F     (  -  for i in ^:
  o2%     -    (o++ %2)
     I_   -   if ^: i = reverse(i)
        , - transpose(^)

— नीला
स्रोत

3

जावास्क्रिप्ट (ईएस 6), 51 54

3 बाइट्स संपादित करें thx @Neil को बचाया

सरणी इनपुट / आउटपुट के साथ फ़ंक्शन

p=>p.map((w,i)=>w.replace(/./g,(c,j)=>p[i+j&1][j]))

मुझे यह एक और पसंद है, लेकिन यह 55 है (इनपुट में 2 स्ट्रिंग्स, आउटपुट में सरणी)

(a,b)=>[...a].reduce(([p,q],c,i)=>[q+c,p+b[i]],['',''])

परीक्षा

f=
p=>p.map((w,i)=>w.replace(/./g,(c,j)=>p[i+j&1][j]))

function go() {
  var a=A.value, b=B.value
  if (a.length == b.length)
    O.textContent = f([a,b]).join('\n')
  else
    O.textContent = '- different length -'
    
}

go()

<input id=A value='Hello,'><input id=B value='world!'>
<button onclick='go()'>go</button><pre id=O></pre>

स्निपेट का विस्तार करें

— edc65
स्रोत

replaceआपको 3 बाइट्स बचाता है p=>p.map((w,i)=>w.replace(/./g,(c,j)=>a[i+j&1][j])):।

— नील

2

पायथ, 8 बाइट्स

C.e_FbkC

इसे ऑनलाइन आज़माएं: प्रदर्शन

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

— Jakube
स्रोत

2

जावास्क्रिप्ट (ईएस 6), 55 बाइट्स

f=([c,...s],[d,...t],o="",p="")=>c?f(t,s,o+c,p+d):[o,p]

मैं वैकल्पिक वर्णों को बदलने के लिए regexp के उपयोग से कुछ चतुर करना चाहता था, लेकिन वह 67 57 बाइट ले रहा था :

a=>a.map((s,i)=>a[+!i].replace(/.(.?)/g,(_,c,j)=>s[j]+c))

— नील
स्रोत

अच्छा लगा। मैं f=([a,...A],[b,...B])=>a?[a+f(B,A)[0],b+f(A,B)[0]]:[""]एक ही लंबाई के लिए था ।

— ETHproductions

मुझे बहुत अच्छा करने की उम्मीद थी, लेकिन कोई रास्ता नहीं, बस 1 कम। एक गैर पुनरावर्ती उत्तर पोस्ट करने के लिए समय

— edc65

@ edc65 उपयोग करने के लिए अच्छा विचार है map, यह मेरे regexp जवाब से 10 बाइट्स मुंडा। हालांकि अभी भी बहुत लंबा है।

— नील

2

पर्ल, 40 बाइट्स

के लिए +1 शामिल है -n

STDIN पर लाइनों के रूप में तार दें

interlace.pl
hello
world
^D

interlace.pl

#!/usr/bin/perl -n
s/./${1&$.+pos}[pos]=$&/seg}{print@0,@1

— टन हास्पेल
स्रोत

2

जावा, 132 103 100 बाइट्स

केविन क्रूज़सेन को धन्यवाद देने के लिए (अन्य सुधारों के बीच) सरणी देने और 29 बाइट्स बचाने के लिए धन्यवाद! 3 बाइट्स के लिए ओलिवियर ग्रेजायर भी!

char[]c(char[]s,int l){for(int o=l;o-->0;)if(o%2>0){char t=s[o];s[o]=s[l+o+1];s[l+o+1]=t;}return s;}

इस तरह कहा जाता है:

public static void main(String[] args) {
    System.out.println(c("Hello,world!".toCharArray(), 5)); // 5 is the length of each "String"
}

आउटपुट:

Hollo,werld!

इस तथ्य का लाभ उठाता है कि इनपुट को मूल रूप से किसी भी तरह से स्वरूपित किया जा सकता है (इस मामले में, स्ट्रिंग्स का एक एकल चार सरणी जो अल्पविराम द्वारा सीमांकित किया जाता है), और बहुत उदार आउटपुट नियम भी।

— Hypino
स्रोत

नमस्ते, मूल इनपुट प्रारूप जो आपको मिला है। आप इसे कुछ और गोल्फ कर सकते हैं: char[]c(char[]s,int l){for(int o=l,t;o-->0;)if(l%2>0){t=s[l];s[l]=s[l+o+1];s[l+o+1]=(char)t;}return s;}( 103 बाइट्स ) सीधे प्रिंट होने के बजाय आउटपुट के साथ। उदाहरण इनपुट System.out.println(c("Hello,world!".toCharArray(), 5));:; उदाहरण आउटपुट: Hollo,werld!।

— केविन क्रूजसेन

यह सच है, मैंने किसी कारण से सिर्फ चार सरणी वापस करने पर विचार नहीं किया था। एक दम बढ़िया!

— हीनिनो

परिणाम होना चाहिए Hollo!werld,और नहीं Hollo,werld!(विराम चिह्न गलत है)। मेरा मानना है कि यह 5 के बजाय 6 के इनपुट मूल्य के साथ तय किया जा सकता है

— ओलिवियर ग्राईगोइरे

जब से आप के लिए डाली tहै char, तो आप इसे लूप के लिए सीधे घोषित क्यों नहीं करते हैं char? आप ऐसा करते हुए कुछ बाइट्स छोड़ देंगे।

— ओलिवियर ग्राएगोइरे

दुर्भाग्य से आप फॉर-लूप इनिशियलाइज़र के भीतर चार को घोषित नहीं कर सकते हैं, लेकिन आपने मुझे यह जांचने के लिए प्रेरित किया है कि क्या चार को अलग से घोषित करना कलाकारों की तुलना में कम होगा और यह वास्तव में 1 बाइट है।

— हाइपिनो

1

सी, 124 बाइट्स

main(c,v)char**v;{char a[99],b[99];for(c=0;v[1][c]^0;++c){a[c]=v[1+c%2][c];b[c]=v[2-c%2][c];}a[c]=0;b[c]=0;puts(a);puts(b);}

के साथ बुलाना:

program.exe string1 string2

स्ट्रिंग की लंबाई 98 वर्णों तक सीमित है।

— Steadybox
स्रोत

1

ऑक्टेव , 64 61 बाइट्स

@(x)reshape(x((t=1:end)+(2*mod(t,2)-1).*(mod(t-1,4)>1)),2,[])

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

Ideone में यह कोशिश करो ।

— लुइस मेंडो
स्रोत

1

रैकेट 208 बाइट्स

(let((sl string->list)(ls list->string)(r reverse))(let p((s(sl s))(t(sl t))(u'())(v'())(g #t))(if(null? s)
(list(ls(r u))(ls(r v)))(p(cdr s)(cdr t)(cons(car(if g s t))u)(cons(car(if g t s))v)(if g #f #t)))))

Ungolfed:

(define (f s t)
  (let ((sl string->list)                ; create short names of fns
        (ls list->string)
        (r reverse))
    (let loop ((s (sl s))                ; convert string to lists
               (t (sl t))
               (u '())                   ; create empty new lists
               (v '())
               (g #t))                   ; a boolean flag
      (if (null? s)                      ; if done, return new lists converted back to strings
          (list (ls (r u))
                (ls (r v)))
          (loop (rest s)
                (rest t)                 ; keep adding chars to new lists alternately
                (cons (first (if g s t)) u) 
                (cons (first (if g t s)) v)
                (if g #f #t))            ; alternate the boolean flag
          ))))

परिक्षण:

(f "abcdef" "123456")

आउटपुट:

'("a2c4e6" "1b3d5f")

ऊपर पुनरावर्ती संस्करण है।

Iterative संस्करण:

(let*((sl string->list)(ls list->string)(r reverse)(s(sl s))(t(sl t))(l'())(k'())(p(λ(a b g)(set! l(cons(if g a b)l))
(set! k(cons(if g b a)k)))))(for((i s)(j t)(n(in-naturals)))(p i j(if(= 0(modulo n 2)) #t #f)))(list(ls(r l))(ls(r k))))

Ungolfed:

(define (f s t)
  (let* ((sl string->list)              ; create short form of fn names
         (ls list->string)
         (r reverse)

         (s (sl s))                     ; convert strings to lists
         (t (sl t))

         (l '())                        ; create empty lists for new sequences
         (k '())

         (p (λ(a b g)                   ; fn to add chars to one or other list
              (set! l (cons (if g a b) l))
              (set! k (cons (if g b a) k)))))

    (for ((i s)(j t)(n (in-naturals)))  ; loop with both strings
          (p i j                        ; add to new lists alternately
             (if (= 0 (modulo n 2)) #t #f)))

    (list (ls (r l))                  ; convert reversed lists to strings
          (ls (r k)))))

— rnso
स्रोत

1

PowerShell v2 +, 82 बाइट्स

param($a,$b)$i=0;[char[]]$a|%{$c+=($_,$b[$i])[$i%2];$d+=($b[$i],$_)[$i++%2]};$c;$d

~~फिर भी गोल्फ ...~~ नहीं। अन्य उत्तरों की तरह रेगेक्स (कॉपी एल्गोरिदम पर बू) का उपयोग किए बिना किसी भी नीचे इसे गोल्फ नहीं कर सकते।

तो हम लेते हैं $aऔर $bतार के रूप में, सूचकांक $iको सेट करते हैं 0, $aएक- charऐरे के रूप में डालते हैं, और इसे एक लूप के माध्यम से भेजते हैं |%{...}। प्रत्येक पुनरावृत्ति, हम एक सरणी-चयन में अनुक्रमण करके $cऔर $d(यानी, इसलिए यह आगे और पीछे की ओर अनुक्रमित करते हुए) स्ट्रिंग-सुगम होते हैं । फिर, हम पाइपलाइन पर $cऔर छोड़ देते हैं $d, और निहितार्थ के माध्यम से आउटपुट Write-Outputप्रोग्राम पूरा होने पर होता है।

— AdmBorkBork
स्रोत

1

Lithp , 120 अक्षर (+3 फ्लैग -v1 फ्लैग के लिए)

पठनीयता के लिए 2 में लाइन विभाजन:

#P::((invoke P "map" (js-bridge #W,I::(replace W (regex "." "g")
     (js-bridge #C,J::(index (index P (& (+ I J) 1)) J))))))

की आवश्यकता है -v1 ध्वज की हैrun.js क्योंकि कुछ कार्य मानक पुस्तकालय का हिस्सा नहीं हैं।

नमूना उपयोग:

(
    (def f #P::((invoke P "map" (js-bridge #W,I::(replace W (regex "." "g")
                (js-bridge #C,J::(index (index P (& (+ I J) 1)) J)))))))
    (print (f (list "Hello," "world!")))
)

इस तरह की हाइलाइट्स जो मैंने मानक पुस्तकालय पर पर्याप्त समय नहीं बिताई हैं। उपयोग करने के लिएjs-bridge/1 का उपयोग कर दो बार और लंबे समय regex रूप है, साथ ही लागू नक्शाinvoke/* यह सब बहुत लंबे समय तक की तुलना में यह करने की जरूरत किया जा रहा करने के लिए योगदान।

मेरे मानक पुस्तकालय पर काम करने का समय मुझे अधिक लगता है।

— Andrakis
स्रोत

1

PHP, 79 बाइट्स

for(;$i<=strlen(($a=$argv)[1]);$y.=$a[2-$i%2][$i++])echo$a[1+$i%2][+$i]??" $y";

पिछला संस्करण PHP, 82 बाइट्स

for(;$i<strlen(($a=$argv)[1]);$y.=$a[2-$i%2][$i++])$x.=$a[1+$i%2][$i];echo"$x $y";

— जार्ग हुल्सरमन
स्रोत

for(...)echo$a[1+$i%2][$i];echo" $y";(-2)

— टाइटस

टाइटस की टिप्पणी for(;$i<=strlen(($a=$argv)[1]);$y.=$a[2-$i%2][$i++])echo$a[1+$i%2][$i]??" $y";का निर्माण आगे एक -2 है, हालांकि इसके लिए php 7 की आवश्यकता है

— user59178

@ user59178 अच्छा है, लेकिन आपको 1 बाइट की आवश्यकता है

— Jörg Hülsermann

क्या आप? यह मेरे लिए काम करता है, आप बस एकNotice: String offset cast occurred in Command line code on line 1

— user59178

@ user59178 पहले शब्द के पहले अक्षर को प्रिंट करने के लिए हाँ

— Jörg Hülsermann

1

सी, 54 52 बाइट्स

f(char*a,char*b,char*c){while(*c++=*a++,*c++=*b++);}

उत्पादन ग्रहण करता है c में पहले से ही वांछित लंबाई है।

उपयोग:

main(){
 char a[]="123456";
 char b[]="abcdef";
 char c[sizeof(a)+sizeof(b)-1];
 f(a,b,c);
 puts(c);

}

यदि आप आउटपुट बनाने पर जोर देते हैं, तो यहां 91 बाइट्स समाधान है:

char*g(char*a,char*b){char*c=malloc(2*strlen(a)),*d=c;while(*c++=*a++,*c++=*b++);return d;}

उपयोग:

main(){
 char a[]="123456";
 char b[]="abcdef";
 puts(g(a,b));
}

— कार्ल नेफ
स्रोत

0

सी, 150 बाइट्स

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

प्रोग्राम को कमांड लाइन से स्ट्रिंग्स की उम्मीद है, और इस तरह, प्रोग्राम को साथ चलाया जाना चाहिए ./a.out string1 string2।

main(int a,char**v){int x=strlen(v[1]);char s[x],t[x],c;strcpy(s,v[1]);strcpy(t,v[2]);for(a=0;a<x;++a)if(a%2)c=s[a],s[a]=t[a],t[a]=c;puts(s),puts(t);}

या अधिक कानूनी रूप से,

main(int a,char**v){
    int x=strlen(v[1]);
    char s[x],t[x],c;
    strcpy(s,v[1]);strcpy(t,v[2]);
    for(a=0;a<x;++a)
        if(a%2)c=s[a],s[a]=t[a],t[a]=c;
    puts(s),puts(t);
}

— जेम्स मर्फी
स्रोत

0

गणितज्ञ, 51 बाइट्स

एक ही प्रारूप में आउटपुट के साथ, वर्णों के दो सरणियों के एक सरणी के रूप में इनपुट लेता है। फ़ंक्शन केवल (मॉड 2) ऑपरेशन का उपयोग करके नए सरणी का निर्माण करता है।

Table[#[[Mod[j+i,2]+1,j]],{i,2},{j,Length@#[[1]]}]&

— ग्रेग मार्टिन
स्रोत

0

QBasic 4.5, 172 बाइट्स

आउच, इस एक दर्दनाक के साथ राजभाषा 'QBasic ...

DEFSTR A-D:INPUT A,B
IF LEN(A)MOD 2=1 THEN A=A+" ":B=B+" "
FOR x=1 TO LEN(A) STEP 2
C=C+MID$(A,x,1)+MID$(B,x+1,1):D=D+MID$(B,x,1)+MID$(A,x+1,1):NEXT:?RTRIM$(C),RTRIM$(D)

मज़ेदार तथ्य: का उपयोग कर DEFSTRअधिक बाइट्स से यह खर्च क्योंकि अब मैं इस्तेमाल कर सकते हैं बचाया Aबजाय a$।

— steenbergh
स्रोत

0

क्यूबिक , 112 बाइट्स

QBIC QBasic बॉयलरप्लेट को बहुत अधिक सुव्यवस्थित कर सकता है, लेकिन मुख्य MID$इंजन को QBasic में अभी भी करने की आवश्यकता है क्योंकि QBIC में विकल्प-फ़ंक्शन का अभाव है। फिर भी, मुझे 60 बाइट्स बचाता है।

;;_LA|~a%2=1|A=A+@ | B=B+C][1,a,2|X=X+$MID$(A$,b,1)+MID$(B$,b+1,1):Y$=Y$+MID$(B$,b,1)+MID$(A$,b+1,1)|]?_tX|,_tY|

— steenbergh
स्रोत

MIND$=> MIN$पाठ में।

— नहीं कि

0

जावा, 68 बाइट्स

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

अनगढ़ और परीक्षण

import java.util.Arrays;
import java.util.Collection;
import java.util.function.BiConsumer;

public class Main {

  static BiConsumer<char[], char[]> func = (left, right) -> {
      for (int i = left.length; --i > 0;) {
        char temp = left[--i];
        left[i] = right[i];
        right[i] = temp;
      }
    };

  public static void main(String[] args) {
    test("Hello,","world!", "Hollo!", "werld,");
    test("code", "golf", "codf", "gole");
    test("happy", "angry", "hnpry", "aagpy");
  }

  private static void test(String left, String right, String x, String y) {
    char[] leftChars = left.toCharArray();
    char[] rightChars = right.toCharArray();
    func.accept(leftChars, rightChars);
    Collection mixed = Arrays.asList(new String(leftChars), new String(rightChars));
    if (mixed.containsAll(Arrays.asList(x, y))) {
      System.out.println("OK");
    } else {
      System.out.printf("NOK: %s, %s -> %s%n", left, right, mixed);
    }
  }
}

— ओलिवियर ग्रेजायर
स्रोत

0

एपीएल, १२

{↓(⍳⍴⊃⍵)⊖↑⍵}

स्पष्टीकरण: {...} एक फ़ंक्शन को परिभाषित करता है, ... सही तर्क है। टेक (str) दो तारों से एक मैट्रिक्स बनाता है, फिर प्रत्येक कॉलम (⊖) को n बार घुमाता है, जहाँ n कोष्ठक (⍳⍴⊃⍵) में भाग होता है। इसे पहले तर्क की लंबाई के रूप में परिभाषित किया गया है। (पूर्व: लंबाई = ५ ==> १ २ ३ ४ ५)। तो पहले कॉलम को एक बार घुमाया जाता है, दूसरे को दो बार (मूल स्थिति में वापस लाने पर), तीसरा कॉलम तीन बार, आदि ...

इसे tryapl.org पर देखें

— मोरिस ज़ुक्का
स्रोत

इंटरलेसिंग स्ट्रिंग्स

उदाहरण

नियम

स्कोरिंग

हास्केल, 37 बाइट्स

पायथन, आई / ओ गोल्फ के साथ 42 बाइट्स

विम, 18 , 17 बाइट्स

हास्केल, 41 बाइट्स

05AB1E , 11 10 बाइट्स

पर्ल, 48 बाइट्स

पायथन, 55 बाइट्स

MATL , 11 10 9 8 बाइट्स

व्याख्या

पुराना संस्करण: 9 बाइट्स

व्याख्या

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

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

जेली , ९ elly ६ बाइट्स

वी , 12 बाइट्स

पाइके, 9 बाइट्स

जावास्क्रिप्ट (ईएस 6), 51 54

पायथ, 8 बाइट्स

जावास्क्रिप्ट (ईएस 6), 55 बाइट्स

पर्ल, 40 बाइट्स

जावा, 132 103 100 बाइट्स

सी, 124 बाइट्स

ऑक्टेव , 64 61 बाइट्स

रैकेट 208 बाइट्स

PowerShell v2 +, 82 बाइट्स

Lithp , 120 अक्षर (+3 फ्लैग -v1 फ्लैग के लिए)

PHP, 79 बाइट्स

सी, 54 52 बाइट्स

सी, 150 बाइट्स

गणितज्ञ, 51 बाइट्स

QBasic 4.5, 172 बाइट्स

क्यूबिक , 112 बाइट्स

जावा, 68 बाइट्स

अनगढ़ और परीक्षण

एपीएल, १२