골

각 항목이 지정된 종속성 뒤에 나열되도록 항목 목록을 정렬하십시오.

입력

각 정수는이 항목 뒤에 오는 다른 항목의 0 기반 또는 1 기반 색인을 지정하는 정수 배열입니다. 입력은 배열 또는 문자열 또는 사람이 읽을 수있는 다른 항목 일 수 있습니다.

예를 들어, 0 기반 입력 :

[
  [ 2 ],    // item 0 comes after item 2
  [ 0, 3 ], // item 1 comes after item 0 and 3
  [ ],      // item 2 comes anywhere
  [ 2 ]     // item 3 comes after item 2
]

순환 종속성이 없다고 가정하면 항상 적어도 하나의 유효한 순서가 있습니다.

산출

종속성 순서의 숫자입니다. 모호한 순서는 결정론적일 필요는 없습니다. 출력은 배열 또는 텍스트 또는 사람이 읽을 수있는 다른 것이 될 수 있습니다.

유효한 주문이 여러 개인 경우에도 출력에는 하나의 주문 만 제공해야합니다.

위 입력에 가능한 출력은 다음과 같습니다.

[ 2, 3, 0, 1 ]
[ 2, 0, 3, 1 ]

채점

최소 바이트 수로 이것을 완료하는 함수 또는 프로그램은 수용의 영광을 얻습니다. 마감일은 6 일입니다.

젤리, 8 바이트

ịÐL³ŒḊ€Ụ

이것은 @ xnor 's Python answer 의 (구현되지 않은) 깊이 접근 방식을 기반으로합니다 .

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

작동 원리

ịÐL³ŒḊ€Ụ  Main link. Input: A (list of dependencies)

 ÐL       Apply the atom to the left until a loop is reached, updating the left
          argument with the last result, and the right argument with the previous
          left argument.
ị         For each number in the left argument, replace it with the item at that
          index in the right argument.
   ³      Call the loop with left arg. A (implicit) and right arg. A (³).
    ŒḊ€   Compute the depth of each resulting, nested list.
       Ụ  Sort the indices of the list according to their values.

Pyth, 21 바이트

hf.A.e!f>xYTxkTbQ.plQ

                    Q  input
                   l   length of input array
                 .p    all permutations of [0, 1, ..., lQ-2, lQ-1]
hf                     find the first permutation for which...
    .e          Q        map over the input array with indices...
       f       b           find all elements in each input subarray where...
        >xYT                 index of dependency is greater than...
            xkT              index of item
      !                    check whether resulting array is falsy (empty)
  .A                     is the not-found check true for [.A]ll elements?

테스트:

llama@llama:~$ echo '[[2],[0,3],[],[2]]' | pyth -c 'hf.A.e!f>xYTxkTbQ.plQ' 
[2, 0, 3, 1]

파이썬 2, 73 바이트

l=input()
f=lambda n:1+sum(map(f,l[n]))
print sorted(range(len(l)),key=f)

정점을 자손 수를 기준으로 정렬하여 f재귀 적 으로 계산합니다. 정점이 다른 정점을 가리키는 경우 해당 정점에는 뾰족한 정점과 해당 정점의 모든 하위 항목이 포함되므로 더 많은 하위 항목이 있습니다. 따라서 원하는 순서대로 정점보다 늦게 배치됩니다.

꼭짓점의 자손 수는 그 자체에 하나이며 각 자식의 자손 수입니다. 여러 경로가 있으면 하위 항목을 여러 번 계산할 수 있습니다.

또한 자손 수보다 깊이를 사용하도록 작동했을 것입니다.

f=lambda n:1+max(map(f,l[n]))

빈 목록 max을 제공해야 한다는 것을 제외하고 0.

Pyth, 19 바이트

hf!s-V@LQT+k._T.plQ

온라인으로 사용해보십시오 : 데모

설명:

hf!s-V@LQT+k._T.plQ   implicit: Q = input list
               .plQ   all permutations of [0, 1, ..., len(Q)-1]
 f                    filter for permutations T, which satisfy:
      @LQT               apply the permutation T to Q
                         (this are the dependencies)
            ._T          prefixes of T
          +k             insert a dummy object at the beginning
                         (these are the already used elements)
    -V                   vectorized subtraction of these lists
   s                     take all dependencies that survived
  !                      and check if none of them survived
h                    print the first filtered permutation

배쉬, 35 바이트

perl -pe's/^$/ /;s/\s/ $. /g'|tsort

예제 실행

I / O는 1 인덱스입니다. 각 배열은 공백을 항목 구분 기호로 사용하여 별도의 줄로 이동합니다.

$ echo $'4\n1\n\n3\n1 3 2' # [[4], [1], [], [3], [1, 3, 2]]
4
1

3
1 3 2
$ bash tsort <<< $'4\n1\n\n3\n1 3 2'
3
4
1
2
5

작동 원리

tsort@DigitalTrauma의 답변 에서 배운 – 부분 순서를 나타내는 공백으로 구분 된 토큰 쌍을 읽고 위에서 언급 한 부분 순서를 확장하는 전체 순서 (모든 고유 토큰의 정렬 된 목록 형식으로)를 인쇄합니다.

특정 줄의 모든 숫자 다음에는 공백이나 줄 바꿈이 있습니다. s/\s/ $. /g펄 명령의 일부로 따라서 확인하는 것으로, 공간, 행 번호, 또 다른 공간이 그 공백 문자를 대체 각 N 행에 K 선행 K .

마지막으로 줄이 비어 있으면 (즉, 줄 바꿈만으로 구성) 줄 s/^$/ /앞에 공백을 추가합니다. 이런 식으로, 두 번째 대체는 빈 줄 k를 로 바꾸어 k k각 정수가 파이프되는 문자열에서 적어도 한 번 발생하는지 확인합니다 tsort.

배쉬 + 코어 유틸리티, 20 80

nl -v0 -ba|sed -r ':;s/(\S+\s+)(\S+) /\1\2\n\1 /;t;s/^\s*\S+\s*$/& &/'|tsort|tac

공백으로 구분 된 라인으로 입력하십시오. 예 :

2
0 3

2

• nl 모든 행에 0부터 시작하는 인덱스를 추가합니다
• sed Depedency 목록을 간단한 종속성 쌍으로 나누고 불완전한 종속성을 자신에게 종속시킵니다.
• tsort 필요한 토폴로지 정렬
• tac 출력을 역순으로 놓는다

이데온 @Dennis의 테스트 케이스가있는 Ideone

파이썬 2 143 118 116 바이트

약간 더 랜덤 한 접근.

from random import*
l=input()
R=range(len(l))
a=R[:]
while any(set(l[a[i]])-set(a[:i])for i in R):shuffle(a)
print a

편집 :

• 수정하고 실제로 일부 바이트도 저장했습니다.
• 2 바이트 절약 (@Dennis 덕분에)