28

ধরুন আমাদের কাছে এই জাতীয় একটি ম্যাট্রিক্স রয়েছে:

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

11111        11111        11111        11011        10001        00000
12221  3 m.  12221  2 m.  12021  1 m.  11011  1 m.  00000  1 m.  00000
12321 -----> 12021 -----> 10001 -----> 00000 -----> 00000 -----> 00000
12221        12221        12021        11011        00000        00000
11111        11111        11111        11011        10001        00000

ব্যাখ্যা:

আগুনের সূচনা [2,2] (0 ভিত্তিক) থেকে শুরু হয়, যার বার্ন টাইম 3 থাকে।
3 মিনিটের পরে, [1,2], [2,1], [2,3], [3,2] জ্বলতে শুরু করে।
2 মিনিটের পরে, সেই কোষগুলি জ্বলন শেষ করে এবং আগুনটি সমস্ত সংলগ্ন কোষগুলিতে প্রচার করে তবে [0,2], [2,0], [2,4], [0,4] পোড়াতে আরও 1 মিনিটের প্রয়োজন, তাই
1 মিনিটের পরে, সেই ঘরগুলি পোড়া হয় এবং কোষটি তাদের সংলগ্ন কোষগুলিতে প্রচার করে।
আরও 1 মিনিটের পরে, ধাপ 3 শেষ থেকে জ্বলন্ত এবং আগুনের বাকি কোষগুলি তাদের সংলগ্ন কোষগুলিতে প্রচার করে (যা ইতিমধ্যে পুড়ে গেছে, তাই কিছুই ঘটে না)।
শেষ মুহুর্তের 1 পরে, পুরো অঞ্চলটি আগুন জ্বলে ওঠে।

সুতরাং এই ক্ষেত্রে সমাধানটি 8 মিনিট। আগুনটি যদি শীর্ষের বামতম কোষে শুরু হয় [0,0]:

11111     01111     00111     00011     00001     00000
12221  1  12221  1  02221  1  01221  1  00121  1  00011   1
12321 --> 12321 --> 12321 --> 02321 --> 01321 --> 00321  -->
12221     12221     12221     12221     02221     01221
11111     11111     11111     11111     11111     01111

00000     00000     00000     00000     00000
00000  1  00000  1  00000  1  00000  1  00000
00221 --> 00110 --> 00000 --> 00000 --> 00000
00221     00121     00020     00010     00000
00111     00011     00001     00000     00000

সুতরাং এখন মোট সময় 10 মিনিট।

চ্যালেঞ্জ

একটি এনএক্সএম ম্যাট্রিক্স (এন> 0, এম> 0) দেওয়া হয়েছে যা প্রতিটি কক্ষের পুরোপুরি গ্রাস করার প্রয়োজনের প্রতিনিধিত্ব করে, সেই সংক্ষিপ্ততম প্রোগ্রাম / ফাংশন লিখুন যা সেই ম্যাট্রিক্স এবং আগুনের যে অবস্থানের সাথে সংখ্যার পূর্ণসংখ্যার সংযোজন নেয় write , এবং পুরো অঞ্চলটিকে পুরোপুরি গ্রাস করতে আগুনের জন্য প্রয়োজনীয় সময়টি ফেরত / মুদ্রণ করে।

প্রতিটি ঘরে একটি ধনাত্মক (শূন্য নয়) বার্ন সময় থাকবে। আপনি সেলগুলির সর্বাধিক মান ধরে নিতে পারবেন না।
ম্যাট্রিক্সটি বর্গক্ষেত্র বা প্রতিসাম্যযুক্ত হওয়ার দরকার নেই।
আপনার পছন্দ অনুসারে ম্যাট্রিক্স 0-সূচকযুক্ত বা 1-সূচকযুক্ত হতে পারে।
অবস্থানটি পূর্ণসংখ্যার একটি টিপল সহ একক প্যারামিটার হিসাবে দেওয়া যেতে পারে, অন্য যুক্তিসঙ্গত বিন্যাসের যাই হোক না কেন তার দুটি পৃথক পরামিতি।
ম্যাট্রিক্সের মাত্রাগুলি ইনপুট পরামিতি হিসাবে নির্দিষ্ট করা যায় না।
প্রতিটি মধ্যবর্তী পদক্ষেপে আপনাকে আউটপুট দেওয়ার দরকার হবে না, যতটা সময় চেয়েছে। পদক্ষেপগুলি কোনওভাবে দৃশ্যমান হলে আমি অভিযোগ করব না।

আরেকটি উদাহরণ:

Fire starts at [1,1] (a '>' represents a minute):

4253   4253   4253   4153   4043   3033   2023    0001   0000
2213 > 2113 > 2013 > 1003 > 0002 > 0001 > 0000 >> 0000 > 0000 
1211   1211   1211   1111   1001   0000   0000    0000   0000

Output: 9

এটি কোড-গল্ফ , তাই প্রতিটি ভাষার জন্য সংক্ষিপ্ততম প্রোগ্রামটি জয় পেতে পারে!

code-golf matrix simulation

— রাতের পাহারাদার
সূত্র

1

@ লিন্ডারমোনসিংগার এটি যে কোনও ম্যাট্রিক্সের সাথে কাজ করতে পারে। আমার অর্থ হ'ল আপনার প্রোগ্রাম বা ফাংশন ম্যাট্রিক্সের মাত্রাগুলিকে ইনপুট পরামিতি হিসাবে গ্রহণ করতে পারে না তবে অবশ্যই আপনি আপনার কোডের অভ্যন্তরে এই মাত্রাগুলি গণনা করতে পারেন।

— চার্লি

ইনপুটটি কি কলাম-প্রধান ক্রমে একক সংখ্যা হিসাবে নেওয়া যেতে পারে ? যে, ম্যাট্রিক্স এন্ট্রি নিচে নাম্বার করা হয়, তারপরে জুড়ে

— লুইস মেন্ডো

1

@ লুইস মেন্ডো অবশ্যই হ্যাঁ তবে মনে রাখবেন যে প্রতিটি কক্ষের জ্বলন্ত সময় 9 টিরও বেশি হতে পারে, যদি এটি "একক সংখ্যা" অংশের জন্য গুরুত্বপূর্ণ।

— চার্লি

ধন্যবাদ। না, কিছু যায় আসে না। আমি একটি একক সংখ্যা বোঝায় তবে সম্ভবত বেশ কয়েকটি অঙ্ক সহ। নম্বর থেকে পরিসীমা হবে 1থেকেM*N

— লুইস Mendo

12

মতলব, 235 257 190 182 178 বাইট

ইনপুট: ম্যাট্রিক্স A, pপ্রারম্ভিক স্থানাঙ্কগুলি সহ 1x2 ভেক্টর ।

function t=F(A,p)
[n,m]=size(A);x=2:n*m;x(mod(x,n)==1)=0;B=diag(x,1)+diag(n+1:n*m,n);k=sub2ind([n m],p(1),p(2));t=max(distances(digraph(bsxfun(@times,((B+B')~=0),A(:))'),k))+A(k)

ব্যাখ্যা:

আগুনের প্রচারের অনুকরণের পরিবর্তে, আমরা এটিকে "দীর্ঘতমতমতম পথের সন্ধান করুন" সমস্যা হিসাবেও বুঝতে পারি। ম্যাট্রিক্স একটি ভারী নির্দেশিত গ্রাফে রূপান্তরিত হয়। একটি একক নোডের পাথের ওজন হ'ল নোড বার্ন করার সময়ের সাথে সঙ্গতিপূর্ণ। যেমন একটি ম্যাট্রিক্সের জন্য

5   7   7   10
5   2   2   10
4   5   2   6

আমরা সংযুক্ত গ্রাফটি পাই:

যেখানে নোড 1 হ'ল উপরের বাম ম্যাট্রিক্স উপাদান এবং নোড 12 নীচের ডান উপাদান। সূচনা স্থানাঙ্ক দেওয়া p, অন্যান্য সমস্ত নোডের সংক্ষিপ্ততম পথ গণনা করা হয়। তারপরে সেই সংক্ষিপ্ততম পথগুলির দীর্ঘতম পথের দৈর্ঘ্য + প্রাথমিক নোড জ্বালানোর সময় পুরো ম্যাট্রিক্স বার্ন করার সময়ের সমান।

নমুনা শুরুর মানগুলির সাথে বর্ণহীন এবং মন্তব্য করা সংস্করণ:

% some starting point
p = [3 2];
% some random 5x6 starting map, integers between 1:10
A = randi(10,5,6); 

function t=F(A,p)
% dimensions of A
[n,m] = size(A);
% create adjacency matrix
x=2:n*m;
x(mod(x,n)==1)=0;
B = diag(x,1)+diag(n+1:n*m,n);
B = B+B';
B = bsxfun(@times,(B~=0),A(:))';
% make graph object with it
G = digraph(B);
% starting node
k = sub2ind([n m], p(1), p(2));
% calculate the shortest distance to all nodes from starting point
d = distances(G,k);
% the largest smallest distance will burn down last. Add burntime of initial point
t = max(d)+A(k);

— লিয়েন্ডার মোসিংগার
সূত্র

1

পিপিসিজিতে আপনাকে স্বাগতম!

— স্টিফেন

খুব সুন্দর পদ্ধতির এবং খুব ভাল ব্যাখ্যা!

— চার্লি

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

— গুরুত্ব

1

@ লিন্ডারমোসিংগার কি স্প্যাম আপনার প্রোগ্রাম আউটপুট হিসাবে একই আউটপুট অঞ্চলে যায়? উদাহরণস্বরূপ, স্প্যামটি যদি STDERR বা সমতুল্য হয়ে যায় এবং আউটপুট STDOUT বা সমতুল্য হয়ে যায়, তবে আপনার সেগুলি অপসারণ করা উচিত। যদি তারা উভয়ই একই জায়গায় আউটপুট দেয় তবে আমি জানতাম না।

— স্টিফেন

@ এটি একটি ভিন্ন আউটপুট অঞ্চল, তবে আমি সবকিছুকে একটি লাইন রেখে একে একে একে এড়াতে পারি। স্পষ্টতার জন্য থেক্স!

— লিয়েন্ডার মোসিংগার

9

জাভাস্ক্রিপ্ট (ES6), 156 152 146 144 143 বাইট

কেভিন ক্রুইজসেনকে ধন্যবাদ 1 বাইট সংরক্ষিত

একটি বরং নিষ্পাপ বাস্তবায়ন। বাক্য গঠন বাক্য গঠনে ইনপুট নেয় (a)(s), যেখানে a 2D-অ্যারে এবং গুলি দুটি সূচকের অ্যারে হয় [ x, y ] শুরুর অবস্থানের 0-ভিত্তিক স্থানাঙ্ককে উপস্থাপন করে।

a=>s=>(g=t=>(a=a.map((r,y)=>r.map((c,x)=>(z=(h,v)=>(a[y+~~v]||[])[x+h]<1)(-1)|z(1)|z(0,-1)|z(0,1)|x+','+y==s&&c?u=c-1:c),u=-1),~u?g(t+1):t))(0)

ফর্ম্যাট এবং মন্তব্য

a => s => (                                // given a and s
  g = t => (                               // g = recursive function with t = time counter
    a = a.map((r, y) =>                    // for each row r of the input array:
      r.map((c, x) =>                      //   for each cell c in this row:
        (                                  //     z = function that takes
          z = (h, v) =>                    //         2 signed offsets h and v and checks
            (a[y + ~~v] || [])[x + h] < 1  //         whether the corresponding cell is 0
        )(-1) | z(1) |                     //     test left/right neighbors
        z(0, -1) | z(0, 1) |               //     test top/bottom neighbors
        x + ',' + y == s                   //     test whether c is the starting cell
        && c ?                             //     if at least one test passes and c != 0:
          u = c - 1                        //       decrement the current cell / update u
        :                                  //     else:
          c                                //       let the current cell unchanged
      ),                                   //   end of r.map()
      u = -1                               //   start with u = -1
    ),                                     // end of a.map() --> assign result to a
    ~u ?                                   // if at least one cell was updated:
      g(t + 1)                             //   increment t and do a recursive call
    :                                      // else:
      t                                    //   stop recursion and return t
  )                                        // end of g() definition
)(0)                                       // initial call to g() with t = 0

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

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

let f =

a=>s=>(g=t=>(a=a.map((r,y)=>r.map((c,x)=>(z=(h,v)=>(a[y+~~v]||[])[x+h]<1)(-1)|z(1)|z(0,-1)|z(0,1)|x+','+y==s&&c?u=c-1:c),u=-1),~u?g(t+1):t))(0)

console.log(f([
  [1,1,1,1,1],
  [1,2,2,2,1],
  [1,2,3,2,1],
  [1,2,2,2,1],
  [1,1,1,1,1]
])([2, 2]))

console.log(f([
  [1,1,1,1,1],
  [1,2,2,2,1],
  [1,2,3,2,1],
  [1,2,2,2,1],
  [1,1,1,1,1]
])([0, 0]))

console.log(f([
  [4,2,5,3],
  [2,2,1,3],
  [1,2,1,1]
])([1, 1]))

স্নিপেট প্রসারিত করুন

— Arnauld
সূত্র

==0<1আমি ভুল না হলে গল্ফ করা যেতে পারে

— কেভিন ক্রুইজসেন

1

@ কেভিন ক্রুইজসেন এইটি মিথ্যাচার মতোই নিরাপদ undefined<1। ধন্যবাদ!

— আর্নৌল্ড

8

অক্টাভা, 67 বাইট

function n=F(s,a)n=0;do++n;until~(s-=a|=imdilate(~s,~(z=-1:1)|~z')

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

মধ্যবর্তী ফলাফলগুলি ভিজ্যুয়ালাইজ করতে আপনি এটি ব্যবহার করে দেখতে পারেন !

ভূখণ্ডের ইনপুট ম্যাট্রিক্স হিসাবে গৃহীত এমন একটি ফাংশন এবং ভূখণ্ডের aসমান আকারের সাথে 0 এবং 1 এর ম্যাট্রিক্স হিসাবে প্রাথমিক স্থানাঙ্ক।

আসলে endfunctionটিওতে উদাহরণটি চালানোর দরকার নেই তবে এটি যুক্ত করা উচিত।

ব্যাখ্যা:

বারবার ভূখণ্ডে রূপচর্চা চিত্রের প্রসারণ প্রয়োগ করুন এবং এটি থেকে পোড়া অংশগুলি বিয়োগ করুন।

অবারিত উত্তর:

function n = Fire(terrain,burned)
    n = 0;
    mask = [...
            0  1  0
            1  1  1
            0  1  0];
    while true
        n = n + 1;
        propagation = imdilate(~terrain, mask);
        burned = burned | propagation;
        terrain = terrain - burned;
        if all(terrain(:) == 0)
            break;
        end
    end
end

— rahnema1
সূত্র

এটি একটি দুর্দান্ত উত্তর, তবে হতে পারে অ্যালগরিদম প্রাথমিক পদক্ষেপ হিসাবে একটি পদক্ষেপ হিসাবে গণনা করছে এবং আপনার উদাহরণে 10 এর পরিবর্তে 11 ফিরিয়েছে। আমি যদি প্রাথমিক কক্ষটি পরিবর্তিত করে [3 3] ফলাফলটি 8 এর পরিবর্তে 9 হয়

— চার্লি

@ কার্লোস আলেজো ওহ, আমার খারাপ। উত্তর পরিবর্তন করা আপডেট n=1করার n=0।

— rahnema1

7

এমএটিএল , 26 25 বাইট

আমি এখানে প্রায় গল্ফিয়াস্ট ভাষা ব্যবহার করে আরও কিছু উত্তর দেখতে চেয়েছিলাম

`yy)qw(8My~1Y6Z+fhy0>z}@&

ইনপুট ফর্ম্যাটটি হ'ল:

প্রথম ইনপুটটি ;সারির বিভাজক হিসাবে ব্যবহার করে একটি ম্যাট্রিক্স ।
দ্বিতীয় ইনপুট হ'ল একক সংখ্যা যা 1-ভিত্তিক কলাম-প্রধান ক্রমে ম্যাট্রিক্সের প্রবেশকে সম্বোধন করে (চ্যালেঞ্জের দ্বারা অনুমোদিত)। উদাহরণস্বরূপ, 3 × 4 ম্যাট্রিক্সে প্রতিটি প্রবেশের কলাম-মেজর স্থানাঙ্ক দ্বারা প্রদত্ত
```
1  4  7 10
2  5  8 11
3  6  9 12
```
সুতরাং উদাহরণস্বরূপ 1-ভিত্তিক স্থানাঙ্ক (2,2) এর সাথে সম্পর্কিত 5।

এটি অনলাইন চেষ্টা করুন! বা সমস্ত পরীক্ষার কেস যাচাই করুন ।

ব্যাখ্যা

কোডটি জ্বলছে এমন এন্ট্রিগুলির একটি তালিকা বজায় রাখে। প্রতিটি পুনরাবৃত্তিতে, তালিকার সমস্ত প্রবেশকেন্দ্র হ্রাস করা হয়। যখন কোনও এন্ট্রি শূন্যে পৌঁছে যায় তখন তার প্রতিবেশী এন্ট্রিগুলি তালিকায় যুক্ত হয়। বাইট সংরক্ষণ করতে, শূন্যে পৌঁছেছে এমন এন্ট্রি তালিকা থেকে সরানো হবে না; পরিবর্তে, তারা নেতিবাচক মান সহ "জ্বলন্ত" রাখে। লুপটি বের হয় যখন কোনও এন্ট্রিতে ইতিবাচক মান থাকে না।

প্রোগ্রামটি সামান্য সংশোধিত কোড সহ ধাপে ধাপে দেখুন ।

মন্তব্য করা কোড:

`      % Do...while
  yy   %   Duplicate top two arrays (matrix and array of positions to be decremented)
       %   In the first iteration this implicitly takes the two inputs
  )    %   Reference indexing. This gives the values that need to be decremented
  q    %   Decrement
  w    %   Swap. This brings the array of positions that have been decremented to top
  (    %   Assignment indexing. This writes the decremented values back into their
       %   positions
  8M   %   Push array of positions again
  y    %   Duplicate decremented matrix
  ~    %   Negate. This replaces zeros by 1, and nonzeros by 0
  1Y6  %   Push predefined literal [0 1 0; 1 0 1; 0 1 0] (4-neighbourhood)
  Z+   %   2D convolution, maintaining size
  f    %   Find: gives column-major indices of neighbours of totally burnt entries
  h    %   Concatenate. This updates the array of positions to be decremented
  y    %   Duplicate decremented matrix
  0>   %   This gives 1 for positive entries, and 0 for the rest
  z    %   Number of nonzeros. This is the loop condition (*)
}      % Finally (execute before exiting loop)
  @    %   Push iteration number. This is the output
  &    %   Specify that the final implicit display function will display only the top
       %   of the stack
       % Implicit end. If the top of the stack (*) is not 0 (i.e. there are entries
       % that have not been totally burnt) the loop proceeds with the next iteration.
       % Else the "finally" branch is executed and the loop is exited
       % Implicit display (only top of the stack)

— লুইস মেন্ডো
সূত্র

2

এখন এটাই আমি শর্ট কোড বলি! :-)

— চার্লি

4

পাইথন 2 , 170 বাইট

s,m=input()
t={s}
r=0
while max(sum(m,[]))>0:
 r+=1
 for a,b in t|t:
	try:a<0<x;b<0<x;m[a][b]-=1;t|=m[a][b]==0and{(a+1,b),(a-1,b),(a,b+1),(a,b-1)}or t^t
	except:0
print r

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

— ovs
সূত্র

4

পাইথন 3 , 277 266 বাইট

def f(m,s):
 p={s};w=len(m);t=0
 while sum(sum(m,[])):
  t+=1;i=0
  for x,y in p:
   try:m[x][y]=max(0,m[x][y]-1)
   except:0
  for v in sum(m,[]):
   if v<1:
    for l in[(1,0),(-1,0),(0,1),(0,-1)]:a,b=max(0,i%w+l[0]),max(0,i//w+l[1]);p.add((a,b))
   i+=1
 print(t)

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

এমন একটি ফাংশন সংজ্ঞায়িত করে fযা 2D ম্যাট্রিক্স এবং পয়েন্টগুলির একটি দ্বিগুণ অংশ নেয়। প্রথম জিনিস ফাংশন আছে পাস প্রাথমিক tuple মান ধারণকারী tuples একটি সেট সংজ্ঞায়িত হয়: p={s}। ফাংশনটি তখন প্রতিটি বিন্দুতে টুপলের মধ্য দিয়ে যায় pএবং ম্যাট্রিক্স থেকে একটিটিকে mসেই বিন্দুতে বিয়োগ করে , যদি না মান ইতিমধ্যে শূন্য হয়। এরপরে এটি mআবার শূন্যের মান সহ সমস্ত পয়েন্ট সন্ধান করে এবং সেই বিন্দুটির চারটি প্রতিবেশীকে সেটে যুক্ত করে p। এ কারণেই আমি একটি সেট ব্যবহার করা বেছে নিলাম, কারণ পাইথনের সেটগুলি সদৃশ মানগুলিকে অনুমোদন দেয় না (যা বিয়োগকে অনেকাংশে স্ক্রু করবে)। দুর্ভাগ্যক্রমে, তালিকা সূচক মোড়কের কারণে (যেমন list[-1] == list[len(list)-1]:) সূচকগুলিকে সীমাবদ্ধ করা দরকার যাতে তারা নেতিবাচক না যায় এবং ভুল স্থানাঙ্কগুলিতে যুক্ত না করে p।

বিশেষ কিছু নয়, এখনও গল্ফ করতে অভ্যস্ত। অবশ্যই উন্নতির জন্য এখানে জায়গা, আমি এটি ক্র্যাকিং রাখা যাচ্ছি।

— MooseOnTheRocks
সূত্র

আপনি কি অনলাইনে চেষ্টা করে এটি প্রয়োগের উদাহরণ লিখতে পারেন যাতে আমরা সকলেই আপনার কোডটি পরীক্ষা করতে পারি?

— চার্লি

@ কার্লোস আলেজো অবশ্যই পোস্টে যুক্ত করেছেন।

— মুজঅন দ্য রকস

4

এপিএল (ডায়ালগ) , 93 66 57 বাইট

{⍵{^/,0≥⍺:0⋄1+x∇⍵∨{∨/,⍵∧⍲/¨2|⍳3 3}⌺3 3⊢0=x←⍺-⍵}(⊂⍺)≡¨⍳⍴⍵}

এটি অনলাইন চেষ্টা করুন! অথবা এটি অনলাইনে ভিজ্যুয়ালাইজ করুন!

এই ফাংশনটি টেরিটেনের ম্যাট্রিক্সকে ডান আর্গুমেন্ট হিসাবে এবং প্রথম আগুনের স্থানাঙ্ক (1-ভিত্তিক) বাম আর্গুমেন্ট হিসাবে গ্রহণ করে। সমস্ত কিছু জ্বালানোর জন্য প্রয়োজনীয় মিনিটের সংখ্যাটি দেয়।

আপডেট

অবশেষে স্প্রেড ফাংশনটি গল্ফ করার একটি উপায় খুঁজে পেয়েছে।
* দীর্ঘশ্বাস * এটি এত সহজ হবে যদি বিশ্বটি টরওয়েডাল হয় ।

টিআইও সবেমাত্র ডায়ালগ ১.0.০ এ আপগ্রেড হয়েছে , যার অর্থ এখন আমাদের কাছে চকচকে নতুন স্টেনসিল অপারেটর রয়েছে

— TwiNight
সূত্র

খুব সুন্দর উত্তর! মধ্যবর্তী আউটপুট অগ্রগতি কল্পনা সাহায্য করে!

— চার্লি

2

পাইথন 2 , 268 বাইট

def f(m,y,x):t,m[y][x]=m[y][x],0;g(m,t)
def g(m,t):
	n,h,w=map(lambda r:r[:],m),len(m),len(m[0])
	for l in range(h*w):r,c=l/h,l%h;n[r][c]-=m[r][c]and not all(m[r][max(c-1,0):min(c+2,w+1)]+[m[max(r-1,0)][c],m[min(r+1,h-1)][c]])
	if sum(sum(m,[])):g(n,t+1)
	else:print t

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

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

* দ্রষ্টব্য: আমার 'এটি অনলাইনে চেষ্টা করুন!' কোডে ফুটারে বোনাস ডিবাগ লগিং অন্তর্ভুক্ত। আমি অ্যালগরিদম অগ্রগতি দেখতে পছন্দ করি।

— কোটি জননাথন স্যাক্সমান
সূত্র

2

হাস্কেল , 138 133 বাইট

u#g|all((<=0).snd)g=0|2>1=1+(u:[[(x+1,y),(x-1,y),(x,y-1),(x,y+1)]|((x,y),0)<-n]>>=id)#n where n=d<$>g;d p|elem(fst p)u=pred<$>p|2>1=p

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

ধরে নিই ইনপুটটি ((x, y), ঘর) এর একটি তালিকা। Ungolfed:

type Pos = (Int, Int)

ungolfed :: [Pos] -> [(Pos, Int)] -> Int
ungolfed burning grid
  | all ((<=0).snd) grid = 0 
  | otherwise = 1 + ungolfed (burning ++ newburning) newgrid
 where
  newgrid = map burn grid
  burn (pos,cell) | pos `elem` burning = (pos, cell - 1)
                  | otherwise = (pos, cell)
  newburning = do
    ((x,y),cell) <- newgrid
    guard (cell <= 0)
    [(x+1,y),(x-1,y),(x,y-1),(x,y+1)]

— bartavelle
সূত্র

আগুন প্রচারের সিমুলেটর

চ্যালেঞ্জ

আরেকটি উদাহরণ:

মতলব, 235 257 190 182 178 বাইট

ব্যাখ্যা:

জাভাস্ক্রিপ্ট (ES6), 156 152 146 144 143 বাইট

ফর্ম্যাট এবং মন্তব্য

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

অক্টাভা, 67 বাইট

এমএটিএল , 26 25 বাইট

ব্যাখ্যা

পাইথন 2 , 170 বাইট

পাইথন 3 , 277 266 বাইট

এপিএল (ডায়ালগ) , 93 66 57 বাইট

আপডেট

পাইথন 2 , 268 বাইট

হাস্কেল , 138 133 বাইট