इंटरक्लेविंग अनुक्रम

18

इंटरलेव्ड सीक्वेंस कुछ संख्या के सीक्वेंस के एक मनमाने विलय का प्रतिनिधित्व करते हैं।

तत्वों की संख्या को सूची से जोड़कर एक इंटरलेयर्ड अनुक्रम बनाया जा सकता है, जो हर बार किसी सूची में से अगले तत्व को चुनकर कुछ सूचियों में से एक हो जाता है। इसलिए, एक interleaved अनुक्रम में सभी सूचियों के अनुरूप क्रम में सभी सूचियों के समान तत्व शामिल होंगे।

1 सूची का एकमात्र इंटरलेयिंग वही सूची है।

चुनौती

आपकी चुनौती एक ऐसा फंक्शन / प्रोग्राम बनाना है, जो कई तरह के सीक्वेंस लेता हो और उन सीक्वेंस के सभी संभव इंटरलेव्स को आउटपुट करता हो।

उदाहरण

Input: [1, 2], [3, 4]
Output:
    [1, 2, 3, 4]
    [1, 3, 2, 4]
    [1, 3, 4, 2] 
    [3, 1, 2, 4]
    [3, 1, 4, 2]
    [3, 4, 1, 2]

Input: [1, 2, 3, 4, 5]
Output:
    [1, 2, 3, 4, 5]

Input: []
Output:
    []

Input: <nothing>
Output:
    []

(also acceptable)
Input: <nothing>
Output: <nothing>

Input: [1, 2, 3], [4, 5]
Output:
    [1, 2, 3, 4, 5]
    [1, 2, 4, 3, 5]
    [1, 2, 4, 5, 3]
    [1, 4, 2, 3, 5]
    [1, 4, 2, 5, 3]
    [1, 4, 5, 2, 3]
    [4, 1, 2, 3, 5]
    [4, 1, 2, 5, 3]
    [4, 1, 5, 2, 3]
    [4, 5, 1, 2, 3]

Input: [1, 2], [3, 4], [5, 6]
Output:
    [1, 2, 3, 4, 5, 6]
    [1, 2, 3, 5, 4, 6]
    [1, 2, 3, 5, 6, 4]
    [1, 2, 5, 3, 4, 6]
    [1, 2, 5, 3, 6, 4]
    [1, 2, 5, 6, 3, 4]
    [1, 3, 2, 4, 5, 6]
    [1, 3, 2, 5, 4, 6]
    [1, 3, 2, 5, 6, 4]
    [1, 3, 4, 2, 5, 6]
    [1, 3, 4, 5, 2, 6]
    [1, 3, 4, 5, 6, 2]
    [1, 3, 5, 2, 4, 6]
    [1, 3, 5, 2, 6, 4]
    [1, 3, 5, 4, 2, 6]
    [1, 3, 5, 4, 6, 2]
    [1, 3, 5, 6, 2, 4]
    [1, 3, 5, 6, 4, 2]
    [1, 5, 2, 3, 4, 6]
    [1, 5, 2, 3, 6, 4]
    [1, 5, 2, 6, 3, 4]
    [1, 5, 3, 2, 4, 6]
    [1, 5, 3, 2, 6, 4]
    [1, 5, 3, 4, 2, 6]
    [1, 5, 3, 4, 6, 2]
    [1, 5, 3, 6, 2, 4]
    [1, 5, 3, 6, 4, 2]
    [1, 5, 6, 2, 3, 4]
    [1, 5, 6, 3, 2, 4]
    [1, 5, 6, 3, 4, 2]
    [3, 1, 2, 4, 5, 6]
    [3, 1, 2, 5, 4, 6]
    [3, 1, 2, 5, 6, 4]
    [3, 1, 4, 2, 5, 6]
    [3, 1, 4, 5, 2, 6]
    [3, 1, 4, 5, 6, 2]
    [3, 1, 5, 2, 4, 6]
    [3, 1, 5, 2, 6, 4]
    [3, 1, 5, 4, 2, 6]
    [3, 1, 5, 4, 6, 2]
    [3, 1, 5, 6, 2, 4]
    [3, 1, 5, 6, 4, 2]
    [3, 4, 1, 2, 5, 6]
    [3, 4, 1, 5, 2, 6]
    [3, 4, 1, 5, 6, 2]
    [3, 4, 5, 1, 2, 6]
    [3, 4, 5, 1, 6, 2]
    [3, 4, 5, 6, 1, 2]
    [3, 5, 1, 2, 4, 6]
    [3, 5, 1, 2, 6, 4]
    [3, 5, 1, 4, 2, 6]
    [3, 5, 1, 4, 6, 2]
    [3, 5, 1, 6, 2, 4]
    [3, 5, 1, 6, 4, 2]
    [3, 5, 4, 1, 2, 6]
    [3, 5, 4, 1, 6, 2]
    [3, 5, 4, 6, 1, 2]
    [3, 5, 6, 1, 2, 4]
    [3, 5, 6, 1, 4, 2]
    [3, 5, 6, 4, 1, 2]
    [5, 1, 2, 3, 4, 6]
    [5, 1, 2, 3, 6, 4]
    [5, 1, 2, 6, 3, 4]
    [5, 1, 3, 2, 4, 6]
    [5, 1, 3, 2, 6, 4]
    [5, 1, 3, 4, 2, 6]
    [5, 1, 3, 4, 6, 2]
    [5, 1, 3, 6, 2, 4]
    [5, 1, 3, 6, 4, 2]
    [5, 1, 6, 2, 3, 4]
    [5, 1, 6, 3, 2, 4]
    [5, 1, 6, 3, 4, 2]
    [5, 3, 1, 2, 4, 6]
    [5, 3, 1, 2, 6, 4]
    [5, 3, 1, 4, 2, 6]
    [5, 3, 1, 4, 6, 2]
    [5, 3, 1, 6, 2, 4]
    [5, 3, 1, 6, 4, 2]
    [5, 3, 4, 1, 2, 6]
    [5, 3, 4, 1, 6, 2]
    [5, 3, 4, 6, 1, 2]
    [5, 3, 6, 1, 2, 4]
    [5, 3, 6, 1, 4, 2]
    [5, 3, 6, 4, 1, 2]
    [5, 6, 1, 2, 3, 4]
    [5, 6, 1, 3, 2, 4]
    [5, 6, 1, 3, 4, 2]
    [5, 6, 3, 1, 2, 4]
    [5, 6, 3, 1, 4, 2]
    [5, 6, 3, 4, 1, 2]

नियम

  • मानक कमियां निषिद्ध (डुह)
  • इनपुट को किसी भी उचित प्रारूप में लिया जा सकता है, उदाहरण के लिए सूचियों की एक सूची, सूचियों की वैरग सूची, पैरामीटर सूचियाँ, आदि ... जब तक यह अस्पष्ट है जहाँ सूचियाँ शुरू होती हैं और समाप्त होती हैं।
  • आउटपुट किसी भी उचित प्रारूप में हो सकता है, इसलिए जब तक यह स्पष्ट न हो जाए कि सूची कहाँ से शुरू और समाप्त होती है। मान्य आउटपुट शामिल हैं, लेकिन आवश्यक रूप से सीमित नहीं हैं:
    • stdout, प्रति पंक्ति एक सूची के साथ
    • सूचियों की एक सूची
    • सूचियों पर एक पुनरावृत्ति (एक जनरेटर के साथ लागू किया जा सकता है अगर आपकी भाषा उनके पास है)
  • यील्ड इंटरलेविंग्स का क्रम मायने नहीं रखता है, हालांकि, किसी भी दोहराया इंटरलेव्स नहीं होना चाहिए।
  • रिपीट डिटेक्शन को सरल बनाने के लिए, आप मान सकते हैं कि सभी इनपुट अनुक्रमों में सभी तत्व अद्वितीय हैं।
  • यदि इनपुट के रूप में कोई सूची नहीं दी गई है, तो खाली सूची और कोई आउटपुट दोनों वैध आउटपुट नहीं हैं।
  • अनुक्रमों में तत्वों के प्रकार अप्रासंगिक हैं। (उदाहरण के लिए वे सभी एक प्रकार के हो सकते हैं या एक प्रकार के मश्मिश हो सकते हैं, जो भी आपकी भाषा में अधिक सुविधाजनक हो)
  • आपका कार्यक्रम / कार्य समय की एक सीमित मात्रा में समाप्त करने की गारंटी होनी चाहिए।
  • यह कोड-गोल्फ है , इसलिए प्रत्येक भाषा के लिए सबसे छोटा कोड जीतता है।
code-golf  sequence 
— Beefster
स्रोत
बिना सूची के केवल इंटरलेविंग खाली सूची है। इसका मतलब यह है कि जब हम इनपुट के रूप में कोई सूची नहीं दी जाती है तो हमें [[]]इसके बजाय आउटपुट करना होगा []?
— एरिक आउटगॉल्फ
इसके अलावा, क्या सूचियों की लंबाई समान होगी?
— एरिक आउटगॉल्फ
मुझे लगता है कि अगर कोई सूची इनपुट के रूप में नहीं दी गई है तो इसे आउटपुट के रूप में कोई सूची वापस करने के लिए गणितीय रूप से समझदार होगा। मैं दोनों की अनुमति दूंगा। सभी आउटपुट सूचियां समान लंबाई की होंगी। इनपुट सूची लंबाई में भिन्न हो सकती है।
— बीफस्टर

जवाबों:

5

पायथन 2 , 103 92 79 78 बाइट्स

def f(A,c=[]):
 if not[f([b[b==x:]for b in A],c+x[:1])for x in A if x]:print c

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

या:

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

def f(A,c=[]):[f([b[b==x:]for b in A],c+x[:1])for x in A if x]or print(c)

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

-1 की जगह [x[0]]के साथ x[:1]अनुसार XNOR

-13 बाइट बेशर्मी से चोरी का विस्तार करने के [b[b==x:]for b in A]रूप में नील के जवाब के बजाय लंबे enumerateदृष्टिकोण से सुझाव दिया ।

Aइनपुट के रूप में सूचियों की एक सूची लेता है । यदि सभी तत्व Aखाली हैं, तो ifवसीयत में मूल्यांकन की गई सूची खाली है, इसलिए हम पुनरावृत्ति और कर सकते हैं print। अन्यथा, हमारे पास एक या एक से अधिक Noneकी सूची है ; और हम पुनरावृत्ति करते हैं।

— चास ब्राउन
स्रोत
[x[0]]हैx[:1]
— xnor
@xnor: बिल्कुल! धन्यवाद!
— चास ब्राउन
4

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

FŒ!fЀ⁼ṛɗÐf

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

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

FŒ!fЀ⁼ṛɗÐf  Main link. Argument: A (array of arrays)

F            Flatten A.
 Œ!          Take all permutations.
        ɗÐf  Filter by the chain to the left, keeping only permutations for which
             it returns a truthy value.
   fЀ         Intersect the permutation with each array in A.
      ⁼ṛ       Test if the result is equal to A.
— डेनिस
स्रोत
3

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

f=->a,*p{(a-=[[]])[0]?a.flat_map{|b|h,*t=b;f[a-[b]+[t],*p,h]}:[p]}

यदि कोई गैर-खाली क्रम नहीं हैं, तो एक खाली अनुक्रम लौटाएं। अन्यथा, प्रत्येक गैर-खाली अनुक्रम के लिए, हटाए गए पहले तत्व के साथ पुनरावृत्ति करें और फिर इसे प्रत्येक परिणाम की शुरुआत में जोड़ें। कार्यान्वयन इस धारणा का उपयोग करता है कि तत्वों को विश्व स्तर पर अद्वितीय होने की गारंटी दी जाती है, अन्यथा a-[b]संभावित रूप से पुनरावर्ती कॉल से 1 से अधिक अनुक्रम निकाल सकता है। हालांकि प्रतिबिंब पर, हो सकता है कि वास्तव में डुप्लिकेट आउटपुट से बचने के लिए सही व्यवहार हो।

उदाहरण IO:

f[[[1,2],[3,4]]] => [[1, 3, 2, 4], [1, 3, 4, 2], [1, 2, 3, 4], [3, 1, 4, 2], [3, 1, 2, 4], [3, 4, 1, 2]]

— histocrat
स्रोत
2

वोल्फ्राम लैंग्वेज (गणितज्ञ) , 76 75 71 बाइट्स

Cases[Permutations[Join@@#],x_/;And@@OrderedQ/@(x~Position~#&/@#&/@#)]&
(* or *)
Cases[Join/*Permutations@@#,x_/;And@@(x~Position~#&/@#&/*OrderedQ/@#)]&

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

Naive approach: उन सभी क्रमपरिवर्तन को खोजें जो इनपुट के इंटरलेव हैं।

व्याख्या

Permutations[Join@@#]

<input>अपने सभी क्रमपरिवर्तन को समतल करें और खोजें।

Cases[ ... ,x_/; ...]

सभी तत्वों को xऐसे खोजें ...

(x~Position~#&/@#&/@#)

सभी वस्तुओं <input>को उनकी संबंधित स्थिति के साथ गहराई -2 में बदलें x।

And@@OrderedQ/@ ...

जांचें कि क्या सभी डेप्थ -1 सूचियां ऑर्डर की जाती हैं (यानी बढ़ते क्रम में)।

इंटरलाकिंग का वास्तविक कार्यान्वयन, 117 बाइट्स

Cases[{}~(f=ReplaceList[#2,{{a___,{b_,c___},d___}/;b>0:>#~Join~{b}~f~{a,{c},d},_:>#}]&)~#,{___},{Tr[1^(Join@@#)]+1}]&

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

— जंगवान मिन
स्रोत
2

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

f=lambda a:any(a)and[b[:1]+c for b in a if b for c in f([c[c==b:]for c in a])]or[[]]

इसे ऑनलाइन आज़माएं! मेरे जावास्क्रिप्ट उत्तर का पोर्ट। संपादित करें: @ChasBrown के लिए 3 बाइट्स सहेजे गए।

— नील
स्रोत
-3 के sum(a,[])साथ प्रतिस्थापित करके any(a)।
— चास ब्राउन
@ChasBrown धन्यवाद, मैं पायथन को अच्छी तरह से नहीं जानता।
— नील
नील: बहुत अच्छा, मुझे लगता है :)। sum(a,[])कुछ स्थितियों में अच्छा उपयोग है, हालांकि!
— चास ब्राउन
2

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

f l=max[[]][h:y|h:t<-l,y<-f$t:filter(/=h:t)l]

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

चास ब्राउन के पायथन उत्तर से अनुकूलित ।

max[[]]एक चाल के आधार मामले दे रहा है [[]]जब इनपुट केवल शामिल []तत्वों। उस स्थिति में, खाली, पुनरावर्ती के लिए उपयोग की जाने वाली सूची खाली है, और max[[]][]देता है [[]]।

चयनित सूची के पहले तत्व को चुनने के बजाय, जब हम पुनरावृत्ति करते हैं, तो h:tहम tसामने की ओर एक नई सूची बनाते हैं और h:tफ़िल्टर कर देते हैं।

— XNOR
स्रोत
0

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

f=a=>a.some(b=>b+b)?[for(b of a)if(b+b)for(c of f(a.map(c=>c.slice(c==b))))[b[0],...c]]:[[]]
— नील
स्रोत
0

जाप -Q , 14 बाइट्स

c á f@e_XfZ eZ
c              // Flatten the input into a single array
  á            // and find all permutations.
    f          // Then filter the results for items
     @e_       // where for each original input
        XfZ eZ // the ordering of the items is unchanged.

सरणी के एक सरणी के रूप में इनपुट लेता है। -Qआउटपुट सरणी संकेतन को संरक्षित करता है।

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

— लीख
स्रोत
0

स्केल: (कम से कम, अधिक स्पष्ट संदर्भ संसाधन का इरादा नहीं)

object Interleave {

  private def interleavePair[A](x: Seq[A], y: Seq[A]): Seq[Seq[A]] =
    (x, y) match {
      case (a +: c, b +: d) =>
        interleavePair(x, d).map(b +: _) ++ interleavePair(c, y).map(a +: _)
      case _ => Seq(x ++ y)
    }

  def interleave[A](ssa: Seq[Seq[A]]): Seq[Seq[A]] =
    ssa.foldLeft[Seq[Seq[A]]](Seq(Seq.empty)) {
      case (sssat, sa) => sssat.flatMap(interleavePair(sa, _))
    }
}

object Main extends App {

  import Interleave._

  println(interleave(Seq()))
  println(interleave(Seq(Seq(1, 2), Seq(3, 4))))
}

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

— सत्याग्रह
स्रोत
1
आपको कम से कम इस कोड को गोल्फ करने की कोशिश करनी चाहिए ...
— टिमटेक
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.