ইন্টারলেভিং সিকোয়েন্সস

Question

আন্তঃবাহিত সিকোয়েন্সগুলি কয়েকটি সিকোয়েন্সগুলির একটি স্বেচ্ছাসেবী সংযুক্তিকে উপস্থাপন করে।

কয়েকটি তালিকা থেকে একের পর এক উপাদানকে তালিকায় যুক্ত করে একটি আন্তঃবাহিত ক্রম তৈরি করা যেতে পারে, প্রতিটি সময় কিছু তালিকা থেকে পরবর্তী উপাদান নির্বাচন করে। সুতরাং, একটি আন্তঃবাহিত ক্রম সমস্ত তালিকার সাথে সামঞ্জস্যপূর্ণ ক্রমের সাথে মিলিত সমস্ত তালিকার ঠিক একই উপাদানগুলিকে ধারণ করবে।

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]

বিধি

• স্ট্যান্ডার্ড লুফোলগুলি নিষিদ্ধ (দুহ)
• ইনপুট যেকোন যুক্তিসঙ্গত ফর্ম্যাটে নেওয়া যেতে পারে, যেমন তালিকার তালিকা, তালিকার তালিকাভুক্ত তালিকা, প্যারামিটারের তালিকা ইত্যাদি ... যতক্ষণ না এটি স্পষ্ট থাকে যেখানে তালিকাগুলি শুরু হয় এবং শেষ হয়।
• আউটপুট যে কোনও যুক্তিসঙ্গত ফর্ম্যাটে থাকতে পারে, যতক্ষণ স্পষ্ট থাকে যে তালিকাগুলি কোথায় শুরু হয় এবং শেষ হয়। বৈধ আউটপুট অন্তর্ভুক্ত, তবে অগত্যা সীমাবদ্ধ নয়:
  • স্ট্যান্ডআউট, প্রতি লাইনে একটি তালিকা রয়েছে
  • তালিকার একটি তালিকা
  • তালিকাগুলির উপরে একটি পুনরাবৃত্তকারী (যদি আপনার ভাষা থাকে তবে একটি জেনারেটরের সাথে প্রয়োগ করা যেতে পারে)
• উত্পাদিত আন্তঃবিবাহের ক্রমের বিষয়টি বিবেচনা করে না, তবে, কোনও পুনরাবৃত্তি আন্তঃব্যবস্থা হওয়া উচিত নয়।
• পুনরাবৃত্তি সনাক্তকরণকে সহজ করার জন্য, আপনি ধরে নিতে পারেন যে সমস্ত ইনপুট অনুক্রমের সমস্ত উপাদান অনন্য।
• যদি ইনপুট হিসাবে কোনও তালিকা না দেওয়া থাকে তবে খালি তালিকা এবং কোনও আউটপুট উভয়ই বৈধ আউটপুট।
• অনুক্রমের উপাদানগুলির প্রকারগুলি অপ্রাসঙ্গিক। (উদাঃ এগুলি সবই এক ধরণের বা এক ধরণের ধরণের মশ্মিশ হতে পারে, যেটি আপনার ভাষায় আরও সুবিধাজনক)
• আপনার প্রোগ্রাম / ফাংশন একটি সীমাবদ্ধ সময়ের মধ্যে অবসান গ্যারান্টিযুক্ত হতে হবে।
• এটি কোড-গল্ফ , তাই প্রতিটি ভাষার জন্য সংক্ষিপ্ততম কোড জিততে পারে।

Comments

কোনও তালিকার একমাত্র ইন্টারলিভিং হ'ল খালি তালিকা। তার মানে কি আমাদের যখন ইনপুট হিসাবে কোনও তালিকা দেওয়া না হয় তার [[]]পরিবর্তে আউটপুট []দিতে হয়?

— এরিক আউটগলফার

এছাড়াও, তালিকাগুলির সমান দৈর্ঘ্য হবে?

— এরিক আউটগল্ফার

আমি মনে করি যে কোনও তালিকা ইনপুট হিসাবে দেওয়া না হলে কোনও ফলাফলকে আউটপুট হিসাবে ফেরত দেওয়া গণিতের বুদ্ধিমানের কাজ হবে। দুজনকেই অনুমতি দেব। সমস্ত আউটপুট তালিকা সমান দৈর্ঘ্য হবে। ইনপুট তালিকাগুলি দৈর্ঘ্যে পৃথক হতে পারে।

— গরুর মাংসের মাংস

Answer 1

হাস্কেল , 84 77 76 বাইট

foldl((.(!)).(>>=))[[]]
a#b=(b:)<$>a
x@(a:c)!y@(b:d)=x!d#b++c!y#a
a!b=[a++b]

7 লাইটের জন্য @ লিন এবং একটি বাইটের জন্য @ ব্যবহারকারী 9549915 কে ধন্যবাদ!

এটি অনলাইন চেষ্টা করুন!

Comments

কিছু বন্ধনী থেকে মুক্তি পেয়ে 76 বাইট

— ব্যবহারকারী 9549915

Answer 2

পাইথন 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, খালি হতে হবে যাতে আমরা recursion ও করতে পারেন শেষে পৌঁছেছেন print। অন্যথায়, আমাদের কাছে এক বা একাধিক'র একটি তালিকা রয়েছে None; এবং আমরা পুনরাবৃত্তি।

Comments

[x[0]]হলx[:1]

— xnor

@ এক্সনোর: অবশ্যই! ধন্যবাদ!

— চ্যাস ব্রাউন

Answer 3

জেলি , 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.

Answer 4

রুবি, 66 বাইট

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

যদি খালি খালি অনুক্রম না থাকে তবে খালি অনুক্রমটি ফিরে আসুন। অন্যথায়, প্রতিটি খালি খালি অনুক্রমের জন্য, সরানো প্রথম উপাদানটির সাথে পুনরাবৃত্তি করুন এবং প্রতিটি ফলাফলের শুরুতে এটি যুক্ত করুন। বাস্তবায়ন এই ধারণাটি ব্যবহার করে যে উপাদানগুলি বিশ্বব্যাপী অনন্য হওয়ার গ্যারান্টিযুক্ত, অন্যথায় a-[b]পুনরাবৃত্ত কল থেকে সম্ভাব্য 1 টিরও বেশি ক্রম সরিয়ে ফেলতে পারে। যদিও প্রতিচ্ছবিতে, ডুপ্লিকেট আউটপুট এড়ানোর জন্য এটি সম্ভবত সঠিক আচরণ হবে।

আইও উদাহরণ:

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]]

Answer 5

ওল্ফ্রাম ভাষা (গণিত) , 76 75 71 বাইট

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

এটি অনলাইন চেষ্টা করুন!

নিষ্পাপ পদ্ধতির: ইনপুটটির আন্তঃবিভাজনযুক্ত সমস্ত অনুমতি সন্ধান করুন।

ব্যাখ্যা

Permutations[Join@@#]

ফ্ল্যাট করুন <input>এবং এর আদেশের সমস্ত সন্ধান করুন।

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

সমস্ত উপাদান xযেমন সন্ধান করুন ...

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

সমস্ত আইটেমের গভীরতা -2 এ <input>তাদের নিজ নিজ অবস্থানের সাথে প্রতিস্থাপন করুন x।

And@@OrderedQ/@ ...

সমস্ত গভীরতা -1 তালিকাগুলি অর্ডার করা হয়েছে কিনা (যেমন ক্রমবর্ধমান ক্রমে) পরীক্ষা করুন।

ইন্টারলিভিংয়ের বাস্তব বাস্তবায়ন, ১১7 বাইট

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

এটি অনলাইন চেষ্টা করুন!

Answer 6

পাইথন 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[[]]

এটি অনলাইন চেষ্টা করুন! আমার জাভাস্ক্রিপ্ট উত্তর পোর্ট। সম্পাদনা: @ চ্যাসব্রাউনকে 3 বাইট সংরক্ষণ করা হয়েছে।

Comments

-3 দিয়ে প্রতিস্থাপন sum(a,[])করে any(a)।

— চ্যাস ব্রাউন

@ চ্যাশব্রাউন ধন্যবাদ, আমি পাইথনকে খুব ভাল জানি না।

— নীল

নীল: ঠিক আছে, আমি মনে করি :)। sum(a,[])যদিও কিছু পরিস্থিতিতে চমৎকার ব্যবহার আছে!

— চ্যাস ব্রাউন

Answer 7

হাস্কেল , 45 বাইট

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

এটি অনলাইন চেষ্টা করুন!

চ্যাস ব্রাউন এর পাইথন উত্তর থেকে অভিযোজিত ।

max[[]]একটি কৌতুক একটি বেস কেস দিতে হয় [[]]যখন ইনপুট শুধুমাত্র রয়েছে []উপাদান। সেক্ষেত্রে খালি, পুনরাবৃত্তি করার জন্য ব্যবহৃত তালিকাটি খালি, এবং max[[]][]দেয় [[]]।

পুনরাবৃত্তি করার সময়, নির্বাচিত তালিকার প্রথম উপাদানটি নির্বাচিতভাবে বাদ দেওয়ার পরিবর্তে h:t, আমরা tসামনে এবং h:tফিল্টার আউট দিয়ে একটি নতুন তালিকা তৈরি করি ।

Answer 8

জাভাস্ক্রিপ্ট (ফায়ারফক্স 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]]:[[]]

Answer 9

জাপট -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আউটপুট অ্যারে স্বরলিপি সংরক্ষণ করে তোলে।

এখানে চেষ্টা করুন।

Answer 10

স্কেলা: (আরও স্বল্প রেফারেন্স রিসোর্সটি ন্যূনতম হওয়ার উদ্দেশ্যে নয়)

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

এটি অনলাইন চেষ্টা করুন!

Comments

আপনার এই কোডটি কমপক্ষে গল্ফ করার চেষ্টা করা উচিত ...

— টিমটেক