인터리빙 시퀀스

18

인터리빙 된 시퀀스는 몇 개의 시퀀스의 임의 병합을 나타냅니다.

인터리브 된 시퀀스는 매번 일부 목록에서 다음 요소를 선택하여 몇 개의 목록에서 요소를 하나씩 목록에 추가하여 만들 수 있습니다. 따라서 인터리브 된 시퀀스에는 모든 목록과 일치하는 순서대로 모든 목록에서 정확히 동일한 요소가 결합됩니다.

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)
  • 입력이 목록의 시작과 끝이 모호하지 않는 한, 목록의 목록, vararg 목록의 목록, 매개 변수 목록 등과 같은 합리적인 형식으로 입력 될 수 있습니다.
  • 리스트가 시작하고 끝나는 곳이 분명한 한, 출력은 합리적인 형식 일 수 있습니다. 유효한 출력에는 다음이 포함되지만 이에 국한되지는 않습니다.
    • stdout (한 줄에 하나의 목록이 있음)
    • 목록의 목록
    • 목록에 대한 반복자 (언어가 있으면 생성기로 구현할 수 있음)
  • 생성 된 인터리빙의 순서는 중요하지 않지만 반복 된 인터리빙은 없어야합니다.
  • 반복 감지를 단순화하기 위해 모든 입력 시퀀스의 모든 요소가 고유하다고 가정 할 수 있습니다.
  • 입력으로 목록이 제공되지 않으면 빈 목록과 출력이 모두 유효한 출력입니다.
  • 시퀀스의 요소 유형은 관련이 없습니다. (예를 들어, 모두 하나의 유형이거나 유형이 혼잡 한 언어 중 하나 일 수 있습니다)
  • 프로그램 / 기능은 제한된 시간 내에 종료되도록 보장해야합니다.
  • 이것은 code-golf 이므로 각 언어에 대한 가장 짧은 코드가 승리합니다.
code-golf  sequence 
— 비프 스터
소스
리스트가없는 유일한 인터리빙은 빈리스트입니다. 입력으로 목록이 주어지지 않을 때 [[]]대신 출력해야한다는 것을 의미합니까 []?
— Outgolfer Erik
또한 목록의 길이가 동일합니까?
— Outgolfer Erik
목록이 입력으로 주어지지 않으면 출력으로 목록을 반환하지 않는 것이 수학적으로 훌륭하다고 가정합니다. 둘 다 허용합니다. 모든 출력 목록의 길이는 같습니다. 입력 목록의 길이는 다를 수 있습니다.
— 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)

온라인으로 사용해보십시오!

xnor에 따라 교체 [x[0]]하여 -1x[:1]

-13 바이트 는 더 긴 접근 방식 대신 Neil의 대답에서 제안한대로 부끄럽게 도용 하여 확장합니다 .[b[b==x:]for b in A]enumerate

목록 목록 A을 입력으로 사용합니다. 의 모든 요소 A가 비어 있으면에서 평가 된 목록 if이 비어 있으므로 재귀의 끝에 도달하여 할 수 있습니다 print. 그렇지 않으면 하나 이상의 목록이 있습니다 None. 우리는 재귀합니다.

— 차스 브라운
소스
[x[0]]입니다x[:1]
— XNOR
@ xnor : 물론입니다! 고마워!
— Chas Brown
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]재귀 호출에서 둘 이상의 시퀀스를 잠재적으로 제거 할 수 있습니다. 반성에도 불구하고 실제로 중복 출력을 피하는 올바른 동작 일 수 있습니다.

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

— 조직 주의자
소스
2

Wolfram Language (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 목록이 정렬되어 있는지 확인하십시오 (즉, 증가하는 순서로).

인터리빙의 실제 구현, 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[[]]

온라인으로 사용해보십시오! 내 JavaScript 답변의 포트. 편집 : @ChasBrown 덕분에 3 바이트가 절약되었습니다.

— 닐
소스
-3으로 교체 sum(a,[])하여 any(a).
— Chas Brown
@ChasBrown 고마워, 나는 파이썬을 잘 모른다.
— Neil
Neil : 충분히 생각합니다. :). sum(a,[])그러나 어떤 상황에서는 잘 사용됩니다!
— Chas Brown
2

하스켈 , 45 바이트

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

온라인으로 사용해보십시오!

Chas Brown의 Python answer 에서 채택되었습니다 .

이 max[[]]의 기본 케이스 수득 속임수 [[]]입력만을 포함하는 경우 []소자. 이 경우 비어 있고 되풀이에 사용 된 목록은 비어 있으며을 max[[]][]제공합니다 [[]].

선택한 목록의 첫 번째 요소를 선택적으로 삭제하지 않고 되풀이 할 때 앞에 h:t새 목록을 t만들고 h:t필터링합니다.

— xnor
소스
0

JavaScript (Firefox 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

apt -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
최소한이 코드를
— 골라야
당사 사이트를 사용함과 동시에 당사의 쿠키 정책과 개인정보 보호정책을 읽고 이해하였음을 인정하는 것으로 간주합니다.
Licensed under cc by-sa 3.0 with attribution required.