Serpiştirme Dizileri

18

Serpiştirilmiş sekanslar, bazı sekansların keyfi birleşmesini temsil eder.

Bir araya getirilmiş dizi, listeye her seferinde bazı listelerden bir sonraki öğeyi seçerek bazı listelerden öğeleri tek tek ekleyerek yapılabilir. Bu nedenle, serpiştirilmiş bir sekans, tüm listelerle tutarlı bir sırayla birleştirilen tüm listelerin tam olarak aynı öğelerini içerecektir.

1 listenin tek eklemesi aynı listedir.

Meydan okuma

Zorluğunuz, rasgele sayıda dizi alan ve bu dizilerin olası tüm eklemelerini çıkaran bir işlev / program oluşturmaktır.

Örnekler

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]

kurallar

  • Standart boşluklar yasak (duh)
  • Giriş, listelerin başladığı ve bittiği açık olduğu sürece, herhangi bir makul formatta, örneğin bir liste listesi, vararg listesi, parametre listeleri vb.
  • Çıktılar, listelerin nerede başladığı ve bittiği açık olduğu sürece herhangi bir makul biçimde olabilir. Geçerli çıktılar aşağıdakileri içerir, ancak bunlarla sınırlı değildir:
    • stdout, satır başına bir liste ile
    • Liste listesi
    • Listeler üzerinden bir yineleyici (diliniz varsa bir jeneratörle uygulanabilir)
  • Elde edilen serpiştirme işlemlerinin sırası önemli değildir, ancak tekrarlanan serpiştirme işlemleri olmamalıdır.
  • Tekrar algılamayı basitleştirmek için, tüm giriş dizilerindeki tüm öğelerin benzersiz olduğunu varsayabilirsiniz.
  • Girdi olarak liste verilmezse, hem boş liste hem de çıktı yok geçerli çıktılardır.
  • Dizilerdeki elemanların türleri önemsizdir. (örneğin, dilinizde hangisi daha uygunsa, hepsi bir tür veya bir tür karışıklık olabilir)
  • Programınızın / fonksiyonunuzun sınırlı bir süre içinde sonlanacağı garanti edilmelidir.
  • Bu kod golf , bu yüzden her dil için en kısa kod kazanır.
code-golf  sequence 
— Beefster
kaynak
Hiçbir listenin tek eklemesi boş listedir. Bu, girdi olarak liste verilmediğinde [[]]değil, çıktı almak zorunda olduğumuz anlamına mı geliyor []?
— Erik the Outgolfer
Ayrıca, listeler eşit uzunlukta olacak mı?
— Erik the Outgolfer
Herhangi bir liste girdi olarak verilmemişse, hiçbir listeyi çıktı olarak döndürmek matematiksel olarak aklı başında olur. Her ikisine de izin vereceğim. Tüm çıktı listeleri eşit uzunlukta olacaktır. Giriş listelerinin uzunluğu değişebilir.
— Beefster

Yanıtlar:

5

Python 2 , 103 92 79 78 bayt

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

Çevrimiçi deneyin!

Veya:

Python 3 , 73 bayt

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

Çevrimiçi deneyin!

-1 değiştirerek [x[0]]ile x[:1]uygun olarak XNOR

-13 tarafından bayt utanmadan çalmak üzerine genişleterek [b[b==x:]for b in A]önerdiği gibi Neil'in yerine daha uzun cevap enumerateyaklaşımı.

Listelerin bir listesini Agirdi olarak alır. Öğesinin tüm öğeleri Aboşsa, içinde değerlendirilen liste ifboş olacaktır, bu nedenle özyineleme ve kutu sonuna ulaştık print. Aksi takdirde, bir veya daha fazla None'lerin bir listesi var ; ve çekiyoruz.

— Chas Kahve
kaynak
[x[0]]olduğunux[:1]
— xnor
@xnor: tabii ki! Teşekkür!
— Chas Brown
4

Jöle , 11 bayt

FŒ!fЀ⁼ṛɗÐf

Çevrimiçi deneyin!

Nasıl çalışır

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.
— Dennis
kaynak
3

Ruby, 66 bayt

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

Boş olmayan diziler yoksa, boş bir dizi döndürün. Aksi takdirde, boş olmayan her sekans için, birinci eleman çıkarılmış halde tekrarlayın ve ardından her sonucun başına ekleyin. Uygulama, öğelerin küresel olarak benzersiz olduğu garanti edildiğini varsayar, aksi takdirde a-[b]özyinelemeli çağrıdan 1'den fazla diziyi kaldırabilir. Yansımasına rağmen, belki de yinelenen çıktılardan kaçınmak için doğru davranış olabilir.

Örnek ES:

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
kaynak
2

Wolfram Dili (Mathematica) , 76 75 71 bayt

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

Çevrimiçi deneyin!

Saf yaklaşım: girdinin araya eklenmesi olan tüm permütasyonları bulun.

açıklama

Permutations[Join@@#]

<input>Tüm permütasyonlarını düzleştirin ve bulun.

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

Tüm elemanları bulun x...

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

Derinlik-2'deki tüm parçaları <input>ilgili konumlarına yerleştirin x.

And@@OrderedQ/@ ...

Tüm derinlik-1 listelerinin sıralanıp sıralanmadığını kontrol edin (örn. Artan sırada).

Serpiştirme işleminin gerçek uygulaması, 117 bayt

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

Çevrimiçi deneyin!

— JungHwan Min
kaynak
2

Python 2 , 87 84 bayt

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

Çevrimiçi deneyin! JavaScript yanıtımın bağlantı noktası. Düzenleme: @ChasBrown sayesinde 3 bayt kaydedildi.

— Neil
kaynak
-3 değiştirerek sum(a,[])ile any(a).
— Chas Brown
@ChasBrown Teşekkürler, Python'u o kadar iyi tanımıyorum.
— Neil
Neil: Yeterince iyi, sanırım :). sum(a,[])bazı durumlarda hoş bir kullanımı var!
— Chas Brown
2

Haskell , 45 bayt

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

Çevrimiçi deneyin!

Chas Brown'un Python cevabından uyarlandı .

Bu max[[]], [[]]yalnızca []öğelerin ne zaman girdi içerdiğini gösteren bir temel durumdur . Bu durumda, boş, özyineleme için kullanılan liste boştur ve max[[]][]verir [[]].

Tekrarlanırken, seçilen listenin ilk öğesini seçici olarak bırakmak yerine , ön tarafta h:tyeni bir liste oluşturur tve h:tfiltreleniriz.

— XNOR
kaynak
0

JavaScript (Firefox 30-57), 92 bayt

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]]:[[]]
— Neil
kaynak
0

Japt -Q , 14 bayt

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.

Girdileri bir dizi dizisi olarak alır. -Qçıktının dizi gösterimini korumasını sağlar.

Burada deneyin.

— Sirke
kaynak
0

Scala: (minimal olması amaçlanmamış, daha açık bir referans kaynağı)

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

Çevrimiçi deneyin!

— satyagraha
kaynak
1
En azından bu kodu golf
— oynamaya çalışmalısın
Sitemizi kullandığınızda şunları okuyup anladığınızı kabul etmiş olursunuz: Çerez Politikası ve Gizlilik Politikası.
Licensed under cc by-sa 3.0 with attribution required.