Hedef

Her bir öğenin belirtilen bağımlılıklarından sonra listelenmesini sağlayarak bir öğe listesini sıralayın.

Giriş

Her tamsayı, bu öğenin gelmesi gereken başka bir öğenin 0 veya 1 tabanlı dizinini belirlediği bir tamsayı dizisi dizisi. Giriş bir dizi veya karakter dizisi veya okunabilir başka bir şey olabilir.

Örneğin, 0 tabanlı bir girdi:

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

Dairesel bağımlılıklar olmadığını, her zaman en az bir geçerli sipariş olduğunu varsayalım.

Çıktı

Bağımlılık sırasına göre sayılar. Belirsiz bir düzenin deterministik olması gerekmez. Çıktı bir dizi veya metin ya da insanların okuyabileceği başka bir şey olabilir.

Birden fazla geçerli sipariş olsa bile çıktıda yalnızca bir sipariş verilmelidir.

Yukarıdaki giriş için olası çıkışlar şunları içerir:

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

puanlama

Bunu en az baytta tamamlayan bir işlev veya program, kabul görmenin ihtişamını kazanır. Son başvuru tarihi 6 gündür.

Jöle, 8 bayt

ịÐL³ŒḊ€Ụ

Bu, @ xnor'ın Python cevabındaki (uygulanmayan) derinlik yaklaşımına dayanmaktadır .

Çevrimiçi deneyin!

Nasıl çalışır

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

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?

Ölçek:

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

Python 2, 73 bayt

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

Köşeleri, fözyinelemeli olarak hesaplayan torun sayılarına göre sıralar . Bir tepe noktası başka bir tepe noktasına işaret ediyorsa, onun torunları sivri tepe noktasını ve bu tepe noktasının tüm torunlarını içerir, bu yüzden kesinlikle daha fazla torunları vardır. Böylece, istenildiği gibi siparişte sivri tepe noktasından daha geç yerleştirilir.

Bir tepe noktasının torun sayısı kendisi içindir, artı her bir çocuğunun soyundan sayılır. Bir torunun, ona giden birden çok yol varsa, birden çok kez sayılabileceğini unutmayın.

Ayrıca, torun sayımı yerine derinliğe kullanılmış olurdu.

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

dışında boş bir liste maxvermek gerekir 0.

Pyth, 19 bayt

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

Çevrimiçi deneyin: Gösteri

Açıklama:

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 bayt

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

Örnek çalışma

G / Ç 1 dizinlidir. Her dizi ayrı bir satıra gider, boşluk ise öğe ayırıcı olarak kullanılır.

$ 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

Nasıl çalışır

tsort- @ DigitalTrauma'nın cevabında öğrendiğim - boşlukla ayrılmış, kısmi bir sıralamayı belirten jeton çiftlerini okur ve yukarıda belirtilen kısmi sıralamayı genişleten toplam bir sıralamayı (tüm benzersiz tokenlerin sıralı bir listesi şeklinde) yazdırır.

Belirli bir satırdaki tüm sayıları bir boşluk veya satır besleme izler. s/\s/ $. /gPerl komutunun parçası böylece emin olduğunu, bir boşluk, satır numarası ve başka alana sahip olanlar boşluk karakterleri değiştirir her n hattında k ilerlettiği k .

Son olarak, çizgi boşsa (yani, yalnızca bir satır s/^$/ /beslemeden oluşursa ), ona bir boşluk ekler. Bu şekilde, ikinci yer değiştirme , her bir tamsayının, bağlanan dizede en az bir kez olduğundan emin olarak boş bir k satırını dönüştürür .k ktsort

Bash + coreutils, 20 80

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

Boşlukla ayrılmış satırlar olarak girin, örneğin:

2
0 3

2

• nl tüm satırlara sıfır tabanlı indeksler ekler
• sed bağımlılık listelerini basit bağımlılık çiftlerine böler ve eksik bağımlılıkları kendilerine bağımlı yapar.
• tsort gerekli topolojik sıralama yapar
• tac Çıktıyı tersine çevirir

Ideone. @Dennis 'test çantasına sahip Ideone

Python 2, 143 118 116 bayt

Biraz daha rastgele bir yaklaşım.

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

Düzenlemeler:

• düzeltti ve bazı baytları da kurtardı.
• 2 bayt kaydedildi (teşekkürler @Dennis)