दो तारों को इंटरलेव करने के सभी संभावित तरीके

Question

मैंने हाल ही में स्टैकओवरफ्लो पर यह प्रश्न देखा । यह एक महान सवाल है, लेकिन सवाल के साथ एक घातक समस्या है। वे इसे करने का सबसे अच्छा तरीका पूछ रहे हैं। उदाहरण के लिए, पढ़ने में सबसे आसान, सबसे मुहावरेदार, साफ-सुथरा आदि। क्या वे नहीं जानते कि क्या मायने नहीं रखता? आप इसे कोड के सबसे कम बाइट्स के साथ कैसे करें, इसके बारे में पूछने वाले हैं!

चूंकि मुझे संदेह है कि स्टैकओवरफ्लो पर सवाल की सराहना की जाएगी, इसलिए मैंने इसे यहां पूछने का फैसला किया।

चुनौती

आपको सबसे कम संभव प्रोग्राम या फ़ंक्शन लिखना होगा जो किसी भी दो मनमाने तारों को इंटरलेव करने के लिए सभी संभव तरीके उत्पन्न करता है। उदाहरण के लिए, यदि दो तार हैं 'ab'और 'cd', आउटपुट है:

['abcd', 'acbd', 'acdb', 'cabd', 'cadb', 'cdab']

जैसा कि आप देख सकते हैं, aहमेशा से पहले है b, और cहमेशा से पहले है d।

IO किसी भी उचित प्रारूप में हो सकता है। अपने आउटपुट की जांच करने के लिए इस अजगर कोड का उपयोग करें। (क्रेडिट: JeD )

def shuffle(s,t):
    if s=="":
        return [t]
    elif t=="":
        return [s]
    else:
        leftShuffle=[s[0]+val for val in shuffle(s[1:],t)]
        rightShuffle=[t[0]+val for val in shuffle(s,t[1:])]
        leftShuffle.extend(rightShuffle)
        return leftShuffle

नमूना IO:

shuffle("$", "1234"):
['$1234', '1$234', '12$34', '123$4', '1234$']

shuffle("az", "by"):
['azby', 'abzy', 'abyz', 'bazy', 'bayz', 'byaz']

shuffle("code", "golf"):
['codegolf', 'codgeolf', 'codgoelf', 'codgolef', 'codgolfe', 'cogdeolf', 'cogdoelf',
'cogdolef', 'cogdolfe', 'cogodelf', 'cogodlef', 'cogodlfe', 'cogoldef', 'cogoldfe',
'cogolfde', 'cgodeolf', 'cgodoelf', 'cgodolef', 'cgodolfe', 'cgoodelf', 'cgoodlef',
'cgoodlfe', 'cgooldef', 'cgooldfe', 'cgoolfde', 'cgoodelf', 'cgoodlef', 'cgoodlfe',
'cgooldef', 'cgooldfe', 'cgoolfde', 'cgolodef', 'cgolodfe', 'cgolofde', 'cgolfode',
'gcodeolf', 'gcodoelf', 'gcodolef', 'gcodolfe', 'gcoodelf', 'gcoodlef', 'gcoodlfe',
'gcooldef', 'gcooldfe', 'gcoolfde', 'gcoodelf', 'gcoodlef', 'gcoodlfe', 'gcooldef',
'gcooldfe', 'gcoolfde', 'gcolodef', 'gcolodfe', 'gcolofde', 'gcolfode', 'gocodelf',
'gocodlef', 'gocodlfe', 'gocoldef', 'gocoldfe', 'gocolfde', 'goclodef', 'goclodfe',
'goclofde', 'goclfode', 'golcodef', 'golcodfe', 'golcofde', 'golcfode', 'golfcode']

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

Comments

कोड का सबसे अच्छा बाइट्स इसे करने का सबसे अच्छा तरीका है, हर एक जानता है कि! * (अस्वीकरण: सीआर नहीं)।

— R

क्या सभी पात्र अलग हैं? या जरूरी नहीं?

— aditsu 1

वास्तव में ... आपके "कोड", "गोल्फ" उदाहरण में आपके पास डुप्लिकेट "ओ" और डुप्लिकेट परिणाम भी हैं, उदाहरण के लिए 'gcoodelf'। मुझे लगता है कि तुम क्या चाहते हो।

— 2

"मुझे यह बहुत अच्छा सवाल लगा। हालांकि, एक घातक दोष है: वे चाहते हैं कि यह अच्छा हो!"

— साइओस

आपको "एएबी", "बीसी" के लिए नमूना आईओ प्रदान करना चाहिए।

— तैमिर

Answer 1

अजगर, २६

M?G?H++LhGgtGH+LhHgGtH]G]H

इसे यहाँ आज़माएँ

यह दिए गए पुनरावर्ती सूत्र का एक बहुत ही बुनियादी कार्यान्वयन है। यह एक फ़ंक्शन को परिभाषित gकरता है जो आवश्यक कार्य करता है। यह लिंक एक संशोधित कार्यक्रम है जो एसटीडीआईएन नई लाइन से स्ट्रिंग्स को अलग-अलग सुविधाजनक होने के लिए पढ़ता है। फ़ंक्शन को कॉल करने के लिए g<string1><string2>।

विस्तार:

M                ##  Define a function g taking two arguments: G and H
 ?G?H ... ]G]H   ##  Two ternaries: if G is empty return a list containing H
                 ##  if H is empty return a list containing G
   +             ##  otherwise return these next two lists joined together
   +LhGgtGH      ##  the first letter of G added to each result of a recursive call to g
                 ##  with G missing its first character and H
   +LhHgGtH      ##  the same as above but with G and H swapped

दो पुनरावर्ती कॉल बहुत समान हैं, लेकिन मैं उन्हें किसी भी अधिक गोल्फ के लिए एक रास्ता नहीं मिल पाया है।

Answer 2

हास्केल, 53 48 बाइट्स

a%""=[a]
a%b=[x:t|(x:y,z)<-[(a,b),(b,a)],t<-y%z]

एक फ़ंक्शन %को परिभाषित करता है जिसके लिए a%bतार तार की a,bएक सूची देता है।

दो तारों को देखते हुए, हम पहले चरित्र को लेने के लिए दोनों में से एक को चुनते हैं। फिर हम प्रत्येक परिणाम के लिए उस चरित्र को प्रस्तुत करते हुए शेष दो तारों पर फिर से बैठते हैं।

जब स्ट्रिंग में से एक खाली होता है, तो एकमात्र संभव परिणाम अन्य स्ट्रिंग होता है। ""%""=[""]यह भी पर्याप्त होगा, लेकिन यह अधिक लंबा है।

---

53 बाइट्स:

a@(b:c)%d@(e:f)=((b:)<$>c%d)++((e:)<$>a%f)
a%d=[a++d]

एक फ़ंक्शन %को परिभाषित करता है जिसके लिए a%dतार तार की a,dएक सूची देता है।

फ़ंक्शन को पुनरावर्ती रूप से परिभाषित किया गया है। यदि हम पहले स्ट्रिंग से एक पात्र लेते हैं, तो उसे दूसरे स्ट्रिंग के साथ पहले स्ट्रिंग के शेष पर पुनरावर्ती कॉल के प्रत्येक परिणाम के लिए तैयार किया जाना चाहिए। अन्य स्ट्रिंग के लिए सममित रूप से।

आधार मामले के लिए, यदि तारों में से एक खाली है, तो परिणाम उनके संघनन की एकल-तत्व सूची है। यह प्रत्येक स्ट्रिंग के खाली होने के दो मामलों से कम है।

Comments

@aditsu उफ़, मेरा मतलब था ""%""=[""]।

— xnor

यह एक अजीब बात है कि आप पर सटीक एक ही भाषा में एक बाइट जीतने का

— गर्व है

Answer 3

हास्केल, 47

(x:s)#b=(x:)<$>s%b
a#b=[]
[]%b=[b]
a%b=a#b++b#a

% वह ऑपरेटर है जो इस चुनौती को हल करता है।

#एक संचालक है जो दो सूचियों में लेता है और उन्हें इंटरलेव करने के सभी तरीके ढूंढता है जैसे कि पहला वर्ण पहले स्ट्रिंग से है (एक किनारे मामले के साथ - यदि पहली सूची खाली है, तो परिणाम एक खाली सूची है) %।

फिर, %सिर्फ #दो बार आवेदन करके काम करता है ।

संपादित करें: पिछले संस्करण में एक बग था , जिसमें ""%""वापस लौटा ["",""], इसलिए मैंने इसे ठीक किया। यह आधार मामले को जोड़कर तय किया गया था %, जो तब उसी लंबाई के आधार मामले को हटाने की अनुमति देता #था (जो वास्तव में, बहुत मतलब नहीं था)।

Comments

@ निमि लेकिन प्रकार के बेमेल - (#) :: [a]->[a]->[[a]] , a::[a]और इसलिए परिणाम प्रकार का होना चाहिए[[a]]

— गर्व हैस्केलर

उफ़, आप सही कह रहे हैं। माफ़ कीजिये।

— नमि

Answer 4

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

f=lambda*p:[x[0]+t for x,y in p,p[::-1]for t in x and f(x[1:],y)]or['']

उदाहरण रन:

>> f('ab','AB')
['abAB', 'aABb', 'aAbB', 'ABab', 'AabB', 'AaBb']

दो तारों को देखते हुए x,yहम इसके पहले चरित्र को ले सकते हैं xऔर इसे गायब होने के साथ पुनरावर्ती कॉल के प्रत्येक परिणाम के लिए प्रस्तुत कर सकते हैं f(x[1:],y)। या, हम उसी के साथ xऔर yस्विच कर सकते हैं । लेने से x,yया तो इनपुट के रूप में pया उसके उलट `p [:: - 1], हम दोनों संभावनाओं मिलता है।

खाली स्ट्रिंग से लेने से बचने के लिए x, हम तार्किक शॉर्ट-सर्किट के साथ x and। यदि दोनों तार खाली हैं, तो न तो स्ट्रिंग हो सकती है xऔर न ही हमें संभावनाओं की खाली सूची मिलती है, जिसे हम orसही आधार मामले के साथ ठीक करते हैं ['']।

पायथन 3 (73 बाइट्स) में एक समान जेनेरिक रणनीति:

f=lambda p,s='':[f((x[1:],y),s+x[0])for x,y in[p,p[::-1]]if x]or print(s)

Comments

ये किस तरह का जादू है?! (+1)

— एड

Answer 5

पायथन, 80

अनुरोध के अनुसार, यहां एक अजगर का जवाब है:

f=lambda a,b,c='':[c+x for x in[a+b][a>''<b:]or f(a[1:],b,a[0])+f(a,b[1:],b[0])]

4 बाइट खाने के लिए Sp3000 धन्यवाद :)

Answer 6

CJam, 38

q~L{_2$e&{_2$(\@jf+@@(@@jf++}{+a}?}2jp

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

डायनेमिक प्रोग्रामिंग (मेमोइज्ड रिकर्सन का उपयोग करके)।

स्पष्टीकरण:

q~         read and evaluate the input (2 strings)
L{…}2j     calculate with memoized recursion with no initial cache and 2 arguments
  _2$      copy the 2 strings
  e&{…}    if they are both non-empty
    _2$    copy the strings again (they're in reverse order)
    (      take out the first character of the first string
    \@     move the strings after the character
    j      solve recursively
    f+     prepend the character to all results
    @@     bring the other copy of the strings on top (in order)
    (      take out the first character of the second string
    @@     move the strings after the character
    j      solve recursively
    f+     prepend the character to all results
    +      concatenate the 2 sets of results
  {…}      else
    +      concatenate the 2 strings (at least one is empty)
    a      put the result in an array
  ?        end if
p          pretty-print the results for the input strings

Answer 7

CJam, 32 बाइट्स

qN/_:,eeWf%e~e!\f{\{_2$=(ot}/No}

इसका परीक्षण यहां करें।

यह वास्तव में गोल्फ की तरह लगता है, लेकिन अभी तक मुझे केवल 4 वैकल्पिक समाधान मिले हैं जो सभी की बाइट गिनती है:

qN/_ee{),*~}%e!\f{\{_2$=(ot}/No}
l_:!l_0f>@+])e!\f{\{_2$=(ot}/No}
ll__3$:!+.=])e!\f{\{_2$=(ot}/No}
qN/[_:,2,]ze~e!\f{\{_2$=(ot}/No} (found by Sp3000)

मूल विचार 0एस और 1एस के सभी क्रमपरिवर्तन को उत्पन्न करना है, जिसके परिणाम में प्रत्येक वर्ण को लेने के लिए स्ट्रिंग है। यही सब कुछ है और इसमें शामिल है e!। बाकी तो बस दो तार से उस क्रम में वर्ण बाहर खींचता है।

Comments

अच्छा लगा, मैंने उस विचार के बारे में सोचा लेकिन यह नहीं सोचा कि यह अच्छी तरह से गोल्फ कर सकता है।

— एडिट्स

@aditsu हम वास्तव में क्या जरूरत है के बीच एक मिश्रण है e*और .*जो एक अलग राशि से प्रत्येक तत्व को दोहराता है। ;) (ऐसा करने के लिए एक ऑपरेटर :a.*:~। मुझे लगता है कि e*इसके लिए इस्तेमाल किया जा सकता है क्योंकि यह वर्तमान में त्रुटियां हैं यदि दो सूचियां दी गई हैं।)

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

Answer 8

जावास्क्रिप्ट (फ़ायरफ़ॉक्स 30-57), 88 84 81 बाइट्स

(s,t,g=(v,w)=>v[1]?f(v.slice(1),w).map(x=>v[0]+x):[v+w])=>[...g(s,t),...g(t,s)]

संपादित करें: मेरी समाप्ति स्थिति में सुधार करके 4 बाइट्स सहेजे गए। सहेजे गए 3 बाइट्स @ edc65 की बदौलत।

Comments

प्रकाशित करने के लिए बहुत करीब है, लेकिन एक नज़र है - यह कम है:f=(a,b,z=(v,w)=>v[1]?f(v.slice(1),w).map(x=>v[0]+x):[v+w])=>z(a,b).concat(z(b,a))

— edc65

@ edc65 बहुत अच्छा; मैंने कोशिश की और vइस शर्त के रूप में उपयोग करने में विफल रहा , लेकिन इसका उपयोग करने के लिए मेरे साथ ऐसा कभी नहीं हुआ v[1]।

— नील

Answer 9

ब्रेकीलॉग , 8 बाइट्स

p~cᵐz₁cc

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

इनपुट चर के माध्यम से दो तारों की सूची के रूप में इनपुट लेता है, और आउटपुट चर के माध्यम से सभी संभव इंटरलेविंग्स उत्पन्न करता है। चूंकि परीक्षण के मामलों में डुप्लिकेट इंटरलेक्शन की अनुमति देने के लिए लगता है जहां साझा पत्र हैं, मैंने उनसे बचने के लिए कोई ध्यान नहीं दिया है, लेकिन यह बहुत अधिक डुप्लिकेट उत्पन्न करता है और न कि केवल साझा पत्रों के साथ। (यदि इसकी अनुमति नहीं है, लेकिन साझा किए गए अक्षर डुप्लिकेट आवश्यक नहीं हैं, तो {}ᵘआउटपुट के लिए लिपटने के लिए केवल तीन बाइट्स जोड़ सकते हैं, कोई डुप्लिकेट नहीं है।)

p           A permutation of
            the input variable
   ᵐ        with each element
 ~c         arbitrarily partitioned,
    z       zipped
     ₁      without cycling,
      cc    and concatenated twice
            is the output variable.

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

ब्रेकीलॉग , 17 बाइट्स

p~cᵐ{lᵐ-ℕ<2&}z₁cc

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

अतिरिक्त कोड, {lᵐ-ℕ<2&}किसी भी विभाजन जोड़ी को विफल कर देता है जहां कोई भी बाहरी विभाजन बनाया जाता है। (मैं पायथन शेल में आसान आउटपुट चेकिंग के लिए उद्धरणों के साथ प्रिंट करने के लिए TIO पर हेडर बदल दिया।)

Answer 10

MATL , 34 30 बाइट्स

h1Mgw~hY@Xu!ttYs*w~tYs1Gn+*+!)

यह इस उत्तर से एक विचार का उपयोग करता है : यदि स्ट्रिंग्स के लैंथ्स हैं mऔर n, बिट्स सेट के m+nसाथ सभी बिट पैटर्न की गणना करें m। एक तरीका यह है कि गणना है: mलोगों और nशून्य के साथ एक वेक्टर के सभी क्रमपरिवर्तन उत्पन्न करें और फिर डुप्लिकेट को हटा दें।

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

व्याख्या

h     % implicitly input the two strings of lengths m and n. Concatenate
1M    % push the two strings again
g     % convert the second strings into ones
w~    % swap. Convert the second string into zeros
h     % concatenate: vector of zeros and ones
Y@    % 2D array with all permutations of that vector, each on a row
Xu    % remove duplicate rows
!     % transpose
ttYs  % duplicate twice. Cumulative sum along each column
*     % element-wise product. Produces, in each column, indices for
      % elements of the first string; 1, 2,...,m. The rest are 0
w~    % swap, negate
tYs   % duplicate. Cumulative sum along each column
1Gn+  % add length of first input
*     % element-wise product. Produces, in each column, indices for
      % elements of the second string: m+1,...,m+n. The rest are 0
+     % add. This gives indices into the concatenated string created initially
!     % transpose back
)     % index into concatenated string. Implicitly display

Answer 11

रूबी, 83 बाइट्स

एक पुनरावर्ती कार्य जो कि [a+b]उन दोनों तारों के खाली होने पर वापस लौटता है। अन्यथा, यह स्ट्रिंग की सूची में a[0] + every string in v[a[1..-1],b]जोड़े गए स्ट्रिंग की एक सूची देता हैb[0] + every string in v[a,b[1..-1]]

v=->a,b{a[0]&&b[0]?v[a[1..-1],b].map{|i|a[0]+i}+v[a,b[1..-1]].map{|i|b[0]+i}:[a+b]}

Answer 12

बैच, 154 152 बाइट्स

@if "%~1%~2"=="" echo %3
@set t=%~1
@if not "%t%"=="" call %0 "%t:~1%" "%~2" %3%t:~,1%
@set t=%~2
@if not "%t%"=="" call %0 "%~1" "%t:~1%" %3%t:~,1%