খেলা এবং ক্লান্তি

10

লাইফ এন্ড ক্লান্তি Stewie এর গেম বেশ আরো বিখ্যাত অনুরূপ লাইফ Conway এর গেম ।

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

  • দু'জনেরও কম জীবন্ত প্রতিবেশী সহ যে কোনও লাইভ সেল মারা যায়, যেন জনসংখ্যার কারণে।
  • দুই বা তিনজন লাইভ প্রতিবেশী সহ যে কোনও লাইভ সেল পরবর্তী প্রজন্মের কাছে থাকে।
  • তিনজনেরও বেশি জীবিত প্রতিবেশী সহ যে কোনও লাইভ সেল মারা যায়, যেন অতিরিক্ত জনসংখ্যার দ্বারা।
  • ঠিক তিনটি জীবিত প্রতিবেশী সহ যে কোনও মৃত কোষ প্রজনন দ্বারা যেন জীবন্ত কোষে পরিণত হয়।
  • টানা দুই প্রজন্ম ধরে বেঁচে থাকা যে কোনও কোষ যেন ক্লান্তিতে মারা যায়। এটি পরবর্তী প্রজন্মের আগ পর্যন্ত আর জীবনে জাগতে পারে না
  • ইনপুট গ্রিডের সীমানার বাইরে থাকা যে কোনও ঘর মারা গেছে, যেন এটি কোনও শৃঙ্খল থেকে পড়েছে।

চ্যালেঞ্জ:

আপনার চ্যালেঞ্জটি হ'ল একটি জিএলএফ এর প্রাথমিক অবস্থার প্রতিনিধিত্ব করে এন-বাই-এম মাত্রার একটি গ্রিড নেওয়া এবং একটি পূর্ণসংখ্যা পি এবং পি প্রজন্মের পরে গেমের অবস্থা আউটপুট করা ।

নিয়মাবলী:

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

পরীক্ষার কেস:

উদাহরণগুলিতে, আমি কেবল ইনপুটটিতে ইনপুট গ্রিড অন্তর্ভুক্ত করেছি, পি নয় । আমি বিভিন্ন পি- মূল্যগুলির আউটপুট সরবরাহ করেছি । আপনি কেবল প্রদত্ত ইনপুট পি সহ গ্রিড আউটপুট করতে পারেন ।

Input:
0   0   0   0   0
0   0   1   0   0
0   0   1   0   0
0   0   1   0   0
0   0   0   0   0

--- Output ---
p = 1
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

p = 2
0   0   0   0   0
0   0   1   0   0
0   0   0   0   0
0   0   1   0   0
0   0   0   0   0

p = 3 -> All dead
---

Input:
0   1   0   0   0   0
0   0   1   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   0
0   0   0   0   0   0

--- Output ---
p = 1
0   0   0   0   0   0
1   0   1   0   0   0
0   1   1   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

p = 2
0   0   0   0   0   0
0   0   0   0   0   0
1   0   0   0   0   0
0   1   1   0   0   0
0   0   0   0   0   0
0   0   0   0   0   0
0   0   0   0   0   0

p = 3
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

p = 4 -> All dead
Input
0   1   1   0   1   1   0
1   1   0   1   1   1   1
0   1   0   0   0   1   0
0   0   0   1   1   0   1
1   0   0   1   0   1   1
0   0   1   1   0   1   1
1   1   0   0   0   0   1

--- Output ---
p = 1
1   1   1   0   0   0   1
1   0   0   1   0   0   1
1   1   0   0   0   0   0
0   0   1   1   0   0   1
0   0   0   0   0   0   0
1   0   1   1   0   0   0
0   1   1   0   0   1   1

p = 2
1   0   0   0   0   0   0
0   0   0   0   0   0   0
1   0   0   1   0   0   0
0   1   1   0   0   0   0
0   1   0   0   0   0   0
0   0   0   0   0   0   0
0   0   1   1   0   0   0   

p = 3
0   0   0   0   0   0   0
0   0   0   0   0   0   0
0   1   1   0   0   0   0
1   1   0   0   0   0   0
0   1   1   0   0   0   0
0   0   1   0   0   0   0
0   0   0   0   0   0   0

p = 4
0   0   0   0   0   0   0
0   0   0   0   0   0   0
1   1   1   0   0   0   0
1   0   0   0   0   0   0
1   0   1   0   0   0   0
0   1   1   0   0   0   0
0   0   0   0   0   0   0

p = 5
0   0   0   0   0   0   0
0   1   0   0   0   0   0
1   0   0   0   0   0   0
0   0   1   0   0   0   0
1   0   0   0   0   0   0
0   1   0   0   0   0   0
0   0   0   0   0   0   0

p = 6
0   0   0   0   0   0   0
0   0   0   0   0   0   0
0   1   0   0   0   0   0
0   1   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

p = 7
0   0   0   0   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   0   0   0   0
0   0   0   0   0   0   0
0   0   0   0   0   0   0

p = 8
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   1   0   0   0   0   0
0   0   0   0   0   0   0
0   0   0   0   0   0   0

p = 9 -> All dead

হ্যাঁ, আমি সচেতন যে সমস্ত প্রাথমিক বীজ সমস্ত কক্ষ মরে যাওয়ার পরে শেষ হবে না।

code-golf  grid  matrix  cellular-automata  game-of-life 
— স্টিও গ্রিফিন
সূত্র
আপনার সম্ভবত স্পষ্ট করা উচিত যে রূপান্তর আইটেম 5 "1 একই সময়ে" আইটেম 1--4 হিসাবে প্রয়োগ করা হয়, এটি 1--4 প্রয়োগ করার আগে এটি রাষ্ট্রের উপর ভিত্তি করে তৈরি হয়
— লুইস মেন্ডো
2
" কোষ, যার প্রতিটি দুটি সম্ভাব্য অবস্থার মধ্যে একটিতে রয়েছে, জীবিত বা মৃত " ইচ্ছাকৃতভাবে বিকৃত সংজ্ঞা বলে মনে হয় যে পরবর্তী ক্লান্তির নিয়ম প্রতিটি কোষের তিনটি রাষ্ট্র (মৃত, সদ্য) তৈরি করে কেবল একটি মান সসীম অটোমেটনে প্রকাশ করা যেতে পারে
— পিটার টেলর
1
আমার কাছে এটির জন্য একটি গলি নিয়ম আছে যদি কেউ এটি চায়।
— ক্যালকুলেটরফলাইন
6
জিওডি খেলছেন, তাই না?
— অ্যাডম

উত্তর:

3

এমএটিএল , 34 30 25 বাইট

@ ক্যালকুলেটরফালাইনের একটি পরামর্শের জন্য 5 বাইট সরানো হয়েছে !

0ii:"wy*~wt3Y6QZ+5:7mb*]&

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

ইনপুটগুলি একটি ম্যাট্রিক্স এবং একটি সংখ্যা। ম্যাট্রিক্স ;সারি বিভাজক হিসাবে ব্যবহার করে । তিনটি পরীক্ষার ক্ষেত্রে ম্যাট্রিক হিসাবে প্রবেশ করা হয়

[0 0 0 0 0; 0 0 1 0 0; 0 0 1 0 0; 0 0 1 0 0;0 0 0 0 0]
[0 1 0 0 0 0; 0 0 1 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 0; 0 0 0 0 0 0]
[0 1 1 0 1 1 0; 1 1 0 1 1 1 1; 0 1 0 0 0 1 0; 0 0 0 1 1 0 1; 1 0 0 1 0 1 1; 0 0 1 1 0 1 1; 1 1 0 0 0 0 1]

ব্যাখ্যা

0     % Push 0. This represents the generation previous to the input one. Actually
      % This should be an array of zeros, but thanks to broadcasting it is
      % equivalent (and saves bytes)
i     % Input: array with starting generation
i     % Input: number of iterations, p.
      % STACK (bottom to top): 0, array with initial generation, p
:"    % Do the following p times
      %   STACK: previous gen, current gen
  wy  %   Swap, duplicate from below
      %   STACK: current gen, previous gen, current gen
  *~  %   Multiply element-wise, negate. This creates a mask of cells that do not 
      %   die of fatigue (they were 0 in the current or in the previous generation)
      %   STACK: current gen, fatigue mask
  wt  %   Swap, duplicate
      %   STACK: Fatigue mask, current gen, current gen
  3Y6 %   Push predefined literal: 8-neighbourhood: [1 1 1; 1 0 1; 1 1 1]
      %   STACK: Fatigue mask, current gen, current gen, 8-neighbourhood
  Q   %   Add 1 element-wise. This gives [2 2 2; 2 1 2; 2 2 2], which will be
      %   used as convolution kernel. Active cells with 2 neighbours will give 5;
      %   inactive cells with 3 neighbours will give 6; and active cells with 3
      %   neighbours will give 7
      %   STACK: Fatigue mask, current gen, current gen, convolution kernel
  Z+  %   2D convolution, keeping size
      %   STACK: Fatigue mask, current gen, convolution result
  5:7 %   Push array [5 6 7]
  m   %   Ismember, element-wise. Cells that give true will survive, unless fatigued
      %   STACK: Fatigue mask, current gen, cells that can survive
  b   %   Bubble up
      %   STACK: Current gen, cells that can survive, fatigue mask
  *   %   Multiply element-wise. This tells which cells survive considering fatigue.
      %   The result is the new generation
      %   STACK: "Current" gen which now becomes old, "new" gen which now becomes
      %   current
]     % End 
&     % Specify that implicit display will show only top of the stack
— লুইস মেন্ডো
সূত্র
1
আপনি 3Y6আরও বিস্তারিতভাবে ব্যাখ্যা করতে পারেন ? এছাড়াও, কার্নেলের মাঝারি উপাদানটি থাকলে .5আপনি স্রেফ দিয়ে সিজিওএল পরীক্ষা করতে পারেন 2<value<4। সাহায্য করতে পারে.
— ক্যালকুলেটরফলাইন
@ ক্যালকুলেটরফ্লাইন এটি একটি খুব ভাল পরামর্শ, ধন্যবাদ! এটি পাঁচটি বাইট সংরক্ষণ করেছিল, দুবার মুখোশ ব্যবহার করে এবং তারপরে এটি পরীক্ষা করে 5<=value<=7। যেমন 3Y6এটি কেবল পূর্বনির্ধারিত আক্ষরিক। এছাড়াও রয়েছে 1Y6, যা 4-পাড়া
— লুইস মেন্ডো
1
হাহ। এটা আসলে কাজ করেছে। ঝরঝরে।
— ক্যালকুলেটরফলাইন
3

এপিএল (ডায়ালগ ক্লাসিক 16.0) , 59 বাইট

⌊{((3∊⌊{⍵,⍵-c}+/,⍵)∧.1>1|c)×(.1×c)+1⌈c←2 2⌷⍵}⎕U233A 3 3⍣⎕⊢⎕

এটি অনলাইন চেষ্টা করুন! (ক্লাসিক 15.0 এ অনুকরণ করা)

এপিএল (ডায়ালগ ইউনিকোড 16.0) , 85 বাইট

⌊{((3∊⌊{⍵,⍵-c}+/,⍵)∧.1>1|c)×(.1×c)+1⌈c←2 2⌷⍵}⌺3 3⍣⎕⊢⎕

এটি অনলাইন চেষ্টা করুন! (ইউনিকোড 15.0 এ অনুকরণ করা)

গ্রিডের জন্য এবং তারপরে পি । পরে নতুন গ্রিড মুদ্রণ পি প্রজন্মের।

নোট করুন যে এটি নতুন ⌺(স্টেনসিল) আদিম ব্যবহার করে যা ক্লাসিক চরিত্রের সেটটিতে অন্তর্ভুক্ত নেই, সুতরাং একটি সংক্ষিপ্ত সংস্করণ এবং কম বাইট সংস্করণ।

অনুসরণ করার ব্যাখ্যা ...

— আদম
সূত্র
এপিএলের প্রদর্শন বিন্যাসটি দুর্দান্ত :-)
— লুইস মেন্ডো
@ লুইস মেন্ডো আসলে, এটি "এপিএল" নয় বরং আউটপুট নিতে চাইলে অনুবাদক এই এপিএল ফাংশনে কলব্যাক করেন । ফাংশনটি পরে আমরা কী আউটপুট করতে চাই তা বিশ্লেষণ করে এবং সে অনুযায়ী এটি সংশোধন করে। displayফাংশনটির ব্যাখ্যা এখানে রয়েছে ।
— অ্যাডম
3

গলি রুললোডার, 295 বাইট

@RULE Y
@TABLE
n_states:3
neighborhood:Moore
symmetries:permute
var z={1,2}
var y=z
var x=z
var w=z
var u=z
var a={0,z}
var b=a
var c=a
var d=a 
var e=a
var f=a
var g=a 
var h=a
0,z,y,x,0,0,0,0,0,1
z,a,0,0,0,0,0,0,0,0
z,y,x,w,u,a,b,c,d,0
2,a,b,c,d,e,f,g,h,0
1,a,b,c,d,e,f,g,h,2
@COLORS
2 255 0 0

ইনপুট গ্রিডটি আটকানো উচিত, সীমানাগুলি নিয়মের নাম (যেমন 5* 3হয় Y:P5,3), অগ্রসর হওয়ার জন্য স্পেস টিপুন।

— CalculatorFeline
সূত্র
2

জাভা 8, 333 বাইট

int[][]G(int p,int[][]s){for(int h=s.length,w=s[0].length,y,x,n,a,b,t[][]=new int[h][w],i=0;i++<2*p;)for(y=0;y<h;++y)for(x=0;x<w;++x)if(i%2>0){for(n=0,a=y-2;++a<y+2;)for(b=x-2;++b<x+2;)n+=a>=0&a<h&b>=0&b<w&(a!=y|b!=x)&&s[a][b]>0?1:0;t[y][x]=s[y][x]<1?n==3?1:0:n<2|n>3|s[y][x]>1?0:2;}else s[y][x]=i==2*p&t[y][x]>1?1:t[y][x];return s;}

ব্যাখ্যা:

int[][]G(int p,int[][]s){
    for(int h=s.length,w=s[0].length,y,x,n,a,b,t[][]=new int[h][w],       //height, width, vars, temp array
            i=0;i++<2*p;)                                                 //for 2*generations: 1. calculate in temporary t, 2. copying to s
        for(y=0;y<h;++y)                                                  //for each row
            for(x=0;x<w;++x)                                              //for each column
                if(i%2>0){                                                //1. calculate
                    for(n=0,a=y-2;++a<y+2;)                               //n = number of alive cells around [y][x]. row above, at and below y
                        for(b=y-2;++b<y+2;)                               //column left, at and right of x
                            n+=a>=0&a<h&b>=0&b<w&(a!=y|b!=x)&&s[a][b]>0?1:0;    //if within bounds and not the cell itself, add 1 if alive.
                    t[y][x]=s[y][x]<1?n==3?1:0:n<2|n>3|s[y][x]>1?0:2;     //save next state in temporary, depending on rules. alive cells become 2.
                }
                else                                                      //2. copy temporary t to s
                    s[y][x]=i==2*p&t[y][x]>1?1:t[y][x];                   //if last generation, replace 2 by 1
    return s;
}
— সেবাস্তিয়ান ম্যাটস্কে
সূত্র
আমাদের সাইট ব্যবহার করে, আপনি স্বীকার করেছেন যে আপনি আমাদের কুকি নীতি এবং গোপনীয়তা নীতিটি পড়েছেন এবং বুঝতে পেরেছেন ।
Licensed under cc by-sa 3.0 with attribution required.