निर्भरता के आधार पर वस्तुओं को क्रमबद्ध करें

Question

लक्ष्य

यह सुनिश्चित करने के लिए कि प्रत्येक आइटम को उसकी निर्दिष्ट निर्भरता के बाद सूचीबद्ध किया गया है, मदों की एक सूची को क्रमबद्ध करें।

इनपुट

पूर्णांकों की सरणियों की एक सरणी, जहां प्रत्येक पूर्णांक किसी अन्य आइटम के 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 दिनों में है।

Comments

इसे जिज्ञासु के लिए टोपोलॉजिकल सॉर्टिंग कहा जाता है ।

— रॉबर्ट फ्रेजर

इनपुट एक सरणी या स्ट्रिंग या कुछ भी हो सकता है मानव पठनीय है बस यह सुनिश्चित करने के लिए: क्या यह शून्य और लोगों के साथ एक 2 डी सरणी हो सकता है, जहां कोई निर्भरता इंगित करता है और शून्य कोई निर्भरता नहीं दर्शाता है?

— लुइस मेन्डो

@DonMuesli, देर से जवाब के लिए खेद है, लेकिन नहीं। विचार कोड निर्भरता से आया था। यदि आपने एक और कोड मॉड्यूल जोड़ा है, तो यह घोषित करने के लिए अप्रासंगिक कोड मॉड्यूल को संशोधित करना गैर-जिम्मेदाराना होगा कि वे इस नए मॉड्यूल पर निर्भर नहीं थे।

— हाथ-ई-फूड

यह पूरी तरह से समझ में आता है। डेनिस विजेता नहीं होना चाहिए?

— लुइस मेंडू

हा वह है। क्षमा करें, देर से तनावपूर्ण रात और मान्यताओं के आधार पर भीड़।

— हाथ-ई-फूड

Answer 1

जेली, 8 बाइट्स

ịÐL³ŒḊ€Ụ

यह @ xnor के पाइथन उत्तर से (अकल्पित ) गहराई के दृष्टिकोण पर आधारित है ।

इसे ऑनलाइन आज़माएं!

यह काम किस प्रकार करता है

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

Comments

क्या ये 8 अक्षर वास्तव में 19 बाइट्स होंगे?

— हाथ-ई-फूड

@ हैंड-ई-फूड जेली एक कस्टम एन्कोडिंग (यूटीएफ 8 नहीं) का उपयोग करता है, इसलिए प्रत्येक चरित्र एक बाइट है

— लुइस मेंडो

@ हाथ-ई-फूड डॉन मूसली सही है। जेली डिफ़ॉल्ट रूप से इस कोड पृष्ठ का उपयोग करती है , जो सभी पात्रों को एक-एक बाइट के रूप में समझता है।

— डेनिस

Answer 2

पायथ, 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]

Answer 3

पायथन 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।

Comments

सुंदर एल्गोरिथ्म। यह पाइथ और जेली दोनों में 12 बाइट्स स्कोर करेगा।

— डेनिस

Answer 4

पायथ, 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

Answer 5

बैश, 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 लाइन पर कश्मीर पछाड़ कश्मीर ।

अंत में, यदि लाइन खाली है (यानी, केवल एक लाइनफीड शामिल है), s/^$/ /इसके लिए एक स्थान तैयार करता है। इस तरह, दूसरा प्रतिस्थापन एक खाली लाइन k में बदल जाता है k k, जिससे यह सुनिश्चित हो जाता है कि प्रत्येक पूर्णांक कम से कम एक बार स्ट्रिंग में होता है जिसे पाइप किया जाता है tsort।

Comments

ठीक है सही। मुझे लगता है कि आपने मुझसे tsortबेहतर / तेजी से ग्रूम किया था :) अतिरिक्त स्पष्टीकरण के लिए धन्यवाद।

— डिजिटल ट्रॉमा

Answer 6

बैश + कोरुटिल्स, 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। @ डेनिस के टेस्टकेस के साथ Ideone

Answer 7

पायथन 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 बाइट्स (धन्यवाद @ डेनिस)