20

ভিডিও গেম মিনক্রাফ্টটি ভার্চুয়াল ওয়ার্ল্ড তৈরি করে এমন 3 ডি পূর্ণসংখ্যার ল্যাটিসিতে বিভিন্ন ধরণের ব্লক স্থাপন এবং অপসারণ সম্পর্কে । প্রতিটি জাল পয়েন্টে ঠিক একটি ব্লক থাকতে পারে বা খালি থাকতে পারে (একটি " এয়ার " ব্লক অফিশিয়ালি)। এই চ্যালেঞ্জের মধ্যে আমরা কেবলমাত্র 3 ডি ওয়ার্ল্ডের একটি অনুভূমিক 2 ডি প্লেন এবং এক ধরণের ব্লক: বুক নিয়ে উদ্বিগ্ন ।

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

একটি বুকের ব্লক কেবলমাত্র একটি খালি জাল পয়েন্টে রাখা যেতে পারে যদি এর চারটি অর্থোগোনালি সংলগ্ন পয়েন্টগুলি সমস্ত খালি থাকে, বা ঠিক যদি কোনও বুকের ব্লক থাকে যা ইতিমধ্যে ডাবল বুকের অংশ নয়। এই স্থাপনার নিয়মগুলি নিশ্চিত করে যে বুকের ব্লকগুলি ডাবল বেষ্টনের সাথে সংযোগ স্থাপন করে সে সম্পর্কে কোনও অস্পষ্টতা কখনই থাকতে পারে না।

উদাহরণস্বরূপ, ধরুন .খালি জায়গা এবং Cএটি একটি বুক: (সংখ্যাগুলিও খালি স্থান এবং কেবল সনাক্তকরণের উদ্দেশ্যে))

.......C..
.1.C2.C3..
........5C
.CC4..CC..
..........

একটি বুক স্পট 1 এ রাখা যেতে পারে কারণ এর 4 প্রতিবেশী খালি রয়েছে।
একটি বুক স্পট 2 এ স্থাপন করা যেতে পারে কারণ প্রতিবেশী বুকটি ডাবল বুকের (এখনও) অংশ নয়।
একটি বুক স্পট 3 এ স্থাপন করা যায় না কারণ ডাবল বুক কীভাবে গঠন হয় সে সম্পর্কে দ্ব্যর্থহীনতা থাকবে।
একটি বুক স্পট 4 এ স্থাপন করা যায় না কারণ প্রতিবেশী বুক ইতিমধ্যে ডাবল বুকের অংশ part
একটি বুক স্পট 5 স্থাপন করা যেতে পারে ত্রিভুজ প্রতিবেশী ডাবল বুক কিছুই প্রভাবিত করে না।

গ্রিড পরলোক এলাকায় ধরে নেওয়া যাক খালি, যে পরিবর্তন করা হয় .একটি গ্রিড মধ্যে *একটি বুক এতে ফলাফল স্থাপন করা যেতে পারে যদি:

******.C**
***C**C.**
*..***..*C
.CC.*.CC.*
*..***..**

অবশ্যই সমস্ত *জায়গাগুলি একই সাথে বুকের সাথে দখল করা যায় না, তবে আপনার যদি কেবল একটি বুক থাকে তবে এটি যে কোনও একটিতে রাখা যেতে পারে।

চ্যালেঞ্জ

একটি প্রোগ্রাম বা ফাংশন যে একটি লাগে লিখুন .এবং Cগ্রিড, এবং প্রত্যেক পরিবর্তন .একটি থেকে *একটি বুক সেখানে স্থাপন করা যেতে পারে, মুদ্রণ বা ফলে গ্রিড ফিরিয়ে আনে।

ইনপুট স্টিডিন বা কোনও ফাইল থেকে বা কোনও ফাংশনের স্ট্রিং আর্গুমেন্ট হিসাবে হতে পারে।
আপনি ধরে নিতে পারেন ইনপুটটি সুগঠিত হয়েছে - যেমন পাঠ্যের একটি সঠিক আয়তক্ষেত্রাকার গ্রিড, কমপক্ষে 1 টি অক্ষর প্রশস্ত এবং লম্বা, কেবল এটিই রয়েছে .এবং Cআপনি বিকল্পভাবে ধরে নিতে পারেন শেষ সারির পরে একটি অনুবর্তনযোগ্য নিউলাইন রয়েছে (এবং আউটপুটে কোনওটি থাকতে পারে )।
আপনি ধরে নিতে পারেন ইনপুটটিতে বুকের ব্যবস্থা উপরের নিয়মের সাথে সামঞ্জস্যপূর্ণ। কোন বুক দ্বিগুণ বুকে গঠন করে তা নিয়ে কখনই অস্পষ্টতা থাকবে না।
ইচ্ছা, আপনি যে কোনো তিনটি স্বতন্ত্র ব্যবহার করতে পারেন মুদ্রণযোগ্য হওয়া ASCII স্থানে অক্ষর ., Cএবং *। আপনি নতুন লাইনের জায়গায় অন্য কিছু ব্যবহার নাও করতে পারেন।
সমস্ত বুকে সাধারণ বুক হয়। আটকা পড়ে না বুকে বা শেষের বুকে ।

স্কোরিং

সবচেয়ে কম বাইটস সহ জমাটি জয়লাভ করে।

^{মাইনক্রাফ্ট সম্পর্কিত চ্যালেঞ্জের জন্য এটি কিছুটা চ্যালেঞ্জিং, নেদারল্যান্ডাল পোর্টাল সনাক্তকরণ চেষ্টা করুন ।}

code-golf

— ক্যালভিনের শখ
সূত্র

5

একটি মাইনক্রাফটিং দৃষ্টিকোণ থেকে, আমি খেলাটিতে এটি বেশ বিরক্তিকর দেখতে পেয়েছি। আটকে আছে বুকে ভাল জিনিস: পি

— স্প 3000

স্টিডিন বা একক স্ট্রিং আর্গুমেন্টের গ্রিড ইনপুট নেওয়ার সময় গ্রিডের মাত্রাগুলি অতিরিক্ত ইনপুট হিসাবে গ্রহণ করা কি গ্রহণযোগ্য? বা নতুন লাইন এবং স্ট্রিং দৈর্ঘ্য থেকে এটি অনুমান করা আছে?

— স্তর নদী সেন্ট

পুনঃটুইট

— ক্যালভিনের শখ

কৌতূহলের বাইরে, আমার নিজের সহ প্রতিটি উত্তরের একটি ডাউনভোট থাকবে কেন? আমি কেবল ধরে নিতে পারি যে এটি একই ব্যক্তি, তারা কি ব্যাখ্যা করার যত্ন নেবে?

— স্তর নদী সেন্ট

অতিরিক্ত চ্যালেঞ্জের জন্য, বুকের জন্য সর্বোত্তম স্থান নির্ধারণের জন্য একটি প্রোগ্রাম লিখতে পারে; এটি হ'ল এমন একটি কনফিগারেশন সন্ধান করুন যা নতুন বুকের মধ্যেও নিয়ম ভঙ্গ না করে সর্বাধিক সংখ্যক অতিরিক্ত বুকে স্থাপন করতে দেয়।

— এজেম্যানসফিল্ড

11

সিজেম, 82 76 66 62 58 54 বাইট

qN/::~4{[8_]f/[9_]f*z{[{1$8-g)+}*]W%}%}*{_8<\2<8?}f%N*

ইনপুট ফর্ম্যাটটি 0এয়ার সেল এবং 8বুকের ঘরের জন্য প্রত্যাশা করে । আউটপুটটিতে এমন 1সমস্ত কক্ষ রয়েছে যা বুকের সাহায্যে স্থাপন করা যায়।

আপডেট : ~~একটি বাগ ঠিক করা। 3 বাইট বৃদ্ধি~~ পেয়েছে :( আরও গল্ফ করেছেন :)। @ স্প3000-কে 4 টি বাইট সংরক্ষণ করা হয়েছে

উদাহরণ ইনপুট:

আউটপুট:

আমি মনে করি আমার আপাতত গল্ফ করা হয়েছে ...

ব্যাখ্যা

qN/::~                   "This part converts the input into array of integer array";
qN/                      "Split input on new line";
   ::~                   "Parse each character in each row as integer";

4{[8_]f/[9_]f*z{[{1$8-g)+}*]W%}%}*

4{   ...z{       W%}%}*  "Run the logic 4 times, first, columns in correct order, then,";
                         "columns in reverse order, then for rows";
  [8_]f/[9_]f*           "Convert adjacent chests represented by two 8 into two 9";
                         "This happens for all the rows in the columns iterations and";
                         "for all the columns in the rows iterations";
  {               }%     "For each row/column";
   [{        }*]         "Reduce and wrap it back in the array";
     :I8-                "Store the second number in I, remove 8 from it";
         g               "Do signum. Now we have -1 for < 8 number, 0 for 8 and 1 for > 8";
          )+I            "Increment to get 0, 1 & 2. Add it to first number and put I back";

{_8<\2<8?}f%N*           "This part converts the output from previous iterations";
                         "to 3 character based final output and prints it";
{        }f%             "Map each row using the code block";
 _8<   8?                "If the value is greater than 7, make it 8, else:";
    \2<                  "If the value is greater than 1, make it 0, else 1";
            N*           "Join the arrays using new line";

এটি এখানে অনলাইনে চেষ্টা করুন

— অপ্টিমাইজার
সূত্র

8

.NET রেইজেক্স ( রেটিনা ), 434 416 310 + 1 = 311 বাইট

সর্বশেষ চ্যালেঞ্জের পরে আমি রেজেজেমে উত্তর দিয়েছি (নেদারল্যান্ডস পোর্টাল চ্যালেঞ্জ এই চ্যালেঞ্জের সাথে যুক্ত), অবশেষে আমি একটি কমান্ড-লাইন সরঞ্জাম লিখতে শুরু করলাম, যা। নেট স্টাইলের নিয়মিত প্রকাশের জন্য দোভাষী হিসাবে কাজ করে, তাই আমি প্রশ্নের উত্তর দিতে পারি রেগেক্সকে চ্যালেঞ্জ না করেই বলা যায় যে তারা এককভাবে ভাষা নয়। আমি রেটিনা নাম রেখেছি।

এখন, এই চ্যালেঞ্জটি নিজেকে একটি রেজেক্স জমা দেওয়ার পক্ষে খুব ভাল ndণ দেয় না, তবে আমাকে এখন রেটিনা ব্যবহার করতে হয়েছিল। ;) (প্লাস, এসপি 3000 আমাকে চ্যাটে এমনটি করার জন্য চ্যালেঞ্জ জানিয়েছে)) সুতরাং এটি এখানে:

রেজেক্স ফাইল

m`(?<=(?=.(.)*).*)(?<=((?<=(?<2>C|C(?(1)!)(\n|(?<-1>.))*)?)C(?=(?<2>C|(\n|(?<-1>.))*(?(1)!)C)?)(()(?(6)!)|(?<=^(?(7)!)(?<-7>.)*C).*\n(.)*()(?(8)!)))?){2}_(?=(?<2>((?(10)!)()|(?(11)!)()(.)*\n.*(?=C(?<-12>.)*(?(12)!)$))(?<=(?<2>C|C(?(1)!)(\n|(?<-1>.))*)?)C(?=(?<2>C|(\n|(?<-1>.))*(?(1)!)C)?))?){2}(?<-2>)?(?(2)!)

প্রতিস্থাপন ফাইল

রেজেক্স ফাইলটি বেশিরভাগ ক্ষেত্রে কেবল রেজেক্স হয়, কেবলমাত্র `আপনি এই ক্ষেত্রে কেবলমাত্র মাল্টলাইন মোডে ফাইলটিতে কয়েকটি বিকল্প রাখতে পারেন। দুটি ফাইল দেওয়া হলে, রেটিনা স্বয়ংক্রিয়ভাবে প্রতিস্থাপন-সমস্ত মোড ধরে নেয়। এই দুটি ফাইল একটি প্রোগ্রাম সংজ্ঞায়িত করে যা STDIN থেকে ইনপুট পড়ে এবং ফলাফলটি STDOUT এ মুদ্রণ করে।

আপনি এটি RegexHero এবং RegexStorm এ পরীক্ষা করতে পারেন । রেজেক্স নতুন লাইনের সাথে এবং পিছনে উভয়ই কাজ করে এবং _এর জায়গায় ব্যবহার করে .। (স্পষ্টতই, রেজেক্সটোরমে মাঝে মধ্যে সমস্যা নেই যদি কোনও অনুমানযোগ্য নতুন লাইন না পাওয়া যায় তবে রেজেক্সহিরো মনে হয় উভয় ক্ষেত্রেই জরিমানা করে।

রেজেক্সে একটি ভয়াবহ পরিমাণে সদৃশ রয়েছে এবং এটিকে উল্লেখযোগ্যভাবে সংক্ষিপ্ত করার জন্য আমার কাছে বেশ কয়েকটি ধারণা রয়েছে ... আমি পরে চেষ্টা করব এবং তারপরে একটি ব্যাখ্যা যুক্ত করব। ইতিমধ্যে, আমাকে যদি আপনি এমন কোনও ফলাফল খুঁজে পেতে পারেন যা কোনও ভুল ফলাফল দেয় know

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

7

জে, 75 73 বাইট

((,.|.)0 _1 0 1)(+:@](LF,@:,.~'*.C'{~>.)(2=f)+.[f]*f=.[:+/|.!.0)'C'&=;._2

, প্রশ্নে বিন্যাস ব্যবহার ব্যবহার ./ */ C, স্থান জন্য / ব্যবহারযোগ্য স্থান / বুকে যথাক্রমে।

সম্পাদনা করুন: একটি ছোট বাগ সংশোধন করে (আমি দুর্ঘটনাক্রমে আশেপাশের খালি স্থান হিসাবে সঠিকভাবে আচরণ করার পরিবর্তে একটি টরাস ব্যবহার করি)।

ব্যাখ্যা

## Preparation
              'C'&=;._2  NB. Map ./C to 0/1, turn into matrix
((,.|.)0 _1 0 1)         NB. Compute offsets to shift into each direction
                         NB. (i.e. [[_1 0], [1 0], [0 _1], [0 1]] in any order)


## "Part B"
(2=f)+.[f]*f=.[:+/|.!.0  NB. This part computes a matrix that is 1 for cells that
                         NB. cannot contain a chest:
              [:+/|.!.0  NB. Sum of shifts: shift in each of the four cardinal
                         NB. directions (using the array above) and then sum up.
           f=.           NB. Define this function as `f`; we'll use it some more.
         ]*              NB. Multiply by the "is chest" matrix: this isolates
                         NB. double-chests.
       [f                NB. Sum of shifts--1 for double-chest neighbours.
(2=f)                    NB. Isolate cells with two neighbouring chest.
     +.                  NB. Boolean or--either two neighbouring chests or next
                         NB. to a double-chest.

## Wrap up the result
(+:@] (fmt >.) PartB)    NB. Maximum of the array from the above and twice the "is
 +:@]      >.  PartB     NB. chest" matrix--this is 0,1,2 for '*', '.' or chest,
                         NB. respectively.

## Output formatting
LF,@:,.~'*.C'{~          NB. Format output...
        '*.C'{~          NB. Map 0,1,2 to '*.C' by using the value as index
LF   ,.~                 NB. Append line feed at end of each line
  ,@:                    NB. Ravel into one line

— জোনাকি না
সূত্র

4

সি, 193

স্বচ্ছতার জন্য 2 অজানা নিউলাইন অবিকৃত কোড সম্পর্কিত সম্মানের সাথে পরিবর্তনগুলি অন্তর্ভুক্ত: অক্ষর আক্ষরিক পরিবর্তে অক্ষর ascii কোড হিসাবে; অক্ষরগুলি সংরক্ষণ করার জন্য ভি = 0, স্ট্রলেন এবং স্ট্রিচআর এর পুনঃব্যবস্থাপনা (স্ট্রেচআর হ'ল ugliest, কারণ এর অর্থ হ'ল একটি গণনা যা অন্যথায় কেবল একবার সম্পাদন করা হত, প্রতি সেলে 5 বার সঞ্চালিত হয়!)

সি ফাংশনগুলি স্ট্রিংগুলিকে আর্গুমেন্ট হিসাবে স্বীকার করে না বা মান হিসাবে ফিরিয়ে দেয় না, তাই আমি সবচেয়ে ভাল যা করতে পারি তা qহ'ল ইনপুট স্ট্রিংয়ের পয়েন্টার। ফাংশনটি স্ট্রিংটি সংশোধন করে এবং ফাংশনটি আউটপুটটি মূল স্ট্রিংয়ে পাওয়া যায়।

g(char*q){int v,j,w,l;
int f(p,d){int s=0,i=w=strchr(q,10)-q+1,r;for(;w/i;i-=i-1?w-1:2)r=p+i,r>-1&r<l&&q[r]==67&&++s&&d&&f(r,0);v|=s>d;}
for(j=l=strlen(q);j--;f(j,1),46-q[j]||v||(q[j]=42))v=0;}

বিধি সংক্ষিপ্তসার:

একটি ফাঁকা স্কোয়ার (এতে সি বা নিউলাইন থাকে না) রূপান্তর করা যেতে পারে যদি এতে সিসি সহ সর্বাধিক 1 প্রতিবেশী থাকে

... এবং সেই প্রতিবেশীর কোনও সি এর সাথে কোনও প্রতিবেশী নেই

ফাংশন জিতে একটি ফাংশন রয়েছে যা গভীরতা 1 থেকে গভীরতা 0 পর্যন্ত পুনরাবৃত্তি করে only কেবল মাত্র 2 স্তরের পুনরাবৃত্তির সাথে একটি সাধারণ f(r,0)পুনরাবৃত্তি কল করবে, এর জন্য কোনও প্রয়োজন নেই f(r,d-1)!

পরীক্ষা প্রোগ্রামে অবহেলিত কোড

ইনপুট পরীক্ষার স্ট্রিংটি হার্ডকোডযুক্ত। getsএবং এতে scanfনতুন লাইনের সাথে একটি ইনপুট স্ট্রিং গ্রহণ করবে না; তারা প্রতিটি নিউলাইনে এটিকে টুকরো টুকরো করে ফেলে।

char n[]=".......C..\n...C..C...\n.........C\n.CC...CC..\n..........";

g(char*q){

  int v,j,w,l;

  int f(p,d){                    //p=cell to be checked,d=recursion depth
    int s=0,i=w,r;               //sum of C's found so far=0, i=width
    for(;w/i;i-=i-1?w-1:2)       //For i in   w,1,-1,-w   = down,right,left,up
      r=p+i,                     //r=cell adjacent to p
      r>-1&r<l&&q[r]=='C'&&++s   //If r not out of bounds and equal to C, increment s...
        &&d&&f(r,0);             //...and if recursion depth not yet at zero, try again one level deeper. 
    v|=s>d;                      //If the local s exceeds d, set global v to true to indicate invalid.
  }

  w=strchr(q,10)-q+1;            //width equals index of first newline + 1                   
  l=strlen(q);                   //length of whole string;
  for(j=l;j--;)                  //for l-1 .. 0 
    v=0,                         //clear v
    f(j,1),                      //and scan to see if it should be set
    '.'-q[j]||v||(q[j]='*');     //if the character is a '.' and v is not invalid, change to '*'
}

main(){
  g(n);
  puts(n);
}

প্রশ্নের উদাহরণের উপর ভিত্তি করে আউটপুট

******.C**
***C**C.**
*..***..*C
.CC.*.CC.*
*..***..**

— স্তর নদী সেন্ট
সূত্র

1

জাভাস্ক্রিপ্ট (ES6) 124 129

0 (*), 6 (সি), 7 (।) অক্ষর ব্যবহার করে

F=s=>[for(c of(d=[o=~s.search('\n'),-o,1,i=-1],s))
   d.map(j=>t-=s[i+j]==6&&~d.some(k=>s[i+j+k]==6),t=i++)|c<7|t>i&&c
].join('')

অবহেলিত এবং ব্যাখ্যা

F=s=>
{
  o=~s.search('\n') // offset to prev row (~ is shorter than +1 and sign does not matter)
  d=[o,-o,1,-1] // array of offset to 4 neighbors
  i=-1
  result = '' // in golfed code, use array comprehension to build the result into an array, then join it
  for (c of s) // scan each char
  {
    t = i++ // set a starting value in t and increment current position in i
    d.forEach(j => // for each near cell, offset in j
    {         
      if (s[i+j]==6) // if cell contains a Chest, must increment t
      {  
        // In golfed code "~some(...)" will be -1(false) or -2(true), using decrement instead of increment
        if (d.some(k=>s[i+j+k]==6)) // look for another Cheast in the neighbor's neighbors
        {
          // more than one chest, position invalid
          t += 2
        }
        else
        {
          t += 1
        }
      }
    })
    if (c < 7 // current cell is not blank
        || t > i) // or t incremented more than once, position invalid
    {
       result += c // curent cell value, unchanged
    }
    else
    {
       result += 0 // mark a valid position 
    }
  }
  return result
}

টেস্ট সালে ফায়ারফক্স / ফায়ারবাগ কনসোলটি

a='\
7777777677\n\
7776776777\n\
7777777776\n\
7667776677\n\
7777777777\n';

console.log(F(a))

আউটপুট

— edc65
সূত্র

1

পার্ল, 66

রিজএক্সপ্যাকের সাথে মিলে যাওয়া বুকের দ্বন্দ্বগুলি দীর্ঘ দিকে শেষ হয়েছিল, সুতরাং এবার সিজেমের সাথে কোনও প্রতিযোগিতা নেই।

#!perl -p0
/.
/;$"=".{@-}";s%0%s/\G0/2/r!~/2((.$")?2(.$")?|2$"|$"2)2/s*1%eg

ইনপুটটিতে ফাঁকা এবং বুকের ফাঁকা স্থানগুলির জন্য 0 এবং 2 ব্যবহার করে, আউটপুটগুলিতে দাগগুলি চিহ্নিত করতে 1।

এখানে চেষ্টা করুন ।

— nutki
সূত্র

0

পাইথন 2 - 281 বাইট

f=lambda x,y:sum(m[y][x-1:x+2])+m[y-1][x]+m[y+1][x]
m=[];o=''
try:
 while 1:m+=[map(int,'0%s0'%raw_input())]
except:a=len(m[0]);l=len(m);m+=[[0]*a]
for y in range(l*2):
 for x in range(1,a-1):
    if y<l:m[y][x]*=f(x,y)
    else:o+=`2if m[y-l][x]else +(f(x,y-l)<5)`
 if y>=l:print o;o=''

(8 এবং 9 লাইনগুলি একটি একক ট্যাব চরিত্রের সাথে লক্ষ্যযুক্ত, যা এসই 4 টি স্পেসে রূপান্তর করে this

ইনপুট: 0কোনও বুকের জন্য নয়, বুকের 2জন্য
অউপুট: 0কোনও বুকের জন্য নয়, 2বিদ্যমান বুকের 1জন্য, সম্ভাব্য নতুন বুকের জন্য

Godশ্বর, এটি ভয়ঙ্কর। আমার অবশ্যই অনুশীলনের বাইরে থাকতে হবে। আমি এটিতে আমার জানা প্রতিটি কৌশল ছুঁড়ে ফেলেছি এবং এটি বেরিয়ে এসেছিল ... ভাল, এটি 281 বাইট হিসাবে প্রকাশিত হয়েছিল, রেগেেক্সের একটি উত্তর ব্যতীত প্রতিটি জবাব হারাচ্ছে , হাহা। আমি সতর্কতার সাথে অনুভব করি যে আমি এটাকে ভালভাবে গল্ফ দিয়েছি, তাই আমি অনুমান করছি যে আমার অ্যালগরিদমটি আদর্শের চেয়ে কম ছিল।

Ungolfed:

def f(x,y):
    """Given x,y coords of the board, return the sum of that point and all
    adjacent points.
    """
    return (sum(board[y][x-1:x+2]) # (x-1,y) + (x,y) + (x+1,y)
            + board[y-1][x]
            + board[y+1][x])
board=[]
output=''
try:
    while True:
        row = '0%s0' % raw_input() # line from stdin with a leading and trailing 0
        board.append(map(int, row)) # convert to list of ints
except:
    pass # exception is thrown when stdin is empty

board_width = len(board[0])
board_height = len(board)

board.append([0]*board_width) # new row of all 0s

for y in xrange(board_height*2):
    # board_height multiplied by 2 so we can use this loop to simulate two
    for x in xrange(1,board_width-1):
        if y < board_height: # "first loop"
            board[y][x] *= f(x,y) # multiply everything on the board by itself + sum
                                  # of neighbours
                                  # empty cells (0) stay 0 no matter what
                                  # lone chests (2 surrounded by 0) become 2*2==4
                                  # double chests (2 touching another 2) are weird:
                                  # - one chest becomes 2*(2+2)==8
                                  # - the other chest becomes 2*(2+8)==20
        else: # "second loop"
            if board[y - board_height][x] != 0:
                output += '2' # anything not equal to 0 is an existing chest
            else:
                valid = f(x, y - board_height) < 5 # if the sum of neighbours > 4, the
                                                   # current cell is either beside a
                                                   # double chest or more than one
                                                   # single chest
                output += '01'[valid]
    if y >= board_height: # only print during the "second loop"
        print output
        output=''

— undergroundmonorail
সূত্র

মাইনক্রাফ্ট বুকে স্থান