目标

对项目列表进行排序，确保每个项目都在指定的依赖项之后列出。

输入值

整数数组的数组，其中每个整数指定该项目必须紧随其后的另一个项目的从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的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]

Python 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

Bash，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/ $. /gPerl的命令的一部分替换那些空白字符与一个空间，该行号，和另一个空间，从而确保每个Ñ上线ķ先于ķ。

最后，如果该行为空（即仅由换行符组成），请s/^$/ /为其添加一个空格。这样，第二个替换将空行k转换为空k k，确保每个整数在传递给的字符串中至少出现一次tsort。

Bash + coreutils，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 向所有行添加从零开始的索引
• sed 将依赖关系列表拆分为简单的依赖关系对，并使不完整的依赖关系依赖于自身。
• tsort 做所需的拓扑排序
• tac 将输出放倒序

伊迪恩 Ideone与@Dennis的测试用例

Python 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）