ในความท้าทายนี้งานของคุณคือการสร้างกราฟที่ไม่มีทิศทางจากลำดับของคำสั่ง มีหนึ่งคำสั่งสำหรับแต่ละจำนวนเต็มไม่ใช่ค่าลบและแต่ละแปลงกราฟที่กำหนดเป็นหนึ่งใหม่

• คำสั่ง0: เพิ่มโหนดที่ไม่ได้เชื่อมต่อใหม่
• คำสั่ง1: เพิ่มโหนดใหม่และเชื่อมต่อกับทุกโหนดที่มีอยู่
• Directive 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

กฎรายละเอียด

คุณสามารถเขียนฟังก์ชั่นหรือโปรแกรมเต็มรูปแบบ จำนวนไบต์ที่สั้นที่สุดชนะ ช่องโหว่มาตรฐานไม่ได้รับอนุญาต โปรดอธิบายอัลกอริทึมของคุณในคำตอบของคุณ

เป็นเวลาหนึ่งสัปดาห์ดังนั้นฉันจึงตอบรับสั้นที่สุด หากสิ่งที่สั้นกว่ามาในภายหลังฉันจะอัปเดตตัวเลือกของฉัน การกล่าวถึงอย่างมีเกียรติไปถึงคำตอบของปีเตอร์เทย์เลอร์ซึ่งคนอื่น ๆ หลายคนอิงรวมถึงผู้ชนะ

Pyth , 37 31

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

โซลูชันนี้ใช้ฟังก์ชันลด ( u) เพื่อสร้างรายการโดยที่แต่ละรายการสอดคล้องกับโหนดที่เหลืออยู่ในรายการและค่าของรายการที่สอดคล้องกับว่าโหนดนั้นถูกเพิ่มเดิมภายใต้คำสั่ง 0 หรือ 1

Gเป็นตัวแปรสะสมในฟังก์ชั่นลดและเก็บรายการดังกล่าว มันถูกเริ่มต้นไปยังรายการที่ว่างเปล่า, Y.

Hรับค่าของสมาชิกแต่ละคนของQอินพุตหนึ่งต่อหนึ่ง ผลลัพธ์ของนิพจน์ถูกกำหนดให้กับGแต่ละครั้งและรายการถัดไปของQถูกกำหนดให้Hและนิพจน์นั้นจะรันอีกครั้ง

หากต้องการอัปเดตGอย่างถูกต้องมีสองความเป็นไปได้สำหรับคำสั่ง 0 หรือ 1 และอีกหนึ่งคำสั่ง กรณีเหล่านี้มีความแตกต่างกับประกอบไปด้วย? ... <H2 ...

ถ้าHเป็น 0 หรือ 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

GolfScript (53 ไบต์)

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

การสาธิตออนไลน์

ฉันยังไม่ได้ตีกอล์ฟจริงๆ แต่ฉันได้ค้นพบว่ามันไม่ง่ายเลยที่จะกำจัดHและTตัวแปรดังนั้นมันอาจจะน้อยที่สุดในท้องถิ่น

นำข้อมูลเกี่ยวกับ stdin [0 1 2 3]ในรูปแบบ ปล่อยเอาต์พุตเมื่อ stdout

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
}/,

CJam, 129 75 73 68 61 46 42 ไบต์

โซลูชันขึ้นอยู่กับอัลกอริทึมของ Peter:

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ซึ่งเก็บ id ของโหนดที่จะเพิ่ม
• รักษารายการของรายการซึ่งแต่ละรายการเป็นโหนดที่มี id เฉพาะที่สร้างขึ้นโดยองค์ประกอบแรกของรายการและองค์ประกอบที่เหลือเป็นรหัสของโหนดที่เชื่อมต่อ
• ในแต่ละการวนซ้ำ (ในขณะที่อ่านคำสั่งอินพุต)
  • หากคำสั่งคือ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";

ลองที่นี่

Pyth, 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ติดตามโหนดที่ถูกลบ

ฉันแสดงการเปลี่ยนแปลงของรายการ adjacency ในตัวอย่างอินพุต[0,1,0,1,0,1,3]:

อินพุต 0: Y = [[0]] J = []
อินพุต 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]] J = []
อินพุต 3: Y = [[3,5], [3,5], [2,3,5], [2,3,5], [4,5], [2,3,4,5]] J = [0,1]

อัลกอริทึมนั้นค่อนข้างง่าย: ทำซ้ำอินพุตทั้งหมดหากอินพุต == 0: เพิ่มโหนดใหม่ด้วยตัวเองเป็นเพื่อนบ้านถ้าอินพุต == 1: เพิ่มโหนดใหม่ที่มีโหนดทั้งหมดเป็นเพื่อนบ้าน (เช่นที่ถูกลบ) และเพิ่ม โหนดนี้ไปยังรายการถ้อยคำของโหนดทั้งหมดถ้า input> 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]หรือกรณีทดสอบอื่น ๆ

APL, 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,⍵}

กราฟจะแสดงเป็นเมทริกซ์ adjacency บูลีน แถว / คอลัมน์จะถูกเพิ่มและลบตามความจำเป็น

Python 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 รหัสของโหนดที่มีอยู่ทั้งหมดจะกลายเป็นรายการเพื่อนบ้านสำหรับโหนดใหม่และรายการเพื่อนบ้านอื่น ๆ ทั้งหมดได้รับการอัปเดตเพื่อรวมโหนด ID ใหม่ สำหรับ m> 1 โหนดที่มีรายการเพื่อนบ้านที่มีหลายค่า m จะถูกลบออกจากรายการโหนดและรายการเพื่อนบ้านทั้งหมด ขอบคุณ @Optimizer สำหรับดักจับข้อบกพร่องในรุ่นก่อนหน้า

NetLogo, 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]คุณสามารถเรียกใช้จากบรรทัดคำสั่งเป็น

Ruby 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}

สิ่งนี้นิยามฟังก์ชันที่เรียกGใช้ using stabby-lambda syntax ใช้G[[0, 1]]จะเรียกมันว่าด้วยคำสั่งและ01

การใช้งานค่อนข้างตรงไปตรงมา: มีNodeโครงสร้าง (เรียกว่าNด้านบน) ซึ่งเก็บการอ้างอิงถึงโหนดที่เชื่อมโยงทั้งหมดผ่านlคุณสมบัติ Gสร้างโหนดตามต้องการและจัดการลิงค์ของพวกเขา รุ่นที่สามารถอ่านได้สามารถใช้ได้ที่นี่

CJam, 99 97 ไบต์

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

ยังมีอะไรอีกมากมายให้เล่นกอล์ฟในครั้งนี้ อัลกอริทึมนั้นขึ้นอยู่กับการติดตามเมทริกซ์ของ adjacency แต่เป็นตัวแทนของเมทริกซ์ที่ว่างเปล่าโดยไม่ต้องรักษามันเป็นพิเศษคือให้ฉันปวดหัว

ทดสอบที่นี่

อินพุตเป็นอาร์เรย์สไตล์ CJam:

[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}/

Python 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จึงนำเข้ารายการของโหนดและเพื่อนบ้านของแต่ละโหนด

สุดท้ายจำนวนรายการในพจนานุกรมกราฟคือคำตอบ

Mathematica ขนาด 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 directive ฉันเพิ่งผนวกรายการว่าง
สำหรับ1 directive ฉันผนวกรายการของโหนดก่อนหน้าทั้งหมดและเพิ่มโหนดใหม่ให้กับโหนดก่อนหน้าทั้งหมด
สำหรับคำสั่ง> 1ฉันลบโหนดที่ระบุและอัพเดตที่เหลือ