Mục tiêu

Sắp xếp danh sách các mục đảm bảo rằng mỗi mục được liệt kê sau các phụ thuộc được chỉ định.

Đầu vào

Một mảng các mảng số nguyên, trong đó mỗi số nguyên chỉ định chỉ số dựa trên 0 hoặc 1 của một mặt hàng khác mà mặt hàng này phải theo sau. Đầu vào có thể là một mảng hoặc chuỗi hoặc bất cứ thứ gì khác mà con người có thể đọc được.

Ví dụ: đầu vào dựa trên 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
]

Giả sử không có phụ thuộc vòng tròn, luôn có ít nhất một lệnh hợp lệ.

Đầu ra

Các số theo thứ tự phụ thuộc. Một trật tự mơ hồ không phải là xác định. Đầu ra có thể là một mảng hoặc văn bản hoặc bất cứ thứ gì khác mà con người có thể đọc được.

Chỉ nên đưa ra một đơn hàng trong đầu ra, ngay cả khi có nhiều đơn hàng hợp lệ.

Đầu ra có thể cho đầu vào trên bao gồm:

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

Chấm điểm

Một hàm hoặc chương trình hoàn thành việc này với số lượng byte ít nhất sẽ giành được vinh quang của sự chấp nhận. Thời hạn là trong 6 ngày.

Thạch, 8 byte

ịÐL³ŒḊ€Ụ

Điều này dựa trên cách tiếp cận chuyên sâu (chưa thực hiện) từ câu trả lời Python của @ xnor .

Hãy thử trực tuyến!

Làm thế nào nó hoạt động

ịÐ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.

Bình thường, 21 byte

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?

Kiểm tra:

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

Python 2, 73 byte

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

Sắp xếp các đỉnh theo số lượng con cháu của chúng, ftính toán đệ quy. Nếu một đỉnh chỉ tới một đỉnh khác, thì hậu duệ của nó bao gồm đỉnh nhọn và tất cả các hậu duệ của đỉnh đó, vì vậy nó có nhiều hậu duệ hơn. Vì vậy, nó được đặt muộn hơn đỉnh nhọn theo thứ tự, như mong muốn.

Số lượng con cháu của một đỉnh là một cho chính nó, cộng với số lượng con cháu của mỗi đứa con của nó. Lưu ý rằng một hậu duệ có thể được tính nhiều lần nếu có nhiều đường dẫn đến nó.

Nó cũng sẽ làm việc để sử dụng độ sâu chứ không phải là con cháu

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

ngoại trừ maxsẽ cần phải đưa ra 0một danh sách trống.

Bình thường, 19 byte

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

Dùng thử trực tuyến: Trình diễn

Giải trình:

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 byte

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

Chạy ví dụ

I / O là 1 chỉ mục. Mỗi mảng đi trên một dòng riêng biệt, với khoảng trắng là dấu phân cách mục.

$ 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

Làm thế nào nó hoạt động

tsort- mà tôi đã tìm hiểu trong câu trả lời của @ DigitalTrauma - đọc các cặp mã thông báo, được phân tách bằng khoảng trắng, cho biết thứ tự từng phần và in tổng thứ tự (dưới dạng danh sách được sắp xếp của tất cả các mã thông báo duy nhất) mở rộng thứ tự từng phần đã nói ở trên.

Tất cả các số trên một dòng cụ thể được theo sau bởi khoảng trắng hoặc nguồn cấp dữ liệu. Một s/\s/ $. /gphần của lệnh Perl thay thế các ký tự khoảng trắng đó bằng một khoảng trắng, số dòng và một khoảng trắng khác, do đó đảm bảo rằng mỗi n trên dòng k có trước k .

Cuối cùng, nếu dòng trống (nghĩa là chỉ bao gồm một dòng cấp), hãy s/^$/ /thêm một khoảng trắng vào nó. Bằng cách này, sự thay thế thứ hai biến một dòng trống k thành k k, đảm bảo rằng mỗi số nguyên xảy ra ít nhất một lần trong chuỗi được dẫn đến 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

Nhập dưới dạng các dòng được phân tách bằng dấu cách, ví dụ:

2
0 3

2

• nl thêm các chỉ số dựa trên zero cho tất cả các dòng
• sed chia danh sách phụ thuộc thành các cặp phụ thuộc đơn giản và làm cho các phụ thuộc không hoàn toàn phụ thuộc vào chính chúng.
• tsort sắp xếp theo yêu cầu
• tac đặt thứ tự đảo ngược đầu ra

Ideone. Ideone với bản thử nghiệm của @Dennis

Python 2, 143 118 116 byte

Một cách tiếp cận ngẫu nhiên hơn một chút .

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

Chỉnh sửa:

• đã sửa nó và thực sự đã lưu một số byte.
• Đã lưu 2 byte (cảm ơn @Dennis)