एक ग्राफ का निर्माण

Question

इस चुनौती में, आपका कार्य निर्देशों के अनुक्रम से एक अप्रत्यक्ष ग्राफ का निर्माण करना है। प्रत्येक nonnegative पूर्णांक के लिए एक निर्देश है, और प्रत्येक दिए गए ग्राफ को एक नए में बदलता है।

• निर्देश 0: एक नया डिस्कनेक्ट किया गया नोड जोड़ें।
• निर्देश 1: एक नया नोड जोड़ें, और इसे हर मौजूदा नोड से कनेक्ट करें।
• निर्देश m > 1: सभी नोड्स को हटा दें जिनकी डिग्री (पड़ोसियों की संख्या) द्वारा विभाज्य है m। ध्यान दें कि 0सभी द्वारा विभाज्य है m, इसलिए डिस्कनेक्ट नोड्स को हमेशा हटा दिया जाता है।

निर्देशों को एक-एक करके लागू किया जाता है, बाएं से दाएं, खाली ग्राफ से शुरू होता है। उदाहरण के लिए, अनुक्रम [0,1,0,1,0,1,3]को निम्नानुसार संसाधित किया जाता है, भयानक ASCII कला का उपयोग करके समझाया गया है। हम खाली ग्राफ के साथ शुरू करते हैं, और इसके द्वारा निर्देशित के रूप में एक ही शीर्ष जोड़ते हैं 0:

a

फिर, एक और शीर्ष जोड़ें और इसे पहले से कनेक्ट करें, जैसा कि निर्देशित किया गया है 1:

a--b

हम एक और डिस्कनेक्ट किए गए वर्टेक्स को जोड़ते हैं और फिर एक कनेक्टेड है, जैसा कि द्वारा निर्देशित 0और 1:

a--b   c
 \  \ /
  `--d

हम इसे एक बार फिर से दोहराते हैं, जैसा कि निर्देशित किया गया है 0और 1:

  ,--f--e
 /  /|\
a--b | c
 \  \|/
  `--d

अंत में, हम डिग्री -3 कोने को हटाते हैं aऔर b, जैसा कि निर्देशित किया गया है 3:

f--e
|\
| c
|/
d

यह अनुक्रम द्वारा परिभाषित ग्राफ है [0,1,0,1,0,1,3]।

इनपुट

निर्देश के एक अनुक्रम का प्रतिनिधित्व करते हुए nonnegative पूर्णांक की एक सूची।

उत्पादन

अनुक्रम द्वारा परिभाषित ग्राफ में नोड्स की संख्या।

परीक्षण के मामलों

[] -> 0
[5] -> 0
[0,0,0,11] -> 0
[0,1,0,1,0,1,3] -> 4
[0,0,0,1,1,1] -> 6
[0,0,1,1,0,0,1,1,2,5,7,0,1] -> 6
[0,0,1,1,1,1,5,1,4,3,1,0,0,0,1,2] -> 6
[0,0,1,1,0,0,1,1,5,2,3,0,0,1,1,0,0,1,1,3,4,0,0,1,1,2,1,1] -> 8
[0,0,1,1,0,0,1,1,2,5,7,0,1,1,1,1,1,0,1,1,1,1,1,1,1,1,8] -> 14

विस्तृत नियम

आप एक फ़ंक्शन या पूर्ण प्रोग्राम लिख सकते हैं। सबसे छोटा बाइट काउंट जीतता है। मानक खामियों को अस्वीकार कर दिया जाता है। कृपया अपने उत्तर में अपने एल्गोरिथ्म की व्याख्या करें।

---

एक सप्ताह हो गया है, इसलिए मैंने सबसे छोटा उत्तर स्वीकार कर लिया है। अगर बाद में कोई छोटा भी आता है, तो मैं अपनी पसंद को अपडेट करूंगा। एक सम्मानजनक उल्लेख पीटर टेलर के जवाब पर जाता है , जिस पर विजेता सहित कई अन्य लोग आधारित थे।

Comments

जैसा कि मैंने प्रश्न पढ़ा है, यह सोचकर कि आपको वास्तव में ग्राफ खींचना है - यह सुपर कठिन है , नीचे स्क्रॉल करता है - ओह

— ऑप्टिमाइज़र

@ ऑप्टिमाइज़र हाँ, मैं इस सवाल का जवाब देना चाहता था ताकि ग्राफ का वास्तविक प्रतिनिधित्व महत्वपूर्ण न हो, और मुख्य कठिनाई निर्देशों को लागू करने में होगी। नोड्स की संख्या शुद्धता की जांच करने का एक आसान तरीका है।

— जर्ग डेब

मुझे वास्तव में यह चुनौती पसंद है! यह डेटा संरचना को डिजाइन करने जैसा है। आपको यह पता लगाना होगा कि ग्राफ़ का प्रतिनिधित्व कैसे किया जाए क्योंकि इनपुट और आउटपुट प्रारूप इसके लिए बंधे नहीं हैं।

— xnor

Answer 1

पायथ , ३ 31 ३१

lu?+GH<H2m@Gdf%+*@GTtTs>GTHUGQY

यह समाधान uएक सूची बनाने के लिए एक कम फ़ंक्शन ( ) का उपयोग करता है , जहां प्रत्येक प्रविष्टि सूची में शेष नोड से मेल खाती है, और नोड के मूल रूप से निर्देश 0 या 1 के तहत जोड़ा गया था, इसी प्रविष्टि का मूल्य।

Gकम फ़ंक्शन में संचायक चर है, और उपरोक्त सूची रखता है। यह खाली सूची में आरंभ नहीं हो जाता Y।

HQएक-एक करके, इनपुट के प्रत्येक सदस्य का मान लेता है । अभिव्यक्ति का परिणाम Gहर बार सौंपा गया है , और अगली प्रविष्टि Qको असाइन किया गया है H, और अभिव्यक्ति फिर से जारी है।

Gठीक से अद्यतन करने के लिए, दो संभावनाएं हैं, एक निर्देशन के लिए 0 या 1, और दूसरी दिशाओं के लिए। ये मामला टर्नरी से अलग है? ... <H2 ...

यदि H0 या 1 है, तो हम सभी को करने की आवश्यकता Hहै G। +GHइसे पूरा करता है।

अन्यथा, पहली बात यह है कि ग्राफ में प्रत्येक नोड के लिए यह निर्धारित करना है कि उसके पास कितने पड़ोसी हैं। यह दो चरणों में पूरा किया जाता है:

सबसे पहले, s>GTइनपुट नोड पर या उसके बाद नोड्स की संख्या को गिनता है जो 1s हैं। ये सभी इनपुट नोड से जुड़े हुए हैं, सिवाय इसके कि अगर इनपुट नोड 1 है तो हम 1 से गिनती करेंगे।

दूसरा, हमें इनपुट नोड की तुलना में पहले नोड्स की संख्या की आवश्यकता है जो इससे जुड़े हुए हैं। यह 0 है यदि इनपुट नोड 0 है, और इनपुट नोड का सूचकांक है T, अगर इनपुट नोड 1 है। यह मान द्वारा दिया जाएगा *@GTT। हालांकि, अभी भी पहले खंड से अधिक गिनती है जिसे ठीक करने की आवश्यकता है। इस प्रकार, हम *@GTtTइसके बजाय गणना करते हैं, जो कि इनपुट नोड 1 है तो 1 कम है। इन मानों को संक्षेप में दिया गया है, इनपुट नोड से जुड़े नोड्स की संख्या देने के लिए।

% ... Hदे देंगे 0 कि संख्या से विभाज्य है H, और इस प्रकार हटा दिया जाना चाहिए, और अन्यथा 0 नहीं देंगे।

f ... UGइस प्रकार इनपुट के सूचकांकों को हटा दिया जाना चाहिए जो fकि एक फिल्टर नहीं है, और 0 गलत है।

m@Gd इन सूचकांकों को संबंधित नोड्स के 0s और 1s में परिवर्तित करता है।

अंत में, एक बार 0 और 1 लेबल वाले नोड्स की परिणामी सूची मिल जाने के बाद, इसकी लंबाई गणना की गई है ( l) और मुद्रित (अंतर्निहित)।

@PeterTaylor के लिए व्यापक विचार धन्यवाद।

Answer 2

गोल्फस्क्रिप्ट (53 बाइट्स)

])~{:^1>{.-1:H)-,:T;{..H):H*T@-:T+^%!{;}*}%}{^+}if}/,

ऑनलाइन डेमो

मैंने वास्तव में इसे अभी तक गोल्फ नहीं बनाया है, लेकिन मुझे पता चला है कि यह Hऔर Tचर को खत्म करना बहुत आसान नहीं है, इसलिए यह एक स्थानीय न्यूनतम हो सकता है।

प्रारूप में स्टडिन पर इनपुट लेता है [0 1 2 3]। स्टडआउट पर आउटपुट छोड़ता है।

Ungolfed:

])~{
  :^1>{
    # array of 0s and 1s
    # Each 0 has degree equal to the number of 1s after it
    # Each 1 has degree equal to the number of values before it plus the number of 1s after it
    .-1:H)-,:T;
    {
      # Stack: x
      # T' = T - x is the number of 1s after it
      # H' = H + 1 is the number of values before it
      # Degree is therefore H' * x + T' = H * x + T - x = (H-1)*x + T
      # Keep x unless degree % ^ == 0
      ..H):H*T@-:T+^%!{;}*
    }%
  }{^+}if
}/,

Answer 3

सीजेएम, 129 75 73 68 61 46 42 बाइट्स

पीटर के एल्गोरिथ्म पर आधारित समाधान:

Lq~{I+I1>{0:U(<:L{LU<,*LU):U>1b+I%},}*}fI,

पालन ​​करने के लिए कोड विस्तार।

---

पिछला समाधान (61 बाइट्स):

Lq~{:N2<{U):UaN{f+U1$0f=+}*a+}{{:X,(N%_!{X0=L+:L;}*},Lf-}?}/,

STDIN से इनपुट लेता है जैसे:

[0 0 1 1 0 0 1 1 5 2 3 0 0 1 1 0 0 1 1 3 4 0 0 1 1 2 1 1]

आउटपुट STDOUT पर संख्या है:

8

एल्गोरिथम :

• एक वृद्धिशील चर बनाए रखें Uजो जोड़े जाने वाले नोड के आईडी को संग्रहीत करता है।
• सूची की एक सूची बनाए रखें, जिसमें प्रत्येक सूची सूची के पहले तत्व द्वारा बनाई गई एक अद्वितीय आईडी और शेष तत्वों से जुड़ी नोड्स की आईडी होने के साथ एक नोड है।
• प्रत्येक पुनरावृत्ति में (इनपुट निर्देशों को पढ़ते समय),
  • यदि निर्देश है 0, तो [U]सूची की सूची में जोड़ें
  • यदि निर्देश है 1, Uतो सूची की सूची में प्रत्येक सूची में जोड़ें और सूची और सूची के प्रत्येक के पहले तत्व से मिलकर एक और सूची जोड़ेंU
  • हटाने के निर्देश के लिए, मैं length - 1विभाज्य की सभी सूचियों को फ़िल्टर करता हूं mऔर उन सूचियों के पहले तत्व को ध्यान में रखता हूं । फ़िल्टर करने के बाद, मैं सभी हटाए गए आईडी को आईडी की शेष सूची से हटा देता हूं।

कोड विस्तार :

Lq~{:N2<{U):UaN{f+U1$0f=+}*a+}{{:X,(N%_!{X0=L+:L;}*},Lf-}?}/,
L                                            "Put an empty array on stack";
 q~                                          "Evaluate the input";
   {                                }/       "For each directive";
    :N                                       "Store the directive in N";
      2<{     ...    }{    ...    }?         "If directive is 0 or 1, run the first";
                                             "block, else second";
{U):UaN{f+U1$0f=+}*a+}
 U):U                                        "Increment and update U (initially 0)";
     a                                       "Wrap it in an array";
      N{         }*                          "Run this block if directive is 1";
        f+                                   "Add U to each list in list of list";
          U1$                                "Put U and list of lists on stack";
             0f=                             "Get first element of each list";
                +                            "Prepend U to the above array";
                   a+                        "Wrap in array and append to list of list";
{{:X,(N%_!{X0=L+:L;}*},Lf-}
 {                   },                      "Filter the list of list on this block";
  :X,(                                       "Get number of connections of this node";
      N%_                                    "mod with directive and copy the result";
         !{        }*                        "If the mod is 0, run this block";
           X0=                               "Get the id of this node";
              L+:L;                          "Add to variable L and update L";
                       Lf-                   "Remove all the filtered out ids from the";
                                             "remaining nodes";
,                                            "After the whole process is completed for"
                                             "all directives, take length of remaining ";
                                             "nodes in the list of list";

इसे यहाँ आज़माएँ

Answer 4

पायथ, 88 80 75 वर्ण

JYFHQI!H~Y]]lY)IqH1=Y+m+dlYY]UhlY)VYI&Hq%l@YNH1~J]N))=Ymf!}TJ@YkUlYY;-lYl{J

मेरा हो गया। हो सकता है कि किसी और के पास कुछ गोल्फ टिप्स हों।

Yग्राफ की आसन्न सूची है। गोल्फिंग कारणों से, मैं इस सूची में एक नोड भी रखता हूं, भले ही नोड हटाए जाने के बाद (अन्यथा मुझे सभी सूचकांकों को अपडेट करना होगा)। प्रत्येक नोड में पड़ोसी के रूप में ही है। सूची Jहटाए गए नोड्स का ट्रैक रखती है।

मैं उदाहरण इनपुट पर आसन्न सूची के परिवर्तन दिखाता हूं [0,1,0,1,0,1,3]:

इनपुट ०: वाई = [[०]] जे = []
इनपुट 1: Y = [[0,1], [0,1]] 0 J = []
इनपुट 0: Y = [[0,1], [0,1], [2]] J = []
इनपुट 1: Y = [[0,1,3], [0,1,3], [2,3], [0,1,2,3]] J = []
इनपुट 0: Y = [[0,1,3], [0,1,3], [2,3], [0,1,2,3], [4]] J = []
इनपुट 1: Y = [[0,1,3,5], [0,1,3,5], [2,3,5], [0,1,2,3,5], [4,5 ], [0,1,2,3,4,5]] जे = []
इनपुट 3: Y = [[3,5], [3,5], [2,3,5], [2,3,5], [4,5], [2,3,4,5]] जे = [0,1]

एल्गोरिथ्म तब बहुत सरल है: सभी इनपुटों पर Iterate करें, यदि इनपुट == 0: पड़ोसी के रूप में स्वयं के साथ एक नया नोड जोड़ें, यदि इनपुट == 1: पड़ोसी के रूप में सभी नोड्स के साथ एक नया नोड जोड़ें (हटाए गए भी) और जोड़ें। यह नोड सभी नोड्स की समीपता सूची में है, अगर इनपुट> 1: # पड़ोसी -1% इनपुट == 0 के साथ नोड निर्धारित करें और उन्हें Jप्रत्येक मामले में, प्रत्येक नोड के पड़ोसियों को अपडेट करके उपयोग करें J। अंत में Yमाइनस की लंबाई (सेट) की लंबाई प्रिंट करें J।

JYFHQI!H~Y]]lY)IqH1=Y+m+dlYY]UhlY)VYI&Hq%l@YNH1~J]N))=Ymf!}TJ@YkUlYY;-lYl{J
JY                      set J=[]
  FHQ                   for H in: input()
I!H      )                if H==0:
   ~Y]]lY                   Y.append([len(Y)])
IqH1              )       if H==1:
    =Y+                     Y=                 +
       m+dlYY                 old nodes updated
             ]UhlY                              new node with all neighbors
VY                )       for N in range(len(Q)):
  I&Hq%l@YNH1    )          if H>0 and len(Y[N])%H==1:
             ~J]N             J.append(N) //this node gets deleted
=Ym           Y           Y=[           for k in Y]
   f!}TJ@YkUlY               k-filtered  //all items of J are removed
;                       end input for loop
-lYl{J                  print len(Y) - len(set(J))

प्रयोग

बस स्क्रिप्ट को कॉल करें और इनपुट [0,1,0,1,0,1,3]या कुछ अन्य टेस्ट-केस के रूप में दें।

Answer 5

एपीएल, 71 65 55 वर्ण

{⍬≡⍺:≢⍵⋄r←1↓⍺⋄1<c←⊃⍺:r∇i⌿⍵/⍨i←0≠c|+/⍵⋄c:r∇∨⌿↑a(⍉a←⍵,1)⋄r∇0,0⍪⍵}∘(0 0⍴0)

{⍺←0 0⍴0⋄⍬≡⍵:≢⍺⋄(⍺{1<⍵:i⌿⍺/⍨i←×⍵|+/⍺⋄⍵:-⌿↑(1,1⍪⍺)1⋄0,0⍪⍺}⊃⍵)∇1↓⍵}

{g←0 0⍴0⋄(≢g)⊣{1<⍵:g⌿⍨←g/⍨←×⍵|+/g⋄(⊃g)-←g⍪⍨←g,⍨←⍵}¨2,⍵}

ग्राफ को बूलियन आसन्न मैट्रिक्स के रूप में दर्शाया गया है। पंक्तियों / स्तंभों को जोड़ा जाता है और आवश्यकतानुसार हटाया जाता है।

Answer 6

अजगर 2, 296

s=input();e=[];n=[];c=0
for t in s:
    if t<2:e=e+[[]]if t==0 else [x+[c]for x in e]+[n[:]];n+=[c];c+=1
    else:
        M=zip(*[(i,n[i])for i,x in enumerate(e)if not len(x)%t])
        if M:e=[list(set(z)-set(M[1]))for j,z in enumerate(e)if j not in M[0]];n=list(set(n)-set(M[1]))
print len(n)

प्रत्येक नोड को एक अद्वितीय आईडी दी जाती है और प्रत्येक नोड के पड़ोसी आईडी को रिकॉर्ड किया जाता है। जब निर्देश 0 होता है, तो नए नोड के लिए एक खाली पड़ोसी सूची जोड़ी जाती है। जब निर्देश 1 होता है, तो सभी मौजूदा नोड्स के आईडी नए नोड के लिए पड़ोसी सूची बन जाते हैं, और नई नोड आईडी को शामिल करने के लिए अन्य सभी पड़ोसी सूचियों को अपडेट किया जाता है। M> 1 के लिए, पड़ोसी सूचियों के साथ नोड्स जो कि कई m हैं नोड सूची और सभी पड़ोसी सूचियों से हटा दिए जाते हैं। पहले संस्करण में बग को पकड़ने के लिए @ ऑप्टिमाइज़र का धन्यवाद।

Answer 7

नेटलोगो, 160

to f[t]foreach t[if ? = 0[crt 1]if ? = 1[crt 1[create-links-with other turtles]]if ? > 1[ask turtles with[count my-links mod ? = 0][die]]]show count turtles
end

कार्यान्वयन सीधा है, प्रत्येक प्रतीक को पढ़ना और उचित कार्रवाई करना।

to f[t]
  foreach t [
    if ? = 0 [
      crt 1
    ]
    if ? = 1 [
      crt 1 [create-links-with other turtles]
    ]
    if ? > 1 [
      ask turtles with [count my-links mod ? = 0] [die]
    ]
  ]
  show count turtles
end

आप कमांड लाइन से चला सकते हैं f[0 0 1 1 0 0 1 1 2 5 7 0 1]।

Answer 8

रूबी 159 157 ( डेमो) )

N=Struct.new:l
G=->c{n=[]
c.map{|m|m<1?n<<N.new([]):m<2?(w=N.new([])
n.map{|x|x.l<<w;w.l<<x}
n<<w):(n-=r=n.select{|x|x.l.size%m<1}
n.map{|x|x.l-=r})}
n.size}

यह Gstabby-lambda सिंटैक्स नामक फ़ंक्शन को परिभाषित करता है । उपयोगG[[0, 1]]आदेशों के साथ इसे कॉल करने के लिए करें 0और 1।

कार्यान्वयन बहुत सीधा है: एक Nodeसंरचना है ( Nऊपर कहा गया है) जो lसंपत्ति के माध्यम से सभी लिंक किए गए नोड्स का संदर्भ रखती है। Gआवश्यकतानुसार नोड बनाता है और उनके लिंक में हेरफेर करता है। एक पठनीय संस्करण यहां उपलब्ध है ।

Answer 9

CJam, 99 97 बाइट्स

Lal~{I2<{_0={{If+z}2*));0+a+}{;Iaa}?}{_0=!!{{{_:+I%+}%z}2*));1+a+{{W=},z}2*);z_{);}{a}?}*}?}fI0=,

इसमें अभी भी बहुत कुछ गज़ब का है। एल्गोरिथ्म आसन्न मैट्रिक्स का ट्रैक रखने पर आधारित है, लेकिन खाली मैट्रिक्स का प्रतिनिधित्व किए बिना इसका इलाज करना विशेष रूप से मुझे सिरदर्द दे रहा है।

इसका परीक्षण यहां करें।

इनपुट एक सीजाम-शैली सरणी है:

[0 0 1 1 0 0 1 1 2 5 7 0 1 1 1 1 1 0 1 1 1 1 1 1 1 1 8]

आप सभी परीक्षणों को चलाने के लिए इस टेस्ट हार्नेस का उपयोग कर सकते हैं:

"[]
[5]
[0,0,0,11]
[0,1,0,1,0,1,3]
[0,0,0,1,1,1]
[0,0,1,1,0,0,1,1,2,5,7,0,1]
[0,0,1,1,1,1,5,1,4,3,1,0,0,0,1,2]
[0,0,1,1,0,0,1,1,5,2,3,0,0,1,1,0,0,1,1,3,4,0,0,1,1,2,1,1]
[0,0,1,1,0,0,1,1,2,5,7,0,1,1,1,1,1,0,1,1,1,1,1,1,1,1,8]"

","SerN/{
La\~{I2<{_0={{If+z}2*));0+a+}{;Iaa}?}{_0=!!{{{_:+I%+}%z}2*));1+a+{{W=},z}2*);z_{);}{a}?}*}?}fI0=,
N}/

Answer 10

अजगर 2, 174

l=input()
g={}
n=0
for x in l:
 n+=1;g[n]=set()
 if x>1:h={i for i in g if len(g[i])%x};g={i:g[i]&h for i in set(g)&h}
 if x==1:
  for i in g:g[i]^={n};g[n]^={i}
print len(g)

यह शायद अभी भी बहुत कुछ गोल्फ हो सकता है।

मैंने gग्राफ़ का प्रतिनिधित्व करने के लिए एक शब्दकोश का उपयोग किया । नोड्स को संख्याओं द्वारा लेबल किया जाता है, और वे आसन्न नोड्स के सेट पर मैप करते हैं। इसका मतलब यह है कि एक बढ़त के प्रत्येक अद्यतन को इसके दोनों समापन बिंदुओं पर निष्पादित करने की आवश्यकता है।

ताज़ा नोड सूचकांकों की गिनती के द्वारा बनाई गई है n। हर बार, मैं एक नया खाली नोड बनाता हूं n। कमांड के लिए 0, यह अभी भी बना हुआ है। आज्ञा के लिए1 , यह एक दूसरे के माध्यम से नोड से जुड़ा हैg[i]^={n};g[n]^={i} ; Xor का उपयोग करके इसे बनाते हैं ताकि नोड स्वयं से जुड़ा न हो। आदेश> 1 के लिए, यह तुरंत हटा दिया गया है।

नोड्स को फ़िल्टर करना जिनकी डिग्री एक से अधिक है, पहले नोड्स को खोजने के द्वारा किया जाता है जो कि रहते हैं ( h), फिरand इसे नोड्स और प्रत्येक नोड के पड़ोसियों की सूची के साथ जोड़ते हैं।

अंत में, ग्राफ डिक्शनरी में प्रविष्टियों की संख्या उत्तर है।

Answer 11

गणितज्ञ, 223 बाइट्स

वाह, यह मेरी अपेक्षा से अधिक लंबा निकला।

f=(g={};t=Append;l=Length;m=ListQ;h=Flatten;k=Position;o=If;(d=#;o[d==0,g=g~t~{},o[d==1,g=o[m@#,t[#,l@g+1],#]&/@g;g=t[g,h@k[g,_?m,1]],g=o[l@#~Mod~d==0,0,#]&/@g;p=h@k[g,0];(c=#;g=#~DeleteCases~c&/@g)&/@p]])&/@#;g~Count~_?m)&

उपयोग:

f@{0, 1, 0, 1, 0, 1, 3}

यहाँ परीक्षण मामलों से परिणाम हैं:

f /@ {
  {},
  {5},
  {0, 0, 0, 11},
  {0, 1, 0, 1, 0, 1, 3},
  {0, 0, 0, 1, 1, 1},
  {0, 0, 1, 1, 0, 0, 1, 1, 2, 5, 7, 0, 1},
  {0, 0, 1, 1, 1, 1, 5, 1, 4, 3, 1, 0, 0, 0, 1, 2},
  {0, 0, 1, 1, 0, 0, 1, 1, 5, 2, 3, 0, 0, 1, 1, 0, 0, 1, 1, 3, 4, 0, 0, 1, 1, 2, 1, 1},
  {0, 0, 1, 1, 0, 0, 1, 1, 2, 5, 7, 0, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 8}
}

Out: {0, 0, 0, 4, 6, 6, 6, 8, 14}

कम गोल्फ वाला:

f = (
   a = #;
   g = {};
   Table[
    If[a[[n]] == 0,
     AppendTo[g, {}],
     If[a[[n]] == 1,
      g = If[ListQ@#, Append[#, Length@g + 1], #] & /@ g; 
      g = Append[g, Flatten@Position[g, _?ListQ, 1]],
      If[a[[n]] > 1,
       g = If[Mod[Length@#, a[[n]]] == 0, 0, #] & /@ g;
       p = Flatten@Position[g, 0];
       (c = #; g = DeleteCases[#, c] & /@ g) & /@ p
       ]
      ]
     ],
    {n, Length@a}];
   Count[g, _?ListQ]
   ) &

जिस तरह से यह काम करता है वह "पड़ोसियों की सूची" की सूची के रूप में ग्राफ का प्रतिनिधित्व करता है।
के लिए 0 निर्देश, मैं सिर्फ एक खाली सूची जोड़ देते हैं।
के लिए 1 निर्देश, मैं सभी पिछले नोड्स की एक सूची संलग्न है, और सभी पिछले नोड्स नए नोड जोड़ें।
एक निर्देशन > 1 के लिए , मैंने निर्दिष्ट नोड्स को हटा दिया और बाकी को अपडेट कर दिया।