একটি *** অ্যামোবা গ্রাফ **** এমন এক ধরণের গাছ যার নোডগুলির সমস্ত মান 0 থেকে কিছু অ-নেতিবাচক পূর্ণসংখ্য N এর সাথে থাকে এবং x <N মানযুক্ত কোনও নির্দিষ্ট নোড x + 1 এর সাথে আলাদা আলাদা নোডের সাথে সংযুক্ত হয় 1।

এন জন্য Ameoba গ্রাফ = 3: (প্রকাশ একটি ₃ )

আমোবা 3

নোট করুন যে 2 এর 3 এর কোনওটিরও ভাগ করার অনুমতি নেই; ঠিক তিনটি 3 অবশ্যই প্রতিটি 2 এর সাথে "সম্পর্কিত"।

চ্যালেঞ্জ

আপনার কাজ হ'ল লোভনীয়ভাবে নোডের মধ্যে ম্যানহাটনের দূরত্বকে হ্রাস করে 2-মাত্রিক গ্রিডে এই আমেরিকা গ্রাফকে প্ররোচিতভাবে "বৃদ্ধি" করা :

বেস কেস: একটি ₀ কেবল গ্রাফ 0।
ইন্ডাকটিভ পদক্ষেপ: বিদ্যমান _{এন এন} কাঠামোর মধ্যে এন মান 1 নোটিশের যতটা সম্ভব কাছাকাছি রেখে পুনরায় পুনরায় নতুন এন + 1 স্থাপন করে একটি _{এন + 1} উত্পন্ন হয় । (এটি কেবল যতটা সম্ভব কাছাকাছি হতে পারে যেহেতু নিকটতম দাগগুলি ইতিমধ্যে পূরণ করা যেতে পারে))

প্ররোচিত পদক্ষেপের জন্য আপনাকে অবশ্যই অনুসরণ করতে হবে সাধারণ পদ্ধতি:

for each existing node P with value N:
    for each new N+1 valued node Q you need to connect to P: //this loops N+1 times
        find the set of vacant spots that are minimally distant from P //by Manhattan distance
        place Q in any of these vacant spots

(অবিচ্ছিন্ন আউটপুট সহ একটি পৃথক পদ্ধতি ঠিক আছে))

এ _{4 এর} বৃদ্ধির উদাহরণ :

A0 is always the same:

0

For A1 I happen to put the 1 to the right of the 0 (it has to go on one of the 4 open sides):

01

For A2 I happen to put the two 2's above and to the right of the 1:

 2
012


For A3 I find that one of the six 3's I must place cannot be directly next to a 2, so I put in one of the next closest places:

 3
323
0123
  33 <-- this 3 is distance two away from its 2

The process continues in A4. Note that I'm iterating over each 3 and placing four 4's next to it or as close as possible, then moving to the next 3 (the order of 3's does not matter):

 444
443444
4323444
4012344
 44334
  4444
   44

Always keep in mind that nodes cannot be "shared".

কার্যক্রম

আপনি যে প্রোগ্রামটি লিখেছেন তা অবশ্যই 0 থেকে 8 (অন্তর্ভুক্ত) পর্যন্ত নেওয়া উচিত এবং উপরে বর্ণিত প্ররোচনামূলক বৃদ্ধির প্যাটার্নটি ব্যবহার করে এর একটি বৈধ আমেরিকা গ্রাফ আউটপুট করতে হবে।

8 এর বাইরে যা ঘটে তাতে কিছুই আসে যায় না।

(একটি ₈ 46234 নোড যার ফলে এটি। একজন পরলোক কিছু ঠেলাঠেলি রয়েছে ₈ হবে এই ঠাহর জন্য মার্টিন Büttner করার অতিদূরে। ধন্যবাদ।)

ইনপুটটি স্টিডিন বা কমান্ড লাইন এবং আউটপুট থেকে স্টাডআউট বা কোনও ফাইলের কাছে আসা উচিত।

উদাহরণ (উপরে থেকে সরাসরি নেওয়া)

Input: 0
Output:

0

Input: 1
Output:

01

Input: 2
Output:

 2
012

Input: 3
Output:

 3
323
0123
  33

Input: 4
Output:

 444
443444
4323444
4012344
 44334
  4444
   44

* এই ধরণের গ্রাফের ইতিমধ্যে একটি নাম থাকতে পারে। আমি স্বীকার করি আমি কেবল তাদের তৈরি করেছি। ;)

code-golf graph-theory

কৌণিক বৃদ্ধির হারের আলোকে, প্রশ্নটি A35 এ থামানো থেকে 1 মেগাবাইট ফাইলে বা এই জাতীয় কিছুতে থামানো হতে পারে? A10 হ'ল এক মিলিয়ন অক্ষর সহ প্রথম অ্যামিবা।

— isaacg

@ মার্টিনবাটনার আমি সীমাটি 8 কে তৈরি করেছি যা 50 ক নোডের কাছাকাছি। এখনও অনেক তবে আশা করি পরিচালনাযোগ্য।

6

গণিত, 353 288 285 275 বাইট

n=Input[];f@_=" ";g={z={0,0}};i=f@z=0;For[r=Range,i++<n,g=Reap[(j=i;o={};For[d=0,j>0,o=Rest@o,If[o=={},o=Join@@({e={#,d-#},-e,e={d-#,-#},-e}&/@r@++d)];If[f[c=#&@@o+#]==" ",f@c=i;Sow@c;--j]])&/@g][[2,1]]];Riffle[(x=#;ToString@f@{x,#}&/@m~r~M)&/@r[m=Min@{g,0},M=Max@g],"
"]<>""

Ungolfed:

n = Input[];
f@_ = " ";
g = {z = {0, 0}};
i = f@z = 0;
For[r = Range, i++ < n,
  g = Reap[(
        j = i;
        o = {}; 
        For[d = 0, j > 0, o = Rest@o,
         If[o == {}, 

          o = Join @@ ({e = {#, d - #}, -e, e = {d - #, -#}, -e} & /@  
              r@++d)
          ];  
         If[f[c = # & @@ o + #] == " ",
          f@c = i;
          Sow@c;
          --j 
          ]   
         ]   
        ) & /@ g
     ][[2, 1]] 
  ];  
Riffle[(
     x = #;
     ToString@f@{x, #} & /@ m~r~M
     ) & /@ r[m = Min@{g, 0}, 
    M = Max@g
    ], "
  "] <> ""

এখানে একটি উদাহরণ আউটপুট n = 5:

      5
     5555     
    555555    
   5555555    
  555555555   
 55555555555  
5555554445555 
5555544444555 
 5555443305555
 55554432144555
 55555443234555
  5555544344555
   555554445555
    5555555555
      5555555 
       55555  
       55

ইনপুটটি 8প্রায় 4.5 মিনিট সময় নেয়।

আমার অ্যালগরিদমের দ্রুত ভাঙ্গনের জন্য:

আমি দুটি বর্ণন সারণী ব্যবহার করছি, fএবং g। প্রথমটি হ'ল একটি বিচ্ছুরিত মানচিত্র যা খালি খালি নেই containing পরেরটি হ'ল একটি তালিকা যা প্রতিটি ঘর-মানের জন্য সমস্ত স্থানাঙ্ক জোড়া যুক্ত করে (আমার মনে হয় এখানে আমার পুরানোগুলির সন্ধানের প্রয়োজন নেই)। আমি gগত পুনরাবৃত্তি থেকে প্রতিটি ঘর প্রসারিত করতে স্থানাঙ্কগুলির মাধ্যমে পুনরাবৃত্তি করছি। এটি করার জন্য আমি ম্যানহাটনের দূরত্বগুলিতে পুনরাবৃত্তি করি, প্রতিটি দূরত্বের জন্য সমস্ত সম্ভাব্য ভেক্টর তৈরি করে এবং ফলাফলকৃত সেলটি এখনও খালি রয়েছে কিনা তা যাচাই করি (আমি এটি পূরণ করি) fill পর্যাপ্ত নতুন ঘর তৈরি না হওয়া পর্যন্ত পুনরাবৃত্তি করুন।

আমার কাজ শেষ হয়ে গেলে আমি সর্বনিম্ন এবং সর্বাধিক সমন্বয় খুঁজে gপাই এবং আমি একটি উপযুক্ত গ্রিড তৈরি করি যা কোষগুলি সন্ধান করে পূরণ করা হয় f। বাকিগুলি কেবল লাইন ব্রেকগুলির সাথে সমস্ত কিছুকে একক স্ট্রিংয়ে যুক্ত করছে।

— মার্টিন ইন্ডার
সূত্র

5

সি - 309 305 301 275 বাইট

মেহ, খুব দীর্ঘ ... যদি কেবল একটির #Dপরিবর্তে কিছু বা কিছু টাইপ করা যায় #defineতবে সি সত্যিই দুর্দান্ত be অবশ্যই -Dসংকলক পতাকাগুলি সম্ভব তবে এটি আমার কাছে প্রতারণার মতো বলে মনে হয়, উত্স ফাইলটিতে থাকা অক্ষরগুলি ছাড়া অন্য কোনও অক্ষর রয়েছে।

চলমান নির্দেশাবলী:

সাবধান হও! প্রোগ্রামটি শুরু হওয়ার পরে আপনি যে প্রথম কী টিপবেন তা ইনপুট গঠন করে। '8' এর মাধ্যমে '0' ব্যতীত একটি চরিত্রের প্রবেশের পরে, কে কী অপরিজ্ঞাপিত জিনিসগুলি জানে তা জানে।

#define F(D,O)x=*r+O d;for(c=d;h*c--;x+=D)!g[x]?g[*w++=x]=l,--h:5;
L=400;g[1<<18];n;s;*r;*w;*m;h;l;d;x;main(c){n=getch()-32;r=w=g+L*L;for(l=g[*w++=80200]=16;l++<n;)for(m=w;r<m;r++)for(d=1,h=l-16;h;d++){F(L+1,-)F(L-1,-L*)F(-L+1,L*)F(~L,)}for(n=L*L;--n;)putch(n%L?g[n]+32:10);}

অগল্ফড (তবে ইতিমধ্যে ভবিষ্যতের গল্ফিংয়ের কথা ভাবছেন) সংস্করণ:

void exit(int);

#define L 400

#define FIND(D, X0)   x = *pread X0 d; \
                for(c = d; c--; x+=D) { \
                    if(x%L == 0 || x%L == L-1 || x/L == 0 || x/L == L-1) \
                        exit(5); \
                    if(!g[x]) { \
                        g[*pwrite++ = x] = '0' + l; \
                        if(!--children) \
                            goto pnext; \
                    } \
                }

main()
{
    int n = getch() - '0';
    //char g[3] = {};
    char g[L*L] = {};
    int plist[46324];

    int *pwrite = plist, *pread = plist;
    *pwrite++ = L/2*L + L/2;
    g[*plist] = '0';
    int factorial = 1;
    int l,  c, parents, children, d, x;
    for(l = 1; l <= n; l++) {
        for(parents = factorial; parents--; pread++) {
            children = l;
            for(d = 1; ; d++) {
                FIND(L + 1, - )
                FIND(L - 1, -L* )
                FIND(-L + 1, +L* )
                FIND(-L - 1, + )
            }
            pnext:;
        }
        factorial *= l;
    }
    int i;
    for(i = L*L; i--; )
        putch(i%L ? (g[i] ? g[i] : ' ') : '\n');
}

সম্পাদনা: আমি বুঝতে পেরেছি যেহেতু আমি ঘোষণাপত্রকে মূল () এর বাইরে সরিয়েছি, অ্যারেগুলি আর স্ট্যাকের জন্য বরাদ্দ করা যায় না, তাই আমি ওভারফ্লো ঝুঁকির ছাড়াই মেমরিটি অবরুদ্ধভাবে ব্যবহার করতে মুক্ত।

— feersum
সূত্র

2

রুবি - 296

g=[s=' ']*d=10**6
$*[g[50500]=0].to_i.times{|c|d.times{|x|g[x]==c&&(r=1;a=c;(4.times{|v|r.times{|w|g[q=x+r*(1e3*(v-1-v/2)+v%2-v/2)+w*(1e3*~0**(v/2)+~0**v)]==s&&a>~0?(g[q]=c+1;a-=1):0}};r+=1)while~0<a)}}
g=g.join.scan(/.{1000}/)
g.map{|s|s[/\d/]&&(puts s[g.map{|s|s[/\A */].size}.min..-1].rstrip)}

খানিকটা উচ্ছৃঙ্খল।

g=[s=' ']*d=10**6 # Initialize a big 1d array as a 2d grid
$*[g[50500]=0].to_i.times{|c| # For n times
    d.times{|x| # For each index in the grid
        g[x]==c&&( # If the element at x is equal to the current growth stage, c
            r=1;   # Initial manhattan radius = 1
            a=c;   # a is number of times the ameoba must replicate
            (4.times{|v| # For each of the 4 sides of the manhattan diamond
                r.times{|w| # For each node in each side
                    # Spawn the 'c+1' ameoba's from the c ameobas... 
                    # The messy formula gives the index of the space in the grid to try spawning
                    g[q=x+r*(1e3*(v-1-v/2)+v%2-v/2)+w*(1e3*~0**(v/2)+~0**v)]==s&&a>~0?(g[q]=c+1;a-=1):0 
                }
            };
            r+=1 # Increase the raidus of the manhattan diamond by one
            ) while~0<a # while not enough ameoba's have been spawned
        )
    }
}
g=g.join.scan(/.{1000}/) # Join the 1d array into a huge string and slice it into rows
# Strip away the empty spaces all around the graph and print it
g.map{|s|s[/\d/]&&(puts s[g.map{|s|s[/\A */].size}.min..-1].rstrip)}

— ভেক্টরকৃত
সূত্র

2

এপিএল (ডায়ালগ) (121)

{0::0⋄V←,⍳⍴Z←' '⍴⍨2/M←⌈4×.5*⍨3÷⍨+/!⍳⍵⋄Z[G;G←⌈M÷2]←'0'⋄Z⊣{⍵∘{⍵∘{+((⊃F[⍋+/¨|(F←V/⍨,Z=' ')-⊂⍺])⌷Z)←⍕⍵}¨⍺/⍺}¨V/⍨,Z=⍕⍵-1}¨⍳⍵}⎕

পারফরম্যান্স বৈশিষ্ট্য: এটি ও (এন!)। আমার সিস্টেমে, এন = 5 অবধি এটি তাত্ক্ষণিক; n = 6 এক সেকেন্ড সময় নেয়, n = 7 এক মিনিট সময় নেয় এবং n = 8 এক ঘন্টা সময় নেয়।

নন-গল্ফ সংস্করণ

টেস্ট:

      {0::0⋄V←,⍳⍴Z←' '⍴⍨2/M←⌈4×.5*⍨3÷⍨+/!⍳⍵⋄Z[G;G←⌈M÷2]←'0'⋄Z⊣{⍵∘{⍵∘{+((⊃F[⍋+/¨|(F←V/⍨,Z=' ')-⊂⍺])⌷Z)←⍕⍵}¨⍺/⍺}¨V/⍨,Z=⍕⍵-1}¨⍳⍵}⎕
⎕:
      5





           5555             
          555555            
         55555555           
        5555445555          
       555544445555         
      55554433445555        
     5555444323445555       
    5555544321455555        
     555554430455555        
     555555444555555        
       555555555555         
        5555555555          
         55555555           
          55555             
           555

ব্যাখ্যা:

{... }⎕: কীবোর্ড থেকে একটি লাইন পড়ুন, এটি মূল্যায়ন করুন, এবং ফলাফলটি কার্যক্রমে প্রেরণ করুন।
0::0: অন্য কোডটি যদি ত্রুটি উত্থাপন করে তবে কোনও একক ফেরত দিন 0। এটি কারণ 0 টি নোড সহ কোনও গ্রাফের জন্য আকার গণনা করার চেষ্টা করার সময় গণিত ব্যর্থ হয়, যখন আউটপুটটি হওয়া উচিত 0। (পূর্ববর্তী সংস্করণটি ছিল ⍵=0:0, (যদি ইনপুটটি 0ফিরে আসে 0অন্যথায় গ্রাফটি তৈরি করে)) তবে 0::0(কেবল 0এটি ব্যবহার করে ব্যর্থ হলে ফিরে আসুন) সংক্ষিপ্ত হয়)
M←⌈4×.5*⍨3÷⍨+/!⍳⍵: আউটপুট অভিমানী একটা মোটামুটি বৃত্ত (এই কাজ), ফ্যাক্টরিয়ালগুলির থেকে সমষ্টি 1থেকে ⍵(= আউটপুট এলাকায়), ডিভাইড 3 দ্বারা (Pi পাসে যথেষ্ট) 4 দ্বারা, বর্গমূল নিতে (আউটপুট ব্যাসার্ধ দান), সংখ্যাবৃদ্ধি, এবং সিলিং নিন। এটি বৃত্তের দ্বিগুণ ব্যাস দেয়, তাই আউটপুটটি ফাঁকা রাখার জন্য রুমের সাথে ফিট করে। এই সংরক্ষণ M।
V←,⍳⍴Z←' '⍴⍨2/M: স্পেসগুলির একটি এম-বাই-এম ম্যাট্রিক্স তৈরি করুন এবং এতে সঞ্চয় করুন Z। এটি আউটপুট ধরে রাখবে। সমস্ত উপাদানগুলির স্থানাঙ্কের একটি তালিকা সঞ্চয় করুন V।
Z[G;G←⌈M÷2]←'0': মাঝখানে উপাদান সেট Zকরতে 0।
Z⊢{... }¨⍳⍵: প্রত্যাবর্তন Zনম্বরে নিম্নলিখিত ফাংশন প্রয়োগের পরে, 1করতে ⍵:
- ⍵∘{... }V/,Z=⍕⍵-1: Zপূর্ববর্তী নোডের মান সহ প্রতিটি উপাদানের জন্য :
  - ⍵∘{... }⍺/⍺: বর্তমান নোডের জন্য, এন বার,
    - ⊃F[⍋+/¨|(F←V/⍨,Z=' ')-⊂⍺]: বর্তমান নোডের নিকটতম মুক্ত স্থান পান,
    - (... ⌷Z)←⍕⍵: এবং সেই স্থানটি Zবর্তমান নোডের মান হিসাবে সেট করুন ।

— সামুদ্রিক
সূত্র

ক্রমবর্ধমান ম্যানহাটন আমেরিকা

এন জন্য Ameoba গ্রাফ = 3: (প্রকাশ একটি 3 )