Interleaving Sequences

18

Interleaved sequences แสดงถึงการรวมของลำดับบางอย่างโดยพลการ

ลำดับ interleaved สามารถทำได้โดยการผนวกองค์ประกอบไปยังรายการหนึ่งโดยหนึ่งจากจำนวนรายการบางรายการเลือกองค์ประกอบต่อไปจากบางรายการในแต่ละครั้ง ดังนั้นลำดับ interleaved จะมีองค์ประกอบเดียวกันทั้งหมดของรายการทั้งหมดรวมกันในลำดับที่สอดคล้องกับรายการทั้งหมด

interleaving เพียง 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]

กฎระเบียบ

  • ช่องโหว่มาตรฐานต้องห้าม (duh)
  • อินพุตอาจถูกนำมาใช้ในรูปแบบที่สมเหตุสมผลเช่นรายการลิสต์รายการวาร์เกตรายการพารามิเตอร์ ฯลฯ ... ตราบใดที่ยังไม่มีความชัดเจนที่รายการเริ่มต้นและสิ้นสุด
  • ผลลัพธ์อาจอยู่ในรูปแบบที่สมเหตุสมผลตราบเท่าที่ชัดเจนว่ารายการเริ่มต้นและสิ้นสุด ผลลัพธ์ที่ถูกต้องรวมถึง แต่ไม่ จำกัด เฉพาะ:
    • stdout โดยมีหนึ่งรายการต่อบรรทัด
    • รายการของรายการ
    • ตัววนซ้ำในรายการ (สามารถนำไปใช้กับตัวสร้างได้หากภาษาของคุณมี)
  • คำสั่งของการแทรกสอดที่เกิดขึ้นไม่สำคัญอย่างไรก็ตามไม่ควรมีการแทรกซ้ำใด ๆ ซ้ำอีก
  • เพื่อลดความซับซ้อนของการตรวจจับซ้ำคุณอาจสมมติว่าองค์ประกอบทั้งหมดในลำดับการป้อนข้อมูลทั้งหมดไม่ซ้ำกัน
  • หากไม่มีรายการใดเป็นอินพุตทั้งรายการว่างและไม่มีเอาต์พุตเป็นเอาต์พุตที่ถูกต้อง
  • ประเภทขององค์ประกอบในลำดับนั้นไม่เกี่ยวข้อง (เช่นพวกเขาทั้งหมดอาจเป็นหนึ่งประเภทหรือยำประเภทซึ่งแล้วแต่ว่าอะไรจะสะดวกในภาษาของคุณ)
  • โปรแกรม / ฟังก์ชั่นของคุณจะต้องรับประกันว่าจะยุติในเวลาที่ จำกัด
  • นี่คือรหัสกอล์ฟดังนั้นรหัสที่สั้นที่สุดสำหรับแต่ละภาษาจะชนะ
code-golf  sequence 
— Beefster
แหล่งที่มา
interleaving รายการเดียวเท่านั้นคือรายการที่ว่างเปล่า นั่นหมายความว่าเราต้องเอาท์พุท[[]]แทนที่จะเป็น[]เมื่อเราไม่ได้รับรายการใด ๆ เป็นอินพุต?
— Erik the Outgolfer
นอกจากนี้รายการจะมีความยาวเท่ากันหรือไม่
— Erik the Outgolfer
ฉันคิดว่ามันจะมีสติทางคณิตศาสตร์เพื่อส่งกลับไม่มีรายการเป็นผลลัพธ์ถ้าไม่มีรายการที่ได้รับเป็นอินพุต ฉันจะอนุญาตให้ทั้งสอง รายการผลลัพธ์ทั้งหมดจะมีความยาวเท่ากัน รายการอินพุตอาจแตกต่างกันไปตามความยาว
— Beefster

คำตอบ:

5

Python 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

ลองออนไลน์!

หรือ:

Python 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]คำแนะนำของNeilแทนที่จะenumerateเข้าใกล้

ใช้รายการของรายการAเป็นอินพุต ถ้าองค์ประกอบทั้งหมดของAที่ว่างเปล่าแล้วรายการประเมินในจะว่างเปล่าเพื่อให้เราได้มาถึงจุดสิ้นสุดของการเรียกซ้ำและกระป๋องif printมิฉะนั้นเราจะมีรายชื่อของหนึ่งหรือมากกว่าNone's; และพวกเรากลับมา

— Chas Brown
แหล่งที่มา
[x[0]]คือx[:1]
— xnor
@xnor: แน่นอน! ขอบคุณ!
— Chas Brown
3

Ruby, 66 ไบต์

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

หากไม่มีลำดับที่ไม่ว่างให้ส่งคืนลำดับว่าง มิฉะนั้นสำหรับแต่ละลำดับที่ไม่ว่างให้ทำการลบออกโดยลบองค์ประกอบแรกออกแล้วเพิ่มเข้าไปที่จุดเริ่มต้นของผลลัพธ์แต่ละรายการ การดำเนินการใช้สมมติฐานที่ว่าองค์ประกอบที่มีการรับประกันจะไม่ซ้ำกันทั่วโลกมิฉะนั้นa-[b]อาจจะลบมากกว่า 1 ลำดับจากโทร recursive แม้ว่าในการไตร่ตรองบางทีนั่นอาจเป็นพฤติกรรมที่ถูกต้องเพื่อหลีกเลี่ยงผลลัพธ์ที่ซ้ำกัน

ตัวอย่าง 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

ภาษา Wolfram (Mathematica) , 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 ทั้งหมดหรือไม่

การใช้งาน interleaving ที่แท้จริง 117 ไบต์

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

ลองออนไลน์!

— จองฮมิน
แหล่งที่มา
2

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

ลองออนไลน์! คำตอบของ JavaScript พอร์ตของฉัน แก้ไข: บันทึกแล้ว 3 ไบต์ด้วย @ChasBrown

— นีล
แหล่งที่มา
-3 โดยการแทนที่ด้วยsum(a,[]) any(a)
— Chas Brown
@ChasBrown ขอบคุณฉันไม่รู้ Python ที่ดี
— Neil
Neil: ก็พอแล้วฉันคิดว่า :) sum(a,[])มีประโยชน์อย่างมากในบางสถานการณ์!
— Chas Brown
2

Haskell , 45 ไบต์

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

ลองออนไลน์!

ที่ดัดแปลงมาจากChas บราวน์ตอบหลาม

max[[]]เป็นเคล็ดลับที่จะให้กรณีฐานของ[[]]เมื่อป้อนข้อมูลที่มีเพียง[]องค์ประกอบ ในกรณีที่รายการที่ใช้สำหรับว่าง recursing ว่างเปล่าและจะช่วยให้max[[]][][[]]

เมื่อเรียกซ้ำแทนที่จะปล่อยองค์ประกอบแรกของรายการที่เลือกh:tเราสร้างรายการใหม่ด้วยtที่ด้านหน้าและh:tกรองออก

— XNOR
แหล่งที่มา
0

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

Scala: (ไม่ได้ตั้งใจให้มีน้อยที่สุดเป็นแหล่งอ้างอิงที่ชัดเจนยิ่งขึ้น)

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

ลองออนไลน์!

— Satyagraha
แหล่งที่มา
1
อย่างน้อยคุณควรพยายามที่จะเล่นกอล์ฟรหัสนี้ ...
— Timtech
โดยการใช้ไซต์ของเรา หมายความว่าคุณได้อ่านและทำความเข้าใจนโยบายคุกกี้และนโยบายความเป็นส่วนตัวของเราแล้ว
Licensed under cc by-sa 3.0 with attribution required.