একটি গ্রাফ তৈরি করুন

Question

এই চ্যালেঞ্জে, আপনার কাজ হ'ল নির্দেশের ক্রম থেকে একটি অনির্দেশিত গ্রাফ তৈরি করা। প্রতিটি নন-নেগেটিভ পূর্ণসংখ্যার জন্য একটি নির্দেশ রয়েছে এবং প্রত্যেকে একটি প্রদত্ত গ্রাফকে একটি নতুন রূপান্তরিত করে।

• দিকনির্দেশক 0: একটি নতুন সংযোগ বিচ্ছিন্ন নোড যুক্ত করুন।
• দিকনির্দেশক 1: একটি নতুন নোড যুক্ত করুন এবং এটি প্রতিটি বিদ্যমান নোডের সাথে সংযুক্ত করুন।
• নির্দেশিকা m > 1: সমস্ত নোডগুলি সরান যার ডিগ্রি (প্রতিবেশীর সংখ্যা) দ্বারা বিভাজ্য m। নোট যা 0সবার দ্বারা বিভাজ্য m, তাই সংযোগ বিচ্ছিন্ন নোডগুলি সর্বদা সরানো হয়।

নির্দেশগুলি খালি গ্রাফ দিয়ে শুরু করে বাম থেকে ডানে এক এক করে প্রয়োগ করা হয়। উদাহরণস্বরূপ, ক্রমটি [0,1,0,1,0,1,3]নিম্নরূপে প্রক্রিয়া করা হয়, দুর্দান্ত অ্যাস্কিআই আর্ট ব্যবহার করে ব্যাখ্যা করা হয়েছে। আমরা খালি গ্রাফ দিয়ে শুরু করি এবং নির্দেশিত হিসাবে একটি একক প্রান্তকে যুক্ত করি 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]।

ইনপুট

দিকনির্দেশের ক্রম উপস্থাপন করে নন-নেগেটিভ পূর্ণসংখ্যার একটি তালিকা।

আউটপুট

অনুক্রম দ্বারা সংজ্ঞায়িত গ্রাফের নোডের সংখ্যা।

পরীক্ষার মামলা

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

আমি যখন প্রশ্নটি পড়ছি, ভেবেছিলাম আপনাকে আসলে গ্রাফটি আঁকতে হবে - এটি অত্যন্ত শক্ত , স্ক্রোল ডাউন - ওহ

— অপ্টিমাইজার 17

@ অপ্টিমাইজার হ্যাঁ, আমি প্রশ্নটি উত্থাপন করতে চেয়েছিলাম যাতে গ্রাফের প্রকৃত উপস্থাপনা গুরুত্বপূর্ণ না হয় এবং নির্দেশিকাগুলি বাস্তবায়নে মূল সমস্যাটি পড়ে যায়। নোডের সংখ্যা নির্ভুলতা যাচাই করার একটি সহজ উপায়।

— Zgarb

আমি সত্যিই এই চ্যালেঞ্জ পছন্দ! এটি একটি ডেটা স্ট্রাকচার ডিজাইনের মতো। আপনাকে কীভাবে গ্রাফটি উপস্থাপন করতে হবে তা নির্ধারণ করতে হবে কারণ ইনপুট এবং আউটপুট ফর্ম্যাটগুলি এর সাথে আবদ্ধ নয়।

— xnor

Answer 1

পাইথ , 37 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 ইনপুট নোডের 1 বা এর পরে নোডের সংখ্যা গণনা করে। এগুলি সমস্তই ইনপুট নোডের সাথে সংযুক্ত, কেবলমাত্র ইনপুট নোডটি যদি 1 হয় তবে আমরা 1 দ্বারা গণনা করব।

দ্বিতীয়ত, আমাদের সাথে সংযুক্ত যা ইনপুট নোডের চেয়ে আগে নোডের সংখ্যা প্রয়োজন need ইনপুট নোডটি যদি 0 হয় তবে ইনপুট নোডটি যদি 0 হয় এবং Tইনপুট নোডটি 1 হয় তবে এই মানটি দেওয়া হবে *@GTT। তবে, প্রথম বিভাগ থেকে এখনও ওভার গণনা রয়েছে যা সংশোধন করা দরকার। সুতরাং, আমরা *@GTtTপরিবর্তে গণনা করি , যা ইনপুট নোডটি 1 হলে 1 কম হয় These

% ... H0 দিবে যে সংখ্যাটি দ্বারা বিভাজ্য H, এবং সুতরাং এটি সরানো উচিত, এবং অন্যথায় 0 দেবে না।

f ... UGএইভাবে fইনপুটটির সূচকগুলি দেবে যা অপসারণ করা উচিত নয়, যেহেতু একটি ফিল্টার এবং 0 টি মিথ্যা।

m@Gd এই সূচকগুলিকে সংশ্লিষ্ট নোডের 0 এবং 1 এর মধ্যে রূপান্তর করে।

অবশেষে, একবার 0 এবং 1 লেবেলযুক্ত নোডগুলির ফলাফলের তালিকাটি পাওয়া গেলে, এর দৈর্ঘ্য গণনা করা হয় ( l) এবং মুদ্রিত (অন্তর্ভুক্ত)।

বিস্তৃত ধারণা @ পিটারটেলরকে ধন্যবাদ।

Answer 2

গল্ফস্ক্রিপ্ট (৫৩ বাইট)

])~{:^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

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

এসটিডিআইএন থেকে ইনপুট নেয়:

[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যোগ করার জন্য নোডের আইডি সঞ্চয় করে এমন ।
• তালিকার একটি তালিকা বজায় রাখুন যাতে প্রতিটি তালিকার তালিকার প্রথম উপাদান দ্বারা তৈরি করা অনন্য আইডি এবং একটির নোডের সাথে যুক্ত নোডগুলির আইডিসহ অবশিষ্ট উপাদান রয়েছে a
• প্রতিটি পুনরাবৃত্তিতে (ইনপুট নির্দেশাবলী পড়ার সময়),
  • নির্দেশনাটি থাকলে 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]:

ইনপুট 0: Y = [[0]] জে = []
ইনপুট 1: ওয়াই = [[0,1], [0,1]] 0 জে = []
ইনপুট 0: ওয়াই = [[0,1], [0,1], [2]] জে = []
ইনপুট 1: ওয়াই = [[0,1,3], [0,1,3], [2,3], [0,1,2,3]] জে = []
ইনপুট 0: ওয়াই = [[0,1,3], [0,1,3], [2,3], [0,1,2,3], [4]] জে = []
ইনপুট 1: ওয়াই = [[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: ওয়াই = [[3,5], [3,5], [2,3,5], [2,3,5], [4,5], [2,3,4,5]] জে = [0,1]

অ্যালগরিদমটি তখন খুব সহজ: সমস্ত ইনপুটগুলিতে আইট্রেট করুন, যদি ইনপুট == 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 হয়, সমস্ত বিদ্যমান নোডের আইডিগুলি নতুন নোডের প্রতিবেশী তালিকায় পরিণত হয় এবং অন্যান্য সমস্ত প্রতিবেশী তালিকাকে নতুন নোড আইডি অন্তর্ভুক্ত করার জন্য আপডেট করা হয়। মি> 1 এর জন্য প্রতিবেশী তালিকার সাথে নোডগুলি যা একাধিক মি এর নোড তালিকা এবং সমস্ত প্রতিবেশী তালিকা থেকে সরানো হয়। পূর্ববর্তী সংস্করণে বাগটি ধরার জন্য @ অপ্টিমাইজারকে ধন্যবাদ।

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}

এটি Gস্ট্যাবি-ল্যাম্বদা সিনট্যাক্স ব্যবহার করে একটি ফাংশন সংজ্ঞায়িত করে। G[[0, 1]]কমান্ড সহ এটি কল করতে ব্যবহার করুন0 এবং1 ।

বাস্তবায়নটি বেশ সোজা: এখানে একটি Nodeকাঠামো রয়েছে (বলা হয়)N উপরে ) যা lসম্পত্তির মাধ্যমে সমস্ত লিঙ্কযুক্ত নোডের রেফারেন্স রাখে । Gপ্রয়োজন অনুযায়ী নোড তৈরি করে এবং তাদের লিঙ্কগুলি ম্যানিপুলেট করে। একটি পঠনযোগ্য সংস্করণ এখানে উপলব্ধ ।

Answer 9

সিজেম, 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গ্রাফ উপস্থাপনের জন্য আমি একটি অভিধান ব্যবহার করেছি । নোডগুলি সংখ্যা দ্বারা লেবেলযুক্ত, এবং তারা সংলগ্ন নোডগুলির সেটে মানচিত্র করে। এর অর্থ এটি একটি প্রান্তের প্রতিটি আপডেটের উভয় প্রান্তে কার্যকর করা দরকার uted

টাটকা নোড সূচকগুলি গণনা করে তৈরি করা হয় n। প্রতিবার, আমি একটি নতুন খালি নোড তৈরি করব n। কমান্ডের জন্য 0, এটি কেবল অবশিষ্ট রয়েছে। কমান্ডের জন্য 1, এটি একে অপরের সাথে নোডের সাথে যুক্তg[i]^={n};g[n]^={i} ; এক্সটি ব্যবহার করে এটি তৈরি করুন যাতে নোডটি নিজের সাথে সংযুক্ত না হয়। কমান্ড> 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 এর জন্য , আমি নির্দিষ্ট নোডগুলি অপসারণ করেছি এবং বাকিগুলি আপডেট করেছি।