ফ্রায়ার সিমুলেটর

31

আপনার কাজটি খাবারের টুকরোগুলিতে বাটারের প্রভাবগুলি মডেল করা। ক্রাস্টের তিনটি স্তর যুক্ত করুন।

[[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], // in
 [0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0],
 [0,0,0,1,1,1,0,0,0,0,0,0,0,1,1,0,0,0],
 [0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,1,0,0],
 [0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0],
 [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]]
                   |
                   V
[[0,0,0,2,0,0,0,0,0,0,0,0,0,0,0,2,1,2],
 [0,0,2,1,2,2,0,0,0,0,0,0,0,2,2,0,2,0],
 [0,0,2,1,1,1,2,0,0,0,0,0,2,1,1,2,0,0],
 [0,0,0,2,1,2,0,0,0,0,0,2,1,1,2,1,2,0],
 [0,0,0,0,2,0,0,0,0,0,0,0,2,1,1,1,2,0],
 [0,0,0,0,0,0,0,0,0,0,0,0,0,2,2,2,0,0]]
                   |
                   V
[[0,0,3,2,3,3,0,0,0,0,0,0,0,3,3,2,1,2],
 [0,3,2,1,2,2,3,0,0,0,0,0,3,2,2,3,2,3],
 [0,3,2,1,1,1,2,3,0,0,0,3,2,1,1,2,3,0],
 [0,0,3,2,1,2,3,0,0,0,3,2,1,1,2,1,2,3],
 [0,0,0,3,2,3,0,0,0,0,0,3,2,1,1,1,2,3],
 [0,0,0,0,3,0,0,0,0,0,0,0,3,2,2,2,3,0]]
                   |
                   V
[[0,4,3,2,3,3,4,0,0,0,0,0,4,3,3,2,1,2], // out
 [4,3,2,1,2,2,3,4,0,0,0,4,3,2,2,3,2,3],
 [4,3,2,1,1,1,2,3,4,0,4,3,2,1,1,2,3,4],
 [0,4,3,2,1,2,3,4,0,4,3,2,1,1,2,1,2,3],
 [0,0,4,3,2,3,4,0,0,0,4,3,2,1,1,1,2,3],
 [0,0,0,4,3,4,0,0,0,0,0,4,3,2,2,2,3,4]]

সামান্য ভিজ্যুয়াল এইড:

কোড স্নিপেট দেখান

ইনপুটটি ফ্রির প্রতিনিধিত্ব করে এমন একটি বুলিয়ান ম্যাট্রিক্স: তেলের জন্য 0, খাবারের জন্য 1। আপনার ক্রিয়াকলাপ বা প্রোগ্রামটিতে 1s এর আশেপাশে 3s, 3s এবং 4s হিসাবে তিনটি স্তর যুক্ত করা উচিত, সুতরাং 0 এর কিছুটি ওভাররাইট করে। বাটার ডোনটস (গর্তযুক্ত খাবার) এবং crumbles (বিচ্ছিন্ন খাদ্য "পিক্সেল") সহ যে কোনও আকার বা আকারের খাবারের জন্য অনুভূমিকভাবে এবং উল্লম্বভাবে (তবে তির্যক নয়) আঁকড়ে ধরে থাকে এবং ফ্রেয়ারের সীমানায় সীমাবদ্ধ থাকে। বাটারের প্রথম স্তরগুলি ক্রাস্টে পরিণত হয় এবং পরেগুলির দ্বারা প্রভাবিত হয় না।

অন্য কথায়, প্রথমে আপনার 1s এর ভন-নিউমন পাড়াগুলিতে থাকা সমস্ত 0 গুলি 2s এর সাথে প্রতিস্থাপন করা উচিত, তারপরে সমস্ত 0s 2s এর ভন-নিউমন পাড়াগুলিতে 3s দিয়ে প্রতিস্থাপন করুন এবং অবশেষে সমস্ত 0 গুলি ভন-নিউম্যান পাড়াগুলিতে প্রতিস্থাপন করুন 4 এস সহ 3 এস। সুতরাং, 2,3,4 সংখ্যাটি ম্যানহাটনের দূরত্বের চেয়ে নিকটবর্তী 1-কোষের চেয়ে বড় একটি পরিমাণের প্রতিনিধিত্ব করে।

ফ্রায়ারের আকার কমপক্ষে 3-বাই -3 হবে এবং এতে কমপক্ষে এক টুকরো খাবার থাকবে। I / O নমনীয় - আপনার ভাষার জন্য উপযুক্ত একটি ম্যাট্রিক্স ফর্ম্যাট ব্যবহার করুন। অতিরিক্ত শ্বেত স্থান অনুমোদিত, খাটো কোড আকাঙ্ক্ষিত, লুফোলস নিষিদ্ধ।

আরও পরীক্ষা:

 [[0,0,1], // in
  [0,0,0],
  [0,1,0]]

 [[3,2,1], // out
  [3,2,2],
  [2,1,2]]

 -

 [[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], // in
  [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],
  [1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,0,1,1,1,0,0,0,0,0,0],
  [1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,0,0,0,0],
  [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,0,1,1,1,1,1,0,0,1,0,0,0],
  [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,1,0,0,1,0,0,0,0,0,0],
  [0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,1,1,0,1,0,0,0,0,0,0,0,0,0,0],
  [0,0,0,0,1,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0],
  [0,0,0,1,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1],
  [0,0,1,0,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0],
  [0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],
  [0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,1,1,1,0,1,1,0,0,0,0,0,0],
  [0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],
  [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0]]

 [[3,4,0,0,0,0,0,0,0,0,0,0,0,0,0,0,4,3,3,4,3,3,3,4,4,4,3,2,1], // out
  [2,3,4,0,0,0,0,0,0,0,0,0,0,0,0,4,3,2,2,3,2,2,2,3,3,4,4,3,2],
  [1,2,3,4,0,0,0,0,0,0,0,0,0,0,4,3,2,1,1,2,1,1,1,2,2,3,4,4,3],
  [1,1,2,3,4,4,4,4,0,0,0,0,0,4,3,2,1,1,1,1,1,1,1,1,1,2,3,4,4],
  [2,2,3,4,4,3,3,3,4,0,0,0,4,3,2,1,1,2,1,1,1,1,1,2,2,1,2,3,4],
  [3,3,4,4,3,2,2,2,3,4,0,0,4,3,2,1,2,2,1,1,2,2,1,2,3,2,3,4,4],
  [4,4,4,3,2,1,1,1,2,3,4,0,4,3,2,1,1,2,1,2,3,3,2,2,2,3,4,3,3],
  [0,4,3,2,1,1,2,1,2,3,4,0,0,4,3,2,2,2,1,2,3,3,2,1,1,2,3,2,2],
  [4,3,2,1,1,2,2,1,2,3,4,0,0,0,4,3,3,3,2,3,4,4,3,2,2,3,2,1,1],
  [3,2,1,2,1,1,1,1,2,3,4,0,0,0,0,4,4,3,3,3,4,3,3,3,3,3,2,1,2],
  [4,3,2,1,2,2,1,2,3,4,0,0,0,0,0,4,3,2,2,2,3,2,2,3,4,4,3,2,3],
  [0,4,3,2,1,1,2,3,2,3,4,0,0,0,4,3,2,1,1,1,2,1,1,2,3,4,4,3,4],
  [0,0,4,3,2,2,3,2,1,2,3,4,0,0,0,4,3,2,2,2,3,2,2,3,4,4,3,2,3],
  [0,0,0,4,3,3,4,3,2,3,4,0,0,0,0,0,4,3,3,3,4,3,3,4,4,3,2,1,2],

সামান্য ভিজ্যুয়াল এইড:

কোড স্নিপেট দেখান

ভিজ্যুয়ালাইজেশনের জন্য ধন্যবাদ @ তছল্লাকা।

code-golf  matrix 
— ngn
সূত্র
4
দয়া করে আপনি কি ওয়াকথ্রো উদাহরণ প্রদান করতে পারেন? 2, 3 বা 4 কখন বা কেন ব্যবহার করবেন তা আমার কাছে পরিষ্কার নয় (আমি ভিটিসি অস্পষ্ট হিসাবে তবে আমার এখন একটি হাতুড়ি আছে এবং দেখে মনে হচ্ছে আমি সংখ্যালঘুতে রয়েছি)
— শেগি
1
@ শেগি আমার বোধগম্য হ'ল সংখ্যাগুলি "স্তর" চিহ্নিত করে। একটি 1 ডি উদাহরণ: 000010000→ 000212000→ 003212300→043212340
— জর্জিওটসন
4
ধন্যবাদ, @ জর্জওয়াটসন; দেখে মনে হচ্ছে তুমি ঠিক আছ অর্থাৎ বৈশিষ্ট থেকে পরিষ্কার নয় যদিও, যা উল্লেখ করে যে "পিটা" শুধুমাত্র খাদ্য লাগিয়া থাকা উচিত এবং পিটা আগের স্তর করছে না পরে বেশী দ্বারা প্রভাবিত। এটি নির্ধারণের একমাত্র উপায় হ'ল পরীক্ষার কেসগুলি থেকে এটি বোঝা।
— শেগি
6
আপনার পরবর্তী চ্যালেঞ্জটি একটি ফ্রিয়ার সিমুলেটর হওয়া উচিত।
— ম্যাজিক অক্টোপাস আরন
5
@ngn সত্যিই ? (͡ ° ͜ʖ ͡ °)
— ম্যাজিক অক্টোপাস উরান

উত্তর:

10

স্টেনসিল : 1 + 14 = 15 বাইট

কমান্ড-লাইন যুক্তি: 3

কোড: s<×⌈/N:1+⌈/N⋄S

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

3 নিম্নলিখিত রূপান্তরটি তিনবার পুনরাবৃত্তি করুন:

 s যদি কিনা গুলি পরী অ খালি

 < এর চেয়ে কম

 × এর সাইনাম

 ⌈/N ভন নিউমন এন পাড়ার সর্বাধিক

 : তারপরে নতুন মান হয়ে যায়

  1+ এক প্লাস

  ⌈/N ভন নিউমন এন পাড়ার সর্বাধিক

 ⋄ আর

  S মান অশোধিত থাকে ( এস এলফ)

— আদম
সূত্র
এটি 15 বাইট (আর্গুমেন্টের জন্য 14 + 1 3) হওয়া উচিত নয়? স্টেনসিলটি প্রথমবার দেখেছি , তবে আমি যদি সঠিকভাবে বুঝতে পারি তবে ডায়ালগ এপিএল ম্যাট্রিক্সের সুবিধা অর্জনের জন্য এটি একটি এক্সটেনশন ? এছাড়াও, ক্ষুদ্র মন্তব্য: শুরুতে রাজধানী এন Neumannআপনার ব্যাখ্যার শেষে ছোটটির পরিবর্তে সাহসী হওয়া উচিত। :)
— কেভিন ক্রুইজসেন
1
ঠিক আছে, নতুন
— sensকমত্যটি
1
@ কেভিন ক্রুজসেন স্টেনসিল সহজে সেলুলার অটোমেটনের জন্য ডায়ালগ এপিএল সরঞ্জাম হিসাবে ব্যবহার করা যেতে পারে, তবে এটি গল্ফিংয়ের ভাষা হিসাবে নিজের মতো করে দাঁড়িয়েছে। বস্তুতঃ, সরঞ্জামের ব্যবহার এবং গল্ফিং ভাষার মাঝে চলাকালীন কারও কোডের পরিবর্তনের প্রয়োজন হতে পারে।
— অ্যাডম
1
@ কেভিন ক্রুজসেন না, সাহসী ফাইনাল এন ইচ্ছাকৃত। দেখুন ডকুমেন্টেশন যে স্টেনসিল এর প্রথম এবং শেষ চিঠি ব্যবহার মুর এবং ভন Neumann সঙ্গে এবং স্ব ছাড়া জন্য স্মৃতিবর্ধনবিদ্যা, এবং ব্যবহারের ছোট হাতের অক্ষরে এবং অ প্যাকিং এর সংখ্যা ও উপাদানের প্রকৃত তালিকার জন্য স্মৃতিবর্ধনবিদ্যা যেমন বড় হাতের অক্ষরে।
— অ্যাডম
@ কেভিন ক্রুজসেন আমার আরও উল্লেখ করা উচিত যে স্টেইনসিল ডায়ালগ এপিএলের ⌺বিল্ট-ইন ( স্টেনসিল নামে পরিচিত ) এর একটি ইন্টারফেস মাত্র । আরও দেখুন কারনে ডকুমেন্টেশান । একটি সম্পূর্ণ গল্ফ ভাষা একটি একক বিল্ট-ইন উপর নির্মিত! প্রকৃতপক্ষে, আমি একক ডায়ালগ এপিএল অন্তর্নির্মিত: কোয়াডআর এবং কোয়াডএস ভিত্তিতে আরও দুটি গল্ফ ভাষা তৈরি করেছি ।
— অ্যাডম
10

জাভা 8, 271 269 247 210 202 198 193 বাইট

a->{for(int n=0,i,j,t,I,J;++n<4;)for(i=a.length;i-->0;)for(j=a[0].length;j-->0;)for(t=4;a[i][j]==n&t-->0;)try{a[I=t>2?i-1:t>1?i+1:i][J=t<1?j-1:t<2?j+1:j]+=a[I][J]<1?n+1:0;}catch(Exception e){}}

জাভা এবং সূচক-নির্ভর ম্যাট্রিকেস .. ইতিমধ্যে ভার্বোজ ভাষার সাথে শুরু করার জন্য একটি ভাল সংমিশ্রণ নয় ..

একটি নতুন ফিরিয়ে দেওয়ার পরিবর্তে ইনপুট-ম্যাট্রিক্স পরিবর্তন করে।

ব্যাখ্যা:

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

a->{                            // Method with integer-matrix parameter and no return-type
  for(int n=0,i,j,t,I,J;++n<4;) //  Loop `n` in range [1, 4)
    for(i=a.length;i-->0;)      //   Inner loop over the rows
      for(j=a[0].length;j-->0;) //    Inner loop over the columns
        for(t=4;a[i][j]==n&     //     If the current cell contains the current `n`:
                t-->0;)         //      Loop `t` downwards in the range (4, 0]
          try{a[                //       Get the cell at a location relative to the current
                I=t>2?          //        If `t` is 3:
                 i-1            //         Take the cell above
                :t>1?           //        Else if `t` is 2:
                 i+1            //         Take the cell below
                :i][J=t<1?      //        Else if `t` is 0:
                 j-1            //         Take the cell left
                :t<2?           //        Else if `t` is 1:
                 j+1:j]         //         Take the cell right
              +=a[I][J]<1?      //       And if this cell contains a 0:
                 n+1:0;         //        Fill it with `n+1`
          }catch(Exception e){} //       catch and ignore ArrayIndexOutOfBoundsExceptions
                                //       (try-catch saves bytes in comparison to if-checks)
— কেভিন ক্রুইজসেন
সূত্র
8

স্টেনসিল + সিএলএ:,3 11 বাইট

s:S⋄+∘×⍨⌈/N

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

-1 আদমকে ধন্যবাদ ।
-2 দ্বারা অন্য উত্তর এর উপরে একটি প্রস্তাবনার ধন্যবাদ ngn , যা আমার কাছ থেকে রূপান্তর করার জন্য নেতৃত্বে স্টেনসিল থেকে স্টেনসিল + + CLA: 3।

— এরিক দ্য আউটগল্ফার
সূত্র
3

জাভাস্ক্রিপ্ট (ES6), 107 105 বাইট

f=(m,k=1)=>k<4?f(m.map((r,y)=>r.map((v,x)=>v|[-1,0,1,2].every(d=>(m[y+d%2]||0)[x+~-d%2]^k)?v:k+1)),k+1):m

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

কোড স্নিপেট দেখান

মন্তব্য

f = (m, k = 1) =>                  // given the input matrix m[] and starting with k = 1
  k < 4 ?                          // if this is not the 4th iteration:
    f(                             //   do a recursive call:
      m.map((r, y) =>              //     for each row r[] at position y in m[]:
        r.map((v, x) =>            //       for each cell v at position x in r[]:
          v |                      //         if v is non-zero
          [-1, 0, 1, 2].every(d => //         or each neighbor cell at (x+dx, y+dy), with:
            (m[y + d % 2] || 0)    //           dy = d % 2 --> [-1, 0, 1, 0]
            [x + ~-d % 2]          //           dx = (d - 1) % 2 --> [0, -1, 0, 1]
            ^ k                    //           is different from k  
          ) ?                      //         then:
            v                      //           let the cell unchanged
          :                        //         else:
            k + 1                  //           set the cell to k + 1
        )                          //       end of inner map()
      ),                           //     end of outer map()
      k + 1                        //     increment k for the next iteration
    )                              //   end of recursive call
  :                                // else:
    m                              //   stop recursion and return m[]
— Arnauld
সূত্র
3

পাইথন 3 , 176 বাইট

f=lambda a,i=-2,e=enumerate:a*i or f([[E or int((6*max(len(a)>i>-1<j<len(a[i])and a[i][j]for i,j in((r+1,c),(r-1,c),(r,c+1),(r,c-1))))**.5)for c,E in e(R)]for r,R in e(a)],i+1)

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

-১৮ বাইটস মিঃ এক্সকোডারকে
ধন্যবাদ -২০ বাইট ওভসকে ধন্যবাদ

— HyperNeutrino
সূত্র
9
" আমি যখন কাল সকালে ঘুম থেকে উঠি এবং এই কোডটি আবার দেখি তখন সম্ভবত আমি খুব বোবা অনুভব করতে যাচ্ছি। " আপনি জাভাতে যেহেতু আপনাকে ছাড়িয়ে গেছেন ততই আপনি ভাল হবেন। ; পি
— কেভিন ক্রুইজসেন
1
@ কেভিন ক্রুইজসেন কী ডি: গ্রহণযোগ্য নয়। জাভা দ্বারা পিটানো উচিত নয়: পি
— হাইপারনিউটারিনো
1
আসুন জাভা: সি - 196 বাইট বীট করি ।
— মিঃ এক্সকোডার
@ মিঃ এক্সকোডার ইয়ে ধন্যবাদ: সি: ডি
— হাইপার নিউট্রিনো
@ ওহ ওহ সুন্দর, টাই!
— হাইপারনিউট্রিনো
3

ফরট্রান 95, 309 299 294 287 269 ​​বাইট

subroutine f(a)
integer::a(:,:),s(2)
integer,allocatable::b(:,:)
s=shape(a)
allocate(b(0:s(1)+1,0:s(2)+1))
do1 k=0,3
do1 i=1,s(1)
do1 j=1,s(2)
b(i,j)=a(i,j)
if(any((/b(i+1,j)==k,b(i-1,j)==k,b(i,j+1)==k,b(i,j-1)==k/)).and.b(i,j)<1.and.k>0)b(i,j)=k+1
1 a(i,j)=b(i,j)
end

ফোর্টরান কোনও গল্ফ করার ভাষা নয়।

  • সম্পাদনা করুন: অদ্ভুত পুরানো ফ্যাশনযুক্ত ডু লুপগুলি ব্যবহার করে 10 বাইট সংরক্ষণ করা হয়েছে।
  • সম্পাদনা 2: এর সাথে 5 বাইট সংরক্ষণ করা হয়েছেany()
  • সম্পাদনা 3: একটি অপ্রয়োজনীয় অপসারণ করে 7 বাইট সংরক্ষণ করা হয়েছেif
  • সম্পাদনা 4: ঘোষিত ঘোষণার মাধ্যমে 18 বাইট সংরক্ষিতs
— georgewatson
সূত্র
1

পার্ল, 63 বাইট

জন্য +3 অন্তর্ভুক্ত 0ap

perl -0ape 's/0(?=$a|.{@{-}}$a)/$a+1/seg,$_=reverse while($a+=$|-=/
/)<4'

চূড়ান্ত নিউলাইন ছাড়াই ডিজিটের ব্লক হিসাবে ইনপুট ম্যাট্রিক্স দিন

001
000
010

3x3 উদাহরণের জন্য। আউটপুট ফর্ম্যাটটি একই, চূড়ান্ত নিউলাইন ছাড়া অঙ্কের একটি ব্লক।

আপনি একটি ছোট স্ক্রিপ্ট ব্যবহার করতে পারেন 

perl -i -0pe 's/\n*$//' <file>

আপনার পছন্দসই সম্পাদকটিতে এটি করা যদি শক্ত হয় তবে সহজেই কোনও ফাইল থেকে চূড়ান্ত নিউলাইনগুলি সরিয়ে ফেলতে

— টন হসপেল
সূত্র
1

এপিএল (ডায়ালগ ইউনিকোড) , 34 30 23 বাইট ( আব্রুডজ / এসবিসিএস )

5|{5⊃,⍵+×⌊.⌊⍨⍵}⌺3 3⍣3∘-

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

-4 এনএনজি ধন্যবাদ ।

— এরিক দ্য আউটগল্ফার
সূত্র
আসুন আমরা এই আলোচনাটি আড্ডায় চলতে থাকি ।
— এরিক দি আউটগল্ফার
1

রেটিনা , 93 87 84 বাইট

1
4
3{m`(?<=^(.)*)0(?=4|.*¶(?>(?<-1>.)*)4|(?<=40|^(?(1)_)(?<-1>.)*4.*¶.*))
5
T`1-5`d

এটি অনলাইন চেষ্টা করুন! আমার উত্তরের ভিত্তিতে এটি কিল দিয়ে ফায়ার করুন । সম্পাদনা করুন: @ মার্টিনইেন্ডারে ধন্যবাদ 6 9 বাইট সংরক্ষিত ব্যাখ্যা:

1
4

সমস্ত 1 গুলি 4s তে পরিণত করুন।

3{

প্রোগ্রামটির বাকি অংশটি (সর্বাধিক) 3 বার পুনরাবৃত্তি করুন।

m`(?<=^(.)*)0(?=4|.*¶(?>(?<-1>.)*)4|(?<=40|^(?(1)_)(?<-1>.)*4.*¶.*))
5

4 এস সংলগ্ন সমস্ত 0 টি 5 এস তে পরিবর্তন করুন।

T`1-5`d

সমস্ত সংখ্যা হ্রাস।

রেটিনা 0.8.2 , 100 94 বাইট

1
3
{m`(?<=^(.)*)0(?=3|.*¶(?>(?<-1>.)*)3|(?<=30|^(?(1)_)(?<-1>.)*3.*¶.*))
4
T`1-4`d`^[^1]+$

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

1
3

সমস্ত 1 গুলি 3s তে পরিণত করুন।

{

আউটপুট পরিবর্তন না হওয়া পর্যন্ত পুনরাবৃত্তি করুন।

m`(?<=^(.)*)0(?=3|.*¶(?>(?<-1>.)*)3|(?<=30|^(?(1)_)(?<-1>.)*3.*¶.*))
4

3 এস সংলগ্ন সমস্ত 0 গুলি 4s তে পরিবর্তন করুন।

T`1-4`d`^[^1]+$

যদি কোনও 1s না থাকে, সমস্ত সংখ্যা হ্রাস করুন।

— নিল
সূত্র
আপনি এর !পরিবর্তে (যা ইনপুটটিতে প্রদর্শিত হতে পারে না) এমন অক্ষর ব্যবহার করে কিছু বাইট সংরক্ষণ করতে পারেন (?!)।
— মার্টিন এন্ডার
@ মার্টিন ইন্ডার ধন্যবাদ, এটি আগুন দিয়েও হত্যা করার পক্ষে কাজ করে (এবং আমি সেখানে থাকাকালীন আমি একটি পৃথক 2 বাইট গল্ফ পেয়েছি!)
— নীল
1

রুবি , 183 158 146 বাইট

->a{3.times{|n|a.size.times{|i|r=a[i];r.size.times{|j|(r[j]<1&&[i>0?a[i-1][j]:0,a[i+1]&.at(j),j>0?r[j-1]:0,r[j+1]].include?(n+1))?r[j]=n+2:0}}};a}

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

সুস্পষ্ট থ্রি-লুপ অ্যালগরিদম ব্যবহার করে। রুবি অ্যারেতে নেগেটিভ ইনডেক্সিংয়ের অনুমতি দেয় তার অর্থ সীমানা চেক করার আশেপাশে কোনও উপায় নেই (যা আমি দেখতে পাচ্ছি)। একটি অ্যারের রিটার্নের সীমা ছাড়িয়ে পৌঁছানো nil, কেবলমাত্র নেতিবাচক বাউন্ড চেকগুলিই প্রয়োজনীয়। a[i+1][j]কেবলমাত্র চেকের জন্য নিরাপদ অ্যাক্সেস অপারেটর ব্যবহার করা দরকার।

আমি এর জন্য একটি ভেরিয়েবল ব্যবহার করে কয়েকটি বাইটও শেভ করেছিলাম a[0]।

-12 আরও বাইট: .timesপরিবর্তে (0...x).map(তিন জায়গায়) ব্যবহার করুন।

->a{
  3.times{|n|                    # For n from 0 to 2
    a.size.times{|i|             # For each row
      r=a[i];
      r.size.times{|j|           # For each column
        (r[j]<1 && [             # If the current cell is 0, and any of
            i>0 ? a[i-1][j] : 0, #     the cell to the north,
            a[i+1]&.at(j),       #     the cell to the south,
            j>0 ? r[j-1] : 0,    #     the cell to the west,
            r[j+1]               #     or the cell to the east
          ].include?(n+1)        #   are set to the previous value,
        ) ? r[j]=n+2 : 0         # Set this cell to the next value (or 0)
      }
    }
  };
  a                              # Return the modified array
}
— benj2240
সূত্র
আমাদের সাইট ব্যবহার করে, আপনি স্বীকার করেছেন যে আপনি আমাদের কুকি নীতি এবং গোপনীয়তা নীতিটি পড়েছেন এবং বুঝতে পেরেছেন ।
Licensed under cc by-sa 3.0 with attribution required.