জীবনের সবচেয়ে ছোট গেম

59

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

  • যদি কোনও লাইভ সেল বেঁচে থাকে তবে এর ঠিক দুই বা তিনটি লাইভ প্রতিবেশী থাকে
  • একটি মৃত কোষ জীবিত হয়ে ওঠে যদি এর ঠিক তিনটি জীবিত প্রতিবেশী থাকে

আপনার মিশনটি, আপনি যদি এটি গ্রহণ করতে চান তবে আপনার পছন্দের ভাষায় জীবনের সংক্ষিপ্ততম গেম অফ লাইফ বাস্তবায়ন কোড করা code

নিয়ম:

  • গ্রিডটি কমপক্ষে 20x20 হওয়া উচিত
  • গ্রিডটি অবশ্যই চারদিকে আবৃত হবে (সুতরাং গ্রিডটি টরাসের পৃষ্ঠের মতো)
  • আপনার প্রয়োগ অবশ্যই ব্যবহারকারীকে তাদের নিজস্ব প্রারম্ভিক নিদর্শনগুলিকে ইনপুট করার অনুমতি দিতে হবে
  • কী হচ্ছে তা যদি আপনি দেখতে না পান তবে GoL কিছুটা অর্থহীন, সুতরাং অটোমেটনের চাক্ষুষ আউটপুট অবশ্যই চলবে, প্রতিটি বারের ফলাফল দীর্ঘকাল ধরে দেখানোর জন্য প্রদর্শিত হবে!
code-golf  game-of-life  cellular-automata 
— ইশারা
সূত্র
8
পূর্বে স্ট্যাক ওভারফ্লোতে: কোড গল্ফ: কনওয়ের গেম অফ লাইফ এবং মন্তব্যগুলিতে এপিএল বাস্তবায়ন লিঙ্কটি অবশ্যই লক্ষ্য করুন।
— dmckee
1
আহ, আমি তা দেখিনি। তবে এটি কিছুটা আলাদা না (চ্যালেঞ্জকে একসাথে রেখে কাজটি মুছে ফেলতে বাঁচান?
— গ্রিফিন
6
এটা সমস্যা না. ইতিমধ্যে স্ট্যাক ওভারফ্লোতে চালিত প্রচুর ধাঁধা এখানেও সম্পন্ন হয়েছে, তবে লোকেরা আপনাকে বলবে যে আমি একই ধরণের চ্যালেঞ্জগুলির সাথে লিঙ্ক দেওয়ার ব্যাপারে আগ্রহী।
— ডিএমকেকে
@ গ্রিফিন: আপনি এর ;আগে সমস্তগুলি মুছে ফেলতে পারেন }। এছাড়াও varগুলি মাঝে মাঝে নির্মূল করা যেতে পারে (যদি এটি আপনার কোডটি না ভঙ্গ করে)। আর অন লাইন জন্য forS, ifগুলি ইত্যাদি, আপনি বাদ দিতে পারে { }সম্পূর্ণরূপে: for(...) for(...) dosomething()।
— pimvdb
@ পিএমভিডিবি, চিয়ার্স, আমি এখনও এটি পুরোপুরি গল্ফ করিনি, সময় পাইনি। অদৃশ্যভাবে একটি চ্যালেঞ্জ সেট করার চেয়ে কেবল আমার কাছে যেতে হবে তা দেখাতে চেয়েছিল। শীঘ্রই এটি সর্বাধিক গল্ফ হবে।
— গ্রিফিন

উত্তর:

27

জাভাস্ক্রিপ্ট সহ HTML5 ক্যানভাস, 940 639 586 519 টি অক্ষর

<html><body onload="k=40;g=10;b=[];setInterval(function(){c=[];for(y=k*k;y--;){n=0;for(f=9;f--;)n+=b[(~~(y/k)+k+f%3-1)%k*k+(y+k+~~(f/3)-1)%k];c[y]=n==3||n-b[y]==3;r.fillStyle=b[y]?'red':'tan';r.fillRect(y%k*g,~~(y/k)*g,g-1,g-1)}if(v.nextSibling.checked)b=c},1);v=document.body.firstChild;v.width=v.height=g*k;v.addEventListener('click',function(e){b[~~((e.pageY-v.offsetTop)/g)*k+~~((e.pageX-v.offsetLeft)/g)]^=1},0);r=v.getContext('2d');for(y=k*k;y--;)b[y]=0"><canvas></canvas><input type="checkbox"/>Run</body></html>

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

আপনি এখন এখানে নতুন সংস্করণ চেষ্টা করতে পারেন ।

দুর্ভাগ্যক্রমে এমন একটি সমস্যা আছে যা আমি এখনও কাজ করতে পারিনি। অনলাইন সংস্করণটি 11 টি অক্ষর দীর্ঘ কারণ জেএসফিডাল একটি টেক্সট নোড ক্যানভাসের ঠিক আগে রেখেছিল (কেন?) এবং এভাবে ক্যানভাসটি আর প্রথম সন্তানের নয়।

সম্পাদনা 1: প্রচুর অপটিমাইজেশন এবং পুনর্গঠন।

সম্পাদনা 2: বেশ কয়েকটি ছোট পরিবর্তন।

3 সম্পাদনা করুন: সম্পূর্ণ স্ক্রিপ্ট ব্লক এবং ছোটখাট পরিবর্তনগুলিকে অন্তর্ভুক্ত করা হয়েছে।

— হাওয়ার্ড
সূত্র
দুর্দান্ত, তবে বিরতিটির বিলম্বটি 1এটি ধীর পদক্ষেপের চেয়ে আমার হিসাবে দ্রুততর করে তুলুন। এছাড়াও যদি আপনি অঙ্কন বাস্তবায়ন করতে চান (প্রতিটি স্কয়ারের পরিবর্তে ক্লিক করুন) তবে আপনি মাউসের অবস্থানটি কাছের ব্লকসাইজে গোল করতে পারেন এবং সেই সময়ে আয়তক্ষেত্রটি পূরণ করতে পারেন। আরও অক্ষর তবে আরও পয়েন্ট।
— গ্রিফিন
আপনি প্রতিস্থাপন করতে পারেন new Array('#FFF','#800')সঙ্গে ['#FFF','#800']।
— লোজ্যাকার
যদিও অঙ্কন সম্পর্কে বলা হচ্ছে, আমার অতি গল্ফযুক্ত চিত্র আঁকতে দেয় না এবং পাপ হিসাবে কুৎসিত। হা হা। আপনি আপনার দুটি রঙ sঅ্যারেতে সেট করতে পারেন tanএবং redযেহেতু এটি সংক্ষিপ্ত উপস্থাপনের সাথে দুটি রঙ - আপনাকে দুটি অক্ষর বাঁচায়। এছাড়াও, যদি সম্ভব jহয় তবে ব্যবধানের আক্ষরিক সংস্করণটি রাখুন । আমি নিশ্চিত যে খুব বেশি কিছু নিবারণের আছে।
— গ্রিফিন
@ গ্রিফিন এবং লোজ্যাকার: আপনাকে অনেক ধন্যবাদ। আমি আরও নিশ্চিত যে আপনি আরও অনেকটা গল্ফ করতে পারেন (এবং ইতিমধ্যে কিছু ধারণা আছে)। দুর্ভাগ্যক্রমে আমি এটি করার সময় পাইনি। একটি আরও ভাল গল্ফযুক্ত সংস্করণ আগামীকাল অনুসরণ করবে - আমি আশা করি ...
— হাওয়ার্ড
2
আপনি এইচটিএমএল এবং বডি ট্যাগগুলি মুছে ফেলতে পারেন। এটি একই কাজ করবে
— এড়োডেবগ
32

পাইথন, 219 অক্ষর

আমি প্রশ্নটি সন্তুষ্ট করার জন্য পর্যাপ্ত ইন্টারফেস সহ সর্বাধিক গল্ফের জন্য গিয়েছিলাম।

import time
P=input()
N=range(20)
while 1:
 for i in N:print''.join(' *'[i*20+j in P]for j in N)
 time.sleep(.1);Q=[(p+d)%400 for d in(-21,-20,-19,-1,1,19,20,21)for p in P];P=set(p for p in Q if 2-(p in P)<Q.count(p)<4)

আপনি এটি এভাবে চালান:

echo "[8,29,47,48,49]" | ./life.py

তালিকার সংখ্যাগুলি শুরুর ঘরগুলির স্থানাঙ্ককে উপস্থাপন করে। প্রথম সারিতে 0-19, দ্বিতীয় সারিটি 20-39 ইত্যাদি etc.

21 সারি সহ এটি টার্মিনালে চালান এবং এটি বেশ আরামদায়ক দেখায়।

— কিথ র্যান্ডাল
সূত্র
1
এটি পুরোপুরি জিততে হবে। আমার অনুমান যে 'ইনপুট আরামদায়ক' ওজন মোটামুটি বেশি।
— প্রিমো
@ প্রিমো আমি এমনকি এমএমএর একটি পৃথক প্রতিযোগিতা থাকা উচিত বলে পরামর্শ দেওয়ার জন্য যেতে পারলাম।
— লুসার droog
2
তাহলে কি এই লাইফ অফ পাই?
— ক্রিস্টোফার
আপনি সর্বদা আরও একটি চর সংরক্ষণ করতে পারেন ... 2-(p in P)== 2-({p}<P)। তবে তারপরে আপনাকে আপনার ইনপুটটি পরিবর্তন করতে হবে {8,29,47,48,49}:)
— জেবার্নার্ডো
21

টিআই-বেসিক, ৯ by বাইট (প্রতিযোগী প্রবেশের জন্য ৮ 87)

আপনার টিআই -৪৮ সিরিজের গ্রাফিং ক্যালকুলেটর (!)। এই বেশ একটি চ্যালেঞ্জ ছিল কোন সহজ উপায় একটি বাফার গ্রাফিক্স রুটিন (স্পষ্টভাবে সালে নির্মিত কিছুই না) লিখতে আছে, কারণ এবং গ্রাফ পর্দা মাত্র চারটি প্রাসঙ্গিক গ্রাফিক্স কমান্ড রয়েছে: Pxl-On(), Pxl-Off(), Pxl-Change(), এবং pxl-Test()।

স্ক্রিনে প্রতিটি অ্যাক্সেসযোগ্য পিক্সেল এবং সঠিকভাবে মোড়ক ব্যবহার করে। প্রতিটি কক্ষ এক পিক্সেল, এবং প্রোগ্রামটি আপডেট করে পর্দা জুড়ে ডানদিকে অনুভূমিকভাবে রেখায়। যেহেতু ক্যালকুলেটরগুলির কেবল একটি 15MHz z80 প্রসেসর রয়েছে এবং বেসিকটি ধীরে ধীরে বর্ণিত ভাষা, কোডটি প্রতি পাঁচ মিনিটের মধ্যে কেবল একটি ফ্রেম পায়।

ব্যবহারকারীর ইনপুটটি সহজ: প্রোগ্রামটি চালানোর আগে গ্রাফ স্ক্রিনে আপনার আকৃতি আঁকার জন্য পেন সরঞ্জামটি ব্যবহার করুন।

আমার এন্ট্রি থেকে ক্যালকুলেটর ফোরাম ওমনিমাগায় একটি কোড গল্ফ প্রতিযোগিতায় রূপান্তরিত ।

0
While 1
For(X,0,94
Ans/7+49seq(pxl-Test(remainder(Y,63),remainder(X+1,95)),Y,62,123
For(Y,0,62
If 1=pxl-Test(Y,X)+int(3fPart(3cosh(fPart(6ֿ¹iPart(sum(Ans,Y+1,Y+3
Pxl-Change(Y,X
End
End
End

ওমনিমাগা সংস্করণ (87 বাইট)

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

0
While 1
For(X,0,93
Ans/7+49seq(pxl-Test(Y,X+1),Y,0,62
For(Y,1,61
If 2rand>isClockOn=pxl-Test(Y,X)+int(3fPart(3cosh(fPart(6ֿ¹iPart(sum(Ans,Y,Y+2
Pxl-Change(Y,X
End
End
ClockOff
End

এই সংস্করণটি সম্ভবত আমি এখনও লিখেছি সবচেয়ে গল্ফযুক্ত কোড এবং এতে কিছু সত্যিকারের বাজে আপত্তিজনক অপ্টিমাইজেশন রয়েছে:

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

  • আমি বেস -7 সংখ্যার 63-উপাদান অ্যারেতে আপডেট হওয়া একের পাশে তিনটি কলামের রাজ্য সংরক্ষণ করি। 49 এর স্থানটি কলামটি ডানদিকে ধারণ করে, 7 টির স্থানটি মধ্যম কলামটি ধরে রাখে এবং ইউনিটগুলির স্থানটি বাম কলামটি ধরে রাখে - 1 একটি জীবন্ত কক্ষের জন্য এবং 0 একটি মৃত কোষের জন্য। তারপরে আমি জীবিত প্রতিবেশী কোষের মোট সংখ্যা খুঁজতে সংশোধিত হওয়া ঘরের চারপাশের তিনটি সংখ্যার যোগফলের বাকী 6 টি মডেলটি গ্রহণ করি (এটি 9 টি ট্রিক দ্বারা ঠিক বিভাজকের মতো base বেসে 7, বাকি মড 6 এর যোগফলের সমান হয়) অঙ্কগুলি)। নিজে থেকে প্রায় 10 বাইট সঞ্চয় করে এবং পরবর্তী দুটি অপটিমাইজেশন ব্যবহার করার সুযোগ দেয়। চিত্রের উদাহরণ উদাহরণ করুন (আসুন ধরা যাক Y = 45 এ একটি নির্দিষ্ট কলামে কেন্দ্রের একটি গ্লাইডার রয়েছে:

    Row # | Cell State       | Stored number | Mod 6 = cell count
...
44      Live, Live, Live   49+7+1 = 57     3
45      Dead, Dead, Live   49+0+0 = 49     1
46      Dead, Live, Dead   0+7+0  = 7      1
...

    কেন্দ্রের ঘরটি মৃত অবস্থায় থাকবে, কারণ এটি প্রায় পাঁচটি জীবন্ত কোষ দ্বারা বেষ্টিত।

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

  • স্নিপেট int(3fPart(3cosh(দেয় 1যখন ইনপুটটি 3/6, 2যখন এটি 4/6 এর সমান হয় এবং 0যখন এটি 0, 1/6, 2/6 বা 5/6 এর সমান হয়। প্রায় 6 বাইট সাশ্রয় করে।

— lirtosiast
সূত্র
19

গণিত - 333

বৈশিষ্ট্য:

  • ইন্টারেক্টিভ ইন্টারফেস: আপনার নিদর্শনগুলি তৈরি করতে কক্ষগুলিতে ক্লিক করুন

  • দুর্দান্ত গ্রিড

  • বাটনগুলি: রান, বিরাম, পরিষ্কার

কোডটি নীচে রয়েছে।

Manipulate[x=Switch[run,1,x,2,CellularAutomaton[{224,{2,{{2,2,2},{2,1,2},{2,2,2}}},
{1,1}},x],3,Table[0,{k,40},{j,40}]];EventHandler[Dynamic[tds=Reverse[Transpose[x]];
ArrayPlot[tds,Mesh->True]],{"MouseClicked":>(pos=Ceiling[MousePosition["Graphics"]];
x=ReplacePart[x,pos->1-x[[Sequence@@pos]]];)}],{{run,3,""},{1->"||",2->">",3->"X"}}]

এখানে চিত্র বর্ণনা লিখুন

এটি কীভাবে চলে তা যদি আপনি অনুভব করতে চান তবে এই ব্লগের দ্বিতীয় উদাহরণটি উপরের কোডটির আরও বিস্তৃত সংস্করণ (লাইভ ফুরিয়ার বিশ্লেষণ, আরও ভাল ইন্টারফেস)। ফ্রি প্লাগইন ডাউনলোডের পরে উদাহরণটি ঠিক আপনার ব্রাউজারে চালানো উচিত।

— ভিটালিয়া কৌরভ
সূত্র
2
+1, যাওয়ার জন্য একটি দুর্দান্ত। হ্যাঁ এই সাইটের সমস্যাটি হ'ল, এখানে প্রচুর টন পুরানো প্রশ্ন রয়েছে যা একটি মিস করে।
— গ্রিফিন
@ গ্রিফিন একেবারেই লক্ষ্য করার জন্য ধন্যবাদ;)
— ভিটালিয়া কৌরভ
15

সি 1063 টি অক্ষর

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

#include <windows.h>
#include<process.h>
#define K ][(x+80)%20+(y+80)%20*20]
#define H R.Event.MouseEvent.dwMousePosition
#define J R.Event.MouseEvent.dwButtonState
HANDLE Q,W;char*E[3],O;Y(x,y){return E[0 K;}U(x,y,l,v){E[l K=v;}I(){E[2]=E[1];E[1]=*E;*E=E[2];memset(E[1],0,400);}A(i,j,k,l,P){while(1){Sleep(16);for(i=0;i<20;++i)for(j=0;j<20;++j){COORD a={i,j};SetConsoleCursorPosition(Q,a);putchar(E[0][i+j*20]==1?'0':' ');}if(O){for(i=0;i<20;++i)for(j=0;j<20;++j){for(k=i-1,P=0;k<i+2;++k)for(l=j-1;l<j+2;++l){P+=Y(k,l);}U(i,j,1,P==3?1:Y(i,j)==1&&P==4?1:0);}I();}}}main(T,x,y,F,D){for(x=0;x<21;++x)puts("#####################");E[0]=malloc(800);E[1]=E[0]+400;I();I();W=GetStdHandle(-10);Q=GetStdHandle(-11);SetConsoleMode(W,24);INPUT_RECORD R;F=D=O=0;COORD size={80,25};SetConsoleScreenBufferSize(Q,size);_beginthread(A,99,0);while(1){ReadConsoleInput(W,&R,1,&T);switch(R.EventType){case 1:O=R.Event.KeyEvent.dwControlKeyState&128;break;case 2:switch(R.Event.MouseEvent.dwEventFlags){case 1:x=H.X;y=H.Y;case 0:F=J&1;D=J&2;}if(F)U(x,y,0,1);if(D)U(x,y,0,0);}}}

সংকলিত EXE এখানে পাওয়া যাবে

সম্পাদনা: আমি উত্সটি মন্তব্য করেছি। এটি এখানে উপলব্ধ

— Kaslai
সূত্র
আমি এর একটি মন্তব্য সংস্করণ দেখতে চাই!
— লুসার droog
1
অবশ্যই, আমি কী ভাবছিলাম তা যদি আমি মনে করতে পারি তবে ... = পি
— ক্যাসলাই
1
@ লুসারড্রোগ এখানে পেস্টবিন.
— com
এটি কেবল দুর্দান্ত।
— রায়রিং - মনিকা
12

জে (39 টি অক্ষর)

l=:[:+/(3 4=/[:+/(,/,"0/~i:1)|.])*.1,:]

এই এপিএল সংস্করণ (একই অ্যালগোরিদম, টরোয়েডাল কনভোলশন) এর উপর ভিত্তি করে ।

ব্যবহারের উদাহরণ:

   r =: (i.3 3) e. 1 2 3 5 8
   r
0 1 1          NB. A glider!
1 0 1
0 0 1

   R =: _1 _2 |. 5 7 {. r
   R
0 0 0 0 0 0 0  NB. Test board
0 0 0 1 1 0 0
0 0 1 0 1 0 0
0 0 0 0 1 0 0
0 0 0 0 0 0 0

   l R
0 0 0 0 0 0 0  NB. Single step
0 0 0 1 1 0 0
0 0 0 0 1 1 0
0 0 0 1 0 0 0
0 0 0 0 0 0 0
— kaoD
সূত্র
10

গণিত, 123 টি অক্ষর

ম্যাথমেটিকার বিল্ট-ইন সেলুলারআউটোম্যাটন ফাংশনটি ব্যবহার করে না এমন একটি অত্যন্ত প্রাথমিক বাস্তবায়ন।

ListAnimate@NestList[ImageFilter[If[3<=Total@Flatten@#<=3+#[[2]][[2]],1,0]&,#,1]&,Image[Round/@RandomReal[1,{200,200}]],99]
— JOwen
সূত্র
8

রুবি ১.৯ + এসডিএল (380 325 314)

সম্পাদনা : ৩১৪ টি অক্ষর এবং প্রথম পুনরাবৃত্তিতে অতিরিক্ত কোষগুলি জীবন্ত উপস্থিত হওয়ার সাথে একটি বাগ স্থির করে। রঙের রুটিনটি সর্বনিম্ন 8 টি বিটকে দেখায় গ্রিড আকারটি 56 এ উন্নীত করে।

সম্পাদনা : গল্ফ ডাউন 325 অক্ষর। গ্রিডের প্রস্থ / উচ্চতা এখন 28 থেকে 28, 9 ব্যাকগ্রাউন্ডের রঙ হিসাবে মানটি ব্যবহার করার সময় আপনার কাছে থাকা বৃহত্তম। এটি এখন পুনরাবৃত্তির জন্য কেবল একটি এসডিএল ইভেন্ট প্রসেস করে, যা অভ্যন্তরীণ লুপটিকে পুরোপুরি বিঘ্নিত করে। বেশ টাইট আমি ভাবি!

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

মোড়ানো কিছুটা দুর্বল।

require'sdl'
SDL.init W=56
R=0..T=W*W
b=[]
s=SDL::Screen.open S=W*9,S,0,0
loop{r="#{e=SDL::Event.poll}"
r['yU']?$_^=1:r[?Q]?exit: r['nU']?b[e.y/9*W+e.x/9]^=1:0
b=R.map{|i|v=[~W,-W,-55,-1,1,55,W,57].select{|f|b[(i+f)%T]}.size;v==3||v==2&&b[i]}if$_
R.map{|i|s.fillRect i%W*9,i/W*9,9,9,[b[i]?0:S]*3}
s.flip
sleep 0.1}

এটা এমন দেখতে:

কর্মক্ষম অ্যাপ্লিকেশনটির স্ক্রিনশট shot

মজার চ্যালেঞ্জ! আমি যে কোনও উন্নতি দেখতে পাচ্ছি তাকে স্বাগত জানাই।

— পল প্রেস্টিজ
সূত্র
ভাল চেষ্টা করুন তবে আমি সরাসরি দেখতে পাচ্ছি যে আপনি ভুল হয়ে গিয়েছেন। জিওএলে আপনার মতো ধরণ থাকতে পারে না। বিধিগুলি সম্পর্কে আরও একবার পড়ুন: এন.ইউইকিপিডিয়া.আর.উইকি
— গ্রিফিন
@ গ্রিফিন আমার ধারণা স্ক্রিনশটটি কিছু কক্ষ নিজেই বিরতি দেওয়ার পরে এবং টগল করার পরে নেওয়া হয়েছিল - যদিও আমি আবার নিয়মগুলি পরীক্ষা করব। ধন্যবাদ!
— পল প্রেসিডেজ
7
@ গ্রিফিন কোন সম্ভাব্য কনফিগারেশনে বীজ প্যাটার্ন থাকতে পারে?
— ই
7

স্কালা, 1181 1158 1128 1063 1018 1003 999 992 987 টি অক্ষর

import swing._
import event._
object L extends SimpleSwingApplication{import java.awt.event._
import javax.swing._
var(w,h,c,d,r)=(20,20,20,0,false)
var x=Array.fill(w,h)(0)
def n(y:Int,z:Int)=for(b<-z-1 to z+1;a<-y-1 to y+1 if(!(a==y&&b==z)))d+=x((a+w)%w)((b+h)%h)
def top=new MainFrame with ActionListener{preferredSize=new Dimension(500,500)
menuBar=new MenuBar{contents+=new Menu("C"){contents+={new MenuItem("Go/Stop"){listenTo(this)
reactions+={case ButtonClicked(c)=>r= !r}}}}}
contents=new Component{listenTo(mouse.clicks)
reactions+={case e:MouseClicked=>var p=e.point
x(p.x/c)(p.y/c)^=1
repaint}
override def paint(g:Graphics2D){for(j<-0 to h-1;i<-0 to w-1){var r=new Rectangle(i*c,j*c,c,c)
x(i)(j)match{case 0=>g draw r
case 1=>g fill r}}}}
def actionPerformed(e:ActionEvent){if(r){var t=x.map(_.clone)
for(j<-0 to h-1;i<-0 to w-1){d=0
n(i,j)
x(i)(j)match{case 0=>if(d==3)t(i)(j)=1
case 1=>if(d<2||d>3)t(i)(j)=0}}
x=t.map(_.clone)
repaint}}
val t=new Timer(200,this)
t.start}}

Ungolfed:

import swing._
import event._

object Life extends SimpleSwingApplication
{
    import java.awt.event._
    import javax.swing._
    var(w,h,c,d,run)=(20,20,20,0,false)
    var x=Array.fill(w,h)(0)
    def n(y:Int,z:Int)=for(b<-z-1 to z+1;a<-y-1 to y+1 if(!(a==y&&b==z)))d+=x((a+w)%w)((b+h)%h)
    def top=new MainFrame with ActionListener
    {
        title="Life"
        preferredSize=new Dimension(500,500)
        menuBar=new MenuBar
        {
            contents+=new Menu("Control")
            {
                contents+={new MenuItem("Start/Stop")
                {
                    listenTo(this)
                    reactions+=
                    {
                        case ButtonClicked(c)=>run= !run
                    }
                }}
            }
        }
        contents=new Component
        {
            listenTo(mouse.clicks)
            reactions+=
            {
                case e:MouseClicked=>
                    var p=e.point
                    if(p.x<w*c)
                    {
                        x(p.x/c)(p.y/c)^=1
                        repaint
                    }
            }
            override def paint(g:Graphics2D)
            {
                for(j<-0 to h-1;i<-0 to w-1)
                {
                    var r=new Rectangle(i*c,j*c,c,c)
                    x(i)(j) match
                    {
                        case 0=>g draw r
                        case 1=>g fill r
                    }
                }
            }
        }
        def actionPerformed(e:ActionEvent)
        {
            if(run)
            {
                var t=x.map(_.clone)
                for(j<-0 to h-1;i<-0 to w-1)
                {
                    d=0
                    n(i,j)
                    x(i)(j) match
                    {
                        case 0=>if(d==3)t(i)(j)=1
                        case 1=>if(d<2||d>3)t(i)(j)=0
                    }
                }
                x=t.map(_.clone)
                repaint
            }
        }
        val timer=new Timer(200,this)
        timer.start
    }
}

কোডটির বৃহত্তর অংশটি হ'ল সুইং জিইউআই স্টাফ। গেমটি নিজেই সেই actionPerformedপদ্ধতিতে রয়েছে যা দ্বারা চালিত হয় Timerএবং সহায়তাকারী ফাংশন nযা প্রতিবেশীদের গণনা করে।

ব্যবহার:

এটি দিয়ে সংকলন করুন scalac filenameএবং তারপরে এটি চালান scala L।
স্কোয়ার ক্লিক করা এটিকে লাইভ থেকে মৃতের দিকে ঝাঁকিয়ে দেয় এবং মেনু বিকল্পটি শুরু হয় এবং খেলাটি বন্ধ করে দেয়। আপনি যদি গ্রিডের আকার পরিবর্তন করতে চান তবে লাইনের প্রথম তিনটি মান পরিবর্তন করুন: var(w,h,c,d,r)=(20,20,20,0,false)সেগুলি যথাক্রমে প্রস্থ, উচ্চতা এবং ঘরের আকার (পিক্সেলে)।

— গ্যারেথ
সূত্র
আমি 2 গল্ফিং-উন্নতি পেয়েছি: import java.awt.event._এবং contents+=m("Go",true)+=m("Stop",false)}}1093 টি অক্ষর নিয়েছি ।
— ব্যবহারকারী অজানা
@ ব্যবহারকারী অজানা ধন্যবাদ আমি নিজেই কিছু উন্নতি পেয়েছি - এখন 1063 তে নেমে এসেছে।
— গ্যারেথ
অভিশাপ তুমি ব্যস্ত। এটা বজায় রাখা! আরও কয়েক জন তাদের পোস্ট করলে আমি উত্তরগুলি পরীক্ষা করব।
— গ্রিফিন
7

খাঁটি বাশ, 244 বাইট

টরয়েডলি-মোড়ানো 36x24 মহাবিশ্বের উপর কাজ করে:

mapfile a
for e in {0..863};{
for i in {0..8};{
[ "${a[(e/36+i/3-1)%24]:(e+i%3-1)%36:1}" == O ]&&((n++))
}
d=\ 
c=${a[e/36]:e%36:1}
[ "$c" == O ]&&((--n==2))&&d=O
((n-3))||d=O
b[e/36]+=$d
n=
}
printf -vo %s\\n "${b[@]}"
echo "$o"
exec $0<<<"$o"

যেহেতু এটি একটি শেল স্ক্রিপ্ট, তাই ইনপুট পদ্ধতিটি অন্যান্য শেল কমান্ডের সাথে একত্রে - যেমন স্টিডিন থেকে:

$ ./conway.sh << EOF

   O 
    O 
  OOO 

EOF


  O O                                                       
   OO                                                       
   O                                                        

















    O                                                       
  O O                                                       
   OO

... ইত্যাদি

trআকর্ষণীয় প্রাথমিক প্রজন্মগুলি পেতে ফিল্টারের মাধ্যমে পাইপযুক্ত কোনও পাঠ্য উত্স থেকে আমরা ইনপুট পুনর্নির্দেশ করতে পারি

man tr | tr [:alnum:] O | ./conway.sh
— ডিজিটাল ট্রমা
সূত্র
6

জাভাস্ক্রিপ্ট, 130

চ্যালেঞ্জের পুরোপুরি সাড়া দেয়নি, তবে রেকর্ডের জন্য, 2013 সালে সাবজে এবং আমি তৈরি করা 130 বাইটে একটি গেম অফ লাইফ ইঞ্জিন রয়েছে's

http://xem.github.io/miniGameOfLife/

/* Fill an array with 0's and 1's, and call g(array, width, height) to iterate */
g=function(f,c,g,d,e,b,h){g=[];e=[c+1,c,c-1,1];for(b=c*c;b--;g[b]=3==d||f[b]&&2==d,d=0)for(h in e)d+=f[b+e[h]]+f[b-e[h]];return g}
— xem
সূত্র
এটি প্রথম সারিতে কিছু সমস্যা বলে মনে হচ্ছে। উদাহরণস্বরূপ @@\n@@(উপরের বাম কোণে 2 বাই 2 বর্গ) বা .@\n.@\n.@। (1 টি 3 কলাম)
— আনানান
5

সি # - 675 অক্ষর

আমি সবসময় এই প্রোগ্রামটির একটি সংস্করণ লিখতে চেয়েছিলাম। কখনই জানতেন না দ্রুত এবং নোংরা সংস্করণের জন্য এটি কেবল অলস আধ ঘন্টা সময় নেবে। (গল্ফ করতে এটি অবশ্যই অনেক বেশি সময় নেয়))

using System.Windows.Forms;class G:Form{static void Main(){new G(25).ShowDialog();}
public G(int z){var g=new Panel[z,z];var n=new int [z,z];int x,y,t;for(int i=0;i<z;
i++)for(int j=0;j<z;j++){var p=new Panel{Width=9,Height=9,Left=i*9,Top=j*9,BackColor
=System.Drawing.Color.Tan};p.Click+=(s,a)=>p.Visible=!p.Visible;Controls.Add(g[i,j]=
p);}KeyUp+=(s,_)=>{for(int i=0;i<99;i++){for(x=0;x<z;x++)for(y=0;y<z;y++){t=0;for(int 
c=-1;c<2;c++)for(int d=-1;d<2;d++)if(c!=0||d!=0){int a=x+c,b=y+d;a=a<0?24:a>24?0:a;b=
b<0?24:b>24?0:b;t+=g[a,b].Visible?0:1;}if(t==3||t>1&&!g[x,y].Visible)n[x,y]=1;if(t<2
||t>3)n[x,y]=0;}for(x=0;x<z;x++)for(y=0;y<z;y++)g[x,y].Visible=n[x,y]<1;Update();}};}}

ব্যবহার

  • সেগুলিকে চালু করতে (জীবিত) ক্লিক করে একটি সূচনা প্যাটার্ন প্রবেশ করুন।
  • যে কোনও কীবোর্ড কী টিপে গেমটি শুরু করুন।
  • খেলাটি প্রতিবার একটি কী চাপলে 99 প্রজন্মের জন্য চলতে থাকে (একটি চর সংরক্ষণ করতে আমি এটি 9 টি তৈরি করতে পারতাম, তবে এটি অত্যন্ত লম্পট বলে মনে হয়েছিল)।

গল্ফিং আপস

  • আপনি কেবল মাউস দিয়ে সেলগুলি চালু করতে পারেন, বন্ধ নয়, তাই আপনি যদি ভুল করে থাকেন তবে আপনাকে প্রোগ্রামটি পুনরায় চালু করতে হবে।
  • কোনও গ্রিড লাইন নেই, তবে এটি খেলতে পারা যায় না hurt
  • আপডেটের গতি সিপিইউ গতির সমানুপাতিক, তাই খুব দ্রুত কম্পিউটারে এটি সম্ভবত একটি ঝাপসা হতে পারে।
  • জীবন্ত কক্ষগুলি লাল কারণ "কালো" আরও 2 টি অক্ষর ব্যবহার করে।
  • কক্ষগুলির ক্ষুদ্রত্ব এবং এগুলি যে সমস্ত ফর্ম স্থান ব্যবহার করে না তা চরিত্র-সংরক্ষণের আপস।
— ইগবি লার্জম্যান
সূত্র
5

GW-বেসিক, 1086 1035 বাইট (টোকেনাইজড)

টোকেনাইজড ফর্মে এটি 1035 বাইট। আপনি ব্যবহার করে tokenised ফর্ম পেতে (হওয়া ASCII ফর্ম, অবশ্যই আরেকটু বেশি হয়।) SAVE"lifeসংযোজন ছাড়া কমান্ড ",aঅনুবাদক হবে।

10 DEFINT A-Z:DEF SEG=&HB800:KEY OFF:COLOR 7,0:CLS:DEF FNP(X,Y)=PEEK((((Y+25)MOD 25)*80+((X+80)MOD 80))*2)
20 X=0:Y=0
30 LOCATE Y+1,X+1,1
40 S$=INKEY$:IF S$=""GOTO 40
50 IF S$=CHR$(13)GOTO 150
60 IF S$=" "GOTO 130
70 IF S$=CHR$(0)+CHR$(&H48)THEN Y=(Y-1+25)MOD 25:GOTO 30
80 IF S$=CHR$(0)+CHR$(&H50)THEN Y=(Y+1)MOD 25:GOTO 30
90 IF S$=CHR$(0)+CHR$(&H4B)THEN X=(X-1+80)MOD 80:GOTO 30
100 IF S$=CHR$(0)+CHR$(&H4D)THEN X=(X+1)MOD 80:GOTO 30
110 IF S$="c"THEN CLS:GOTO 20
120 GOTO 40
130 Z=PEEK((Y*80+X)*2):IF Z=42 THEN Z=32ELSE Z=42
140 POKE(Y*80+X)*2,Z:GOTO 40
150 LOCATE 1,1,0:ON KEY(1)GOSUB 320:KEY(1) ON
160 V!=TIMER+.5:FOR Y=0 TO 24:FOR X=0 TO 79:N=0
170 Z=FNP(X-1,Y-1):IF Z=42 OR Z=46 THEN N=N+1
180 Z=FNP(X,Y-1):IF Z=42 OR Z=46 THEN N=N+1
190 Z=FNP(X+1,Y-1):IF Z=42 OR Z=46 THEN N=N+1
200 Z=FNP(X-1,Y):IF Z=42 OR Z=46 THEN N=N+1
210 Z=FNP(X+1,Y):IF Z=42 OR Z=46 THEN N=N+1
220 Z=FNP(X-1,Y+1):IF Z=42 OR Z=46 THEN N=N+1
230 Z=FNP(X,Y+1):IF Z=42 OR Z=46 THEN N=N+1
240 Z=FNP(X+1,Y+1):IF Z=42 OR Z=46 THEN N=N+1
250 Z=PEEK((Y*80+X)*2):IF Z=32 THEN IF N=3 THEN Z=43
260 IF Z=42 THEN IF N<2 OR N>3 THEN Z=46
270 POKE(Y*80+X)*2,Z:NEXT:NEXT:FOR Y=0 TO 24:FOR X=0 TO 79:Z=PEEK((Y*80+X)*2):IF Z=46 THEN Z=32
280 IF Z=43 THEN Z=42
290 POKE(Y*80+X)*2,Z:NEXT:NEXT
300 IF TIMER<V!GOTO 300
310 IF INKEY$=""GOTO 160
320 SYSTEM

এটি সর্বাধিক গল্ফযুক্ত সংস্করণ, তবে এখনও বৈশিষ্ট্যযুক্ত: শুরু করার পরে, আপনি একটি সম্পাদক পান, যাতে আপনি কার্সার কীগুলি নিয়ে চলতে পারেন; স্পেসটি বর্তমান ক্ষেত্রের উপর ব্যাকটিরিয়াকে চালু বা বন্ধ করে দেয়, cস্ক্রিন সাফ করে, রিটার্ন গেমের মোডে শুরু হয়।

এখানে একটি স্বল্প-বিস্মৃত সংস্করণ অনুসরণ করা হয়েছে, যা দুটি স্ট্রাকচার (একটি বিজ্ঞপ্তি-ঘোরানো জিনিস এবং একটি গ্লাইডার) সহ প্রাথমিক গেম বোর্ড সেট করে:

1000 REM Conway's Game of Life
1001 REM -
1002 REM Copyright (c) 2012 Thorsten "mirabilos" Glaser
1003 REM All rights reserved. Published under The MirOS Licence.
1004 REM -
1005 DEFINT A-Z:DEF SEG=&hB800
1006 KEY OFF:COLOR 7,0:CLS
1007 DEF FNP(X,Y)=PEEK((((Y+25) MOD 25)*80+((X+80) MOD 80))*2)
1010 PRINT "Initial setting mode, press SPACE to toggle, RETURN to continue"
1020 PRINT "Press C to clear the board, R to reset. OK? Press a key then."
1030 WHILE INKEY$="":WEND
1050 CLS
1065 DATA 3,3,4,3,5,3,6,3,7,3,8,3,3,4,4,4,5,4,6,4,7,4,8,4
1066 DATA 10,3,10,4,10,5,10,6,10,7,10,8,11,3,11,4,11,5,11,6,11,7,11,8
1067 DATA 11,10,10,10,9,10,8,10,7,10,6,10,11,11,10,11,9,11,8,11,7,11,6,11
1068 DATA 4,11,4,10,4,9,4,8,4,7,4,6,3,11,3,10,3,9,3,8,3,7,3,6
1069 DATA 21,0,22,1,22,2,21,2,20,2,-1,-1
1070 RESTORE 1065
1080 READ X,Y
1090 IF X=-1 GOTO 1120
1100 POKE (Y*80+X)*2,42
1110 GOTO 1080
1120 X=0:Y=0
1125 LOCATE Y+1,X+1,1
1130 S$=INKEY$
1140 IF S$="" GOTO 1130
1150 IF S$=CHR$(13) GOTO 1804
1160 IF S$=" " GOTO 1240
1170 IF S$=CHR$(0)+CHR$(&h48) THEN Y=(Y-1+25) MOD 25:GOTO 1125
1180 IF S$=CHR$(0)+CHR$(&h50) THEN Y=(Y+1) MOD 25:GOTO 1125
1190 IF S$=CHR$(0)+CHR$(&h4B) THEN X=(X-1+80) MOD 80:GOTO 1125
1200 IF S$=CHR$(0)+CHR$(&h4D) THEN X=(X+1) MOD 80:GOTO 1125
1210 IF S$="c" THEN CLS:GOTO 1120
1220 IF S$="r" GOTO 1050
1225 IF S$=CHR$(27) THEN END
1230 GOTO 1130
1240 Z=PEEK((Y*80+X)*2)
1250 IF Z=42 THEN Z=32 ELSE Z=42
1260 POKE (Y*80+X)*2,Z
1270 GOTO 1130
1804 LOCATE 1,1,0
1900 ON KEY(1) GOSUB 2300
1910 KEY(1) ON
2000 V!=TIMER+.5
2010 FOR Y=0 TO 24
2020  FOR X=0 TO 79
2030   N=0
2040   Z=FNP(X-1,Y-1):IF Z=42 OR Z=46 THEN N=N+1
2050   Z=FNP(X  ,Y-1):IF Z=42 OR Z=46 THEN N=N+1
2060   Z=FNP(X+1,Y-1):IF Z=42 OR Z=46 THEN N=N+1
2070   Z=FNP(X-1,Y  ):IF Z=42 OR Z=46 THEN N=N+1
2080   Z=FNP(X+1,Y  ):IF Z=42 OR Z=46 THEN N=N+1
2090   Z=FNP(X-1,Y+1):IF Z=42 OR Z=46 THEN N=N+1
2100   Z=FNP(X  ,Y+1):IF Z=42 OR Z=46 THEN N=N+1
2110   Z=FNP(X+1,Y+1):IF Z=42 OR Z=46 THEN N=N+1
2120   Z=PEEK((Y*80+X)*2)
2130   IF Z=32 THEN IF N=3 THEN Z=43
2140   IF Z=42 THEN IF N<2 OR N>3 THEN Z=46
2150   POKE (Y*80+X)*2,Z
2160  NEXT X
2170 NEXT Y
2200 FOR Y=0 TO 24
2210  FOR X=0 TO 79
2220   Z=PEEK((Y*80+X)*2)
2230   IF Z=46 THEN Z=32
2240   IF Z=43 THEN Z=42
2250   POKE (Y*80+X)*2,Z
2260  NEXT X
2270 NEXT Y
2280 IF TIMER<V! GOTO 2280
2290 IF INKEY$="" GOTO 2000
2300 SYSTEM

বিরক্ত হয়ে এবং বন্ধুর জন্য অপেক্ষা করতে করতে আমি 15 মিনিটের মধ্যে এটি লিখেছিলাম, যিনি একই সময়ে কনওয়ের গেম অফ লাইফের জন্য তাঁর "শিক্ষানবিশ" দিয়ে কোড-গল্ফ করেছিলেন।

এটি এর মতো কাজ করে: এটি অবিলম্বে 80x25 টেক্সট মোড স্ক্রিন বাফার ব্যবহার করে ( আপনি যদি হারকিউলিস গ্রাফিক্স কার্ডে থাকেন তবে DEF SEGব্যবহারের প্রাথমিক পরিবর্তন করুন &hB000; এই সেটিংসটি কেমু এবং (ধীর) ডসবক্সের সাথে কাজ করে)। একটি নক্ষত্র *একটি ব্যাকটিরিয়া।

এটি দ্বি-পাসের কাজ করে: প্রথমত, জন্মস্থানগুলি চিহ্নিত করা হয় +এবং মৃত্যুর সাথে এটির লক্ষ্যগুলি চিহ্নিত করা হয় .। দ্বিতীয় পাস ইন, +এবং .সঙ্গে প্রতিস্থাপিত হয় *এবং যথাক্রমে।

TIMERজিনিস এটা প্রতিটি রাউন্ডে পর অর্ধেক একটি দ্বিতীয় জন্য অপেক্ষা করতে হয়, ক্ষেত্রে আপনার QEMU হোস্ট খুব দ্রুত ☺ হয়

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

— mirabilos
সূত্র
অ-গল্ফযুক্ত সংস্করণে আপনার লেবেলগুলিকে 1 দ্বারা বাড়ানো বিবেচনা করে, গল্ফযুক্ত সংস্করণেও কি এটি করা সম্ভব? (অর্থাত, 1, 2, 3, ইত্যাদি) অথবা লাইন সংখ্যা গণনা করা হয় না?
— জাকারি
লাইন সংখ্যা, যখন টোকেনাইজড হয়, শব্দ হিসাবে গণনা করুন (16 বিট), যদি আমি পুরোপুরি ভুল না করি
— মিরাবিলোস
ঠিক আছে, তাহলে অনুমান করুন আমি তখন অবশ্যই অন্যান্য কিছু বেসিক উপভাষার কথা ভাবছিলাম।
— জাকারি
@ জ্যাচারý "জিডাব্লু-বেসিক টোকেনাইজড প্রোগ্রাম ফর্ম্যাট" ক্লিক করুন এবং তারপরে এখানে "প্রোগ্রাম ফর্ম্যাট" ক্লিক করুন , প্রকৃতপক্ষে, লাইন নম্বরগুলি ক্রমাগতভাবে দুটি বাইট হয় এবং টোকেন ফর্ম্যাটের আরও গভীরতার জন্য।
— মিরাবিলোস
5

গণিত, 115 বাইট

এটির জন্য এখানে একটি সহজ কপ-আউট: 

ListAnimate[ArrayPlot/@CellularAutomaton[{224,{2,{{2,2,2},{2,1,2},
{2,2,2}}},{1,1}},{RandomInteger[1,{9,9}],0},90]]
— JeremyKun
সূত্র
1
গাণিতিক ভাল, তবে নিয়ম অনুসারে প্রোগ্রামটি ব্যবহারকারীকে তাদের নিজস্ব নিদর্শনগুলি ইনপুট করার অনুমতি দিতে হবে। এই নিয়মটি ইচ্ছাকৃত, যেহেতু কয়েকটি ভাষা সংক্ষিপ্ত বাস্তবায়নের অনুমতি দেয় তবে ব্যবহারকারীর সাথে কোনও ইন্টারঅ্যাকশন না করে। নিশ্চিত যে আপনি সেখানে নিজের অ্যারে রাখতে পারেন তবে এটি জিততে পারে না।
— গ্রিফিন
গাণিতিকায় "ইনপুট" বেশিরভাগ নোটবুক ইন্টারফেসের মাধ্যমে হয়, তাই আমি মনে করি না "ব্যবহারকারীর মিথস্ক্রিয়া" সত্যই সম্ভব। আপনি কেবল সেলুলারআউটমেটনের ফাংশনে র্যান্ডমইন্টেজার যুক্তিটি যা খুশি তাই প্রতিস্থাপন করুন এবং কোডটি পুনরায় মূল্যায়ন করুন।
— জেরেমিকুন
3
ব্যবহারকারীর মিথস্ক্রিয়া সম্ভব। আমি এখন ভাবতে সবচেয়ে সহজ পদ্ধতি হ'ল বোতামগুলির একটি অ্যারে। একটি গো মানুষ দিন।
— গ্রিফিন
4

জাভা (ওপেনজেডিকে 8) - 400 388 367 বাইট

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

ফলাফলের কোড (লুপের জন্য যারা ডাবল নেস্টগুলি কীভাবে সংক্ষিপ্ত করবেন তা আমি যদি জানতে পারি তবে সম্ভবত আরও বেশি গল্ফিং শেষ হবে ...):

u->{int w=u.length,h=u[0].length,x,y,i,j,n;Stack<Point>r=new Stack<Point>();for(;;){for(Point c:r)u[c.x][c.y]=1;r.clear();for(x=0;x<w;++x)for(y=0;y<h;++y){boolean o=u[x][y]>0;n=o?-1:0;for(i=-2;++i<2;)for(j=-2;++j<2;)if(u[(w+x+i)%w][(h+y+j)%h]>0)++n;if(o&n>1&n<4|!o&n==3)r.add(new Point(x,y));System.out.print(u[x][y]+(y>h-2?"\n":""));}for(int[]t:u)Arrays.fill(t,0);}}

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

(মূল পোস্টটি এখানে শুরু হয়))

আমি আসলে একটি মুহুর্তের জন্য ভেবেছিলাম যে আমি জাভা লোল সম্পর্কে আমার (তর্কাতীতভাবে সীমাবদ্ধ) জ্ঞানের সাহায্যে কমপক্ষে সেরা পাইথন উত্তরের চ্যালেঞ্জ করতে সক্ষম হব ... এটি এমন একটি চ্যালেঞ্জ ছিল যা আমি তবুও অংশ নিতে পেরে আনন্দ করেছি (পার্টিতে যোগদানের পরেও সম্ভবত একটি মাত্র কিছুটা দেরি ...)

এটির তেমন কিছুই নেই - নীচের অনুসারে প্রাথমিক ব্যাখ্যা (অবরুদ্ধ):

/*
 * Explanation of each variable's usage:
 * w=height* of array
 * h=width* of array
 * x=y* coord of point in array
 * y=x* coord of point in array
 * i and j are counters for calculating the neighbours around a point in the array
 * n=neighbour counter
 * r=temporary array to store the cells from the current generation
 * u=the 2d array used for all the calculations (parameter from lambda expression)
 * c=temporary variable used to help populate the 2d array
 * o=boolean variable that stores the value of whether the cell is alive or not
 */
u-> // start of lambda statement with u as parameter (no need for brackets as it's only one parameter being passed)
{
    int w=u.length,h=u[0].length,x,y,i,j,n; // defines all the necessary integer variables;
    Stack<Point>r=new Stack<Point>(); // same with the only array list needed (note how I only use two data structures);
    for(;;) // notice how this is still an infinite loop but using a for loop;
    {
        for(Point c:r)u[c.x][c.y]=1; //for every point in the "previous" generation, add that to the 2D array as a live (evil?) cell;
        r.clear(); // clears the array list to be populated later on
        for(x=0;x<w;++x) // a pair of nested for loops to iterate over every cell of the 2D array;
        {
            for(y=0;y<h;++y)
            {
                // sets o to be the presence of a live cell at (x,y) then uses said value in initialising the neighbour counter;
                boolean o=u[x][y]>1;n=o?-1:0;
                for(i=-2;++i<2;) // another pair of nested for loops - this one iterates over a 3x3 grid around *each* cell of the 2D array;
                {                // this includes wrap-around (note the modulus sign in the if statement below);
                    for(j=-2;++j<2;)
                    {
                        if(u[(w+x+i)%w][(h+y+j)%h]>0)++n; // this is where the first interesting thing lies - the bit which makes wrap-around a reality;
                    }
                }
                if(o&n>1&n<4|!o&n==3)r.add(new Point(x,y)); // this is the second interesting bit of my code - perhaps more so as I use bitwise operators to calculate the number of neighbours (x,y) has;
                                                            // (since I'm technically dealing with 0s and 1s, it's not a total misuse of them imo);
                System.out.print(u[x][y]+(y>h-2?"\n":""));  // that extra part of the print statement adds a newline if we reached the end of the current 'line';
            }
        }
        // since the information about the new generation is now in the array list, this array can be emptied out, ready to receive said info on the new generation;
        for(int[]t:u)Arrays.fill(t,0);
    }
} // end of lambda statement

(জাভা 8-এ ল্যাম্বদা স্টেটমেন্ট সম্পর্কে আরও তথ্য এখানে )

হ্যাঁ, আমার পদ্ধতির সাথে একটি ধরা আছে।

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

u->{int b=0,w=u.length,h=u[0].length,x,y,i,j,n;Stack<Point>r=new Stack<Point>();for(;++b<6;){for(Point c:r)u[c.x][c.y]=1;r.clear();for(x=0;x<w;++x)for(y=0;y<h;++y){boolean o=u[x][y]>0;n=o?-1:0;for(i=-2;++i<2;)for(j=-2;++j<2;)if(u[(w+x+i)%w][(h+y+j)%h]>0)++n;if(o&n>1&n<4|!o&n==3)r.add(new Point(x,y));System.out.print(u[x][y]+(y>h-2?"\n":""));}for(int[]t:u)Arrays.fill(t,0);}}

অতিরিক্তভাবে, কয়েকটি বিষয় উল্লেখযোগ্য। এই প্রোগ্রামটি ইনপুটটি সঠিক কিনা এবং তা চেক করে না, অতএব, (সম্ভবত সম্ভবত) এ দিয়ে ব্যর্থ হবে ArrayOutOfBoundsException; যেমন, অ্যারের অংশ পুরোপুরি পূরণ করে ইনপুটটি বৈধ কিনা তা নিশ্চিত করে নিন (স্ক্যাচড অ্যারেগুলি উপরে বর্ণিত ব্যতিক্রমটিকে নিক্ষেপ করবে)। এছাড়াও, বোর্ডটি বর্তমানে এটি দেখতে 'তরল' দেখাচ্ছে - এটি হ'ল এক প্রজন্মের এবং পরবর্তী প্রজন্মের মধ্যে কোনও বিচ্ছেদ নেই। যদি আপনি এটি যুক্ত করতে চান যে উত্সাহিত প্রজন্ম সত্যই বৈধ কিনা ডাবল-চেক System.out.println();করার জন্য, ঠিক আগে একটি অতিরিক্ত অতিরিক্ত যুক্ত করা দরকার for(int[]t:u)Arrays.fill(t,0);( স্বচ্ছতার জন্য এটি অনলাইনে দেখুন! ) এবং সর্বশেষে, তবে কম নয়, প্রদত্ত যে এটি আমার প্রথম কোড গল্ফ, যে কোনও প্রতিক্রিয়ার প্রশংসা করা হয়েছে :)

পূর্ববর্তী 388 বাইট উত্তর থেকে পুরাতন কোড:

u->{int w=u.length,h=u[0].length,x,y,i,j,n;ArrayList<Point>r=new ArrayList<Point>();while(true){for(Point c:r)u[c.x][c.y]=1;r.clear();for(x=0;x<w;++x){for(y=0;y<h;++y){boolean o=u[x][y]==1;n=o?-1:0;for(i=-2;++i<2;)for(j=-2;++j<2;)if(u[(w+x+i)%w][(h+y+j)%h]==1)++n;if(o&n>1&n<4|!o&n==3)r.add(new Point(x,y));System.out.print(u[x][y]);}System.out.println();}for(int[]t:u)Arrays.fill(t,0);}}

এবং প্রাথমিক 400 বাইট উত্তর থেকে:

int w=35,h=20,x,y,i,j,n;ArrayList<Point>l=new ArrayList<Point>(),r;while(true){int[][]u=new int[w][h];for(Point c:l)u[c.x][c.y]=1;r=new ArrayList<Point>();for(x=0;x<w;++x){for(y=0;y<h;++y){boolean o=u[x][y]==1;n=o?-1:0;for(i=-2;++i<2;)for(j=-2;++j<2;)if(u[(w+x+i)%w][(h+y+j)%h]==1)++n;if(o&n>1&n<4|!o&n==3)r.add(new Point(x,y));System.out.print(u[x][y]);}System.out.println();}l.clear();l.addAll(r);}
— NotBaal
সূত্র
আশ্চর্যজনক প্রথম পোস্ট, পিপিসিজিতে আপনাকে স্বাগতম!
— জাকারি
ধন্যবাদ, আমি অবশ্যই এগুলি আরও করতে যাচ্ছি - তারা মজাদার :)
— নোটবাল
আমাদের সাথে যোগ দিন, আমাদের ডেনিস আছে। এছাড়াও, এটি একটি সম্পূর্ণ প্রোগ্রাম বা কোনও ক্রিয়াকলাপ নয়, যা এটি হওয়া দরকার, আইআইআরসি।
— জাকারি
ওহ হ'ল 'প্রোগ্রাম' অংশটি ভুলে গেছেন: পি এটি কিছুটা মধ্যে সম্পাদনা করছে।
— নোটবাল
এটি শুধু একটি ফাংশন হতে পারে।
— জাকারি
4

স্টেনসিল , 6 বাইট

না আমার প্রিয় ভাষা, কিন্তু এটা হয় সংক্ষিপ্ত ...

4 কোড বাইট প্লাস ∊nlist এবং Torus পতাকা।

3∊me

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

কি ...
 3 3
 ∊ সদস্য মি স্ব বা oore-আশপাশ গোনা  Moor ই স্ব ছাড়া -neighbourhood গোনা ...?
 m
 e

— আদম
সূত্র
3

স্কালা - 799 অক্ষর

স্ক্রিপ্ট হিসাবে চালান। স্কোয়ারে একটি মাউস ক্লিক এটিকে চালু বা বন্ধ করে দেয় এবং কোনও কী প্রজন্মের শুরু বা থামায়।

import java.awt.Color._
import swing._
import event._
import actors.Actor._
new SimpleSwingApplication{var(y,r,b)=(200,false,Array.fill(20,20)(false))
lazy val u=new Panel{actor{loop{if(r){b=Array.tabulate(20,20){(i,j)=>def^(i:Int)= -19*(i min 0)+(i max 0)%20
var(c,n,r)=(0,b(i)(j),-1 to 1)
for(x<-r;y<-r;if x!=0||y!=0){if(b(^(i+x))(^(j+y)))c+=1}
if(n&&(c<2||c>3))false else if(!n&&c==3)true else n}};repaint;Thread.sleep(y)}}
focusable=true
preferredSize=new Dimension(y,y)
listenTo(mouse.clicks,keys)
reactions+={case e:MouseClicked=>val(i,j)=(e.point.x/10,e.point.y/10);b(i)(j)= !b(i)(j)case _:KeyTyped=>r= !r}
override def paintComponent(g:Graphics2D){g.clearRect(0,0,y,y);g.setColor(red)
for(x<-0 to 19;y<-0 to 19 if b(x)(y))g.fillRect(x*10,y*10,9,9)}}
def top=new Frame{contents=u}}.main(null)
— DonMac
সূত্র
3

জে, 45

আমি ভেবেছিলাম আমি জে একবার চেষ্টা করব। এটি এখনও ভালভাবে গল্ফ হয়নি, তবে আমি শীঘ্রই এটিকে আবার চেষ্টা করব।

(]+.&(3&=)+)+/((4&{.,(_4&{.))(>,{,~<i:1))&|.

উদাহরণ: 

   f =: 5 5 $ 0 1 0 0 0   0 0 1 0 0   1 1 1 0 0   0 0 0 0 0    0 0 0 0 0
   f
0 1 0 0 0
0 0 1 0 0
1 1 1 0 0
0 0 0 0 0
0 0 0 0 0
   f (]+.&(3&=)+)+/((4&{.,(_4&{.))(>,{,~<i:1))&|. f
0 0 0 0 0
1 0 1 0 0
0 1 1 0 0
0 1 0 0 0
0 0 0 0 0
— কপি
সূত্র
3

প্রক্রিয়াজাতকরণ 536 532

int h=22,t=24,i,j;int[][]w=new int[t][t],b=new int[t][t];int[]q={1,0,-1};void draw(){if(t<9){clear();for(i=2;i<h;i++){for(j=2;j<h;j++)w[i][j]=b[i][j];w[i][1]=w[i][21];w[i][h]=w[i][2];w[1][i]=w[21][i];w[h][i]=w[2][i];}for(i=1;i<23;i++)for(j=1;j<23;j++){t=-w[i][j];for(int s:q)for(int d:q)t+=w[i+s][j+d];b[i][j]=w[i][j]>0&(t<2|t>3)?0:t==3?1:b[i][j];}a();}}void keyPressed(){t=0;}void mousePressed(){int i=mouseX/5+2,j=mouseY/5+2;w[i][j]=b[i][j]=1;a();}void a(){for(i=0;i<h-2;i++)for(j=0;j<h-2;j++)if(w[i+2][j+2]==1)rect(i*5,j*5,5,5);}

আমি বিশ্বাস করি এটি সমস্ত প্রয়োজনীয়তা পূরণ করে।

Ungolfed:

int h=22,t=24,i,j;
int[][]w=new int[t][t],b=new int[t][t];
int[]q={1,0,-1};
void draw(){
  if(t<9){
  clear();
  for(i=2;i<h;i++){
    for(j=2;j<h;j++)
      w[i][j]=b[i][j];  
    w[i][1]=w[i][21];
    w[i][h]=w[i][2];
    w[1][i]=w[21][i];
    w[h][i]=w[2][i];
  }
  for(i=1;i<23;i++)
    for(j=1;j<23;j++){
      t=-w[i][j];
      for(int s:q)
        for(int d:q)
          t+=w[i+s][j+d];        
      b[i][j]=w[i][j]>0&(t<2|t>3)?0:t==3?1:b[i][j];  
  }
  a();
}
}
void keyPressed(){
  t=0;
}
void mousePressed(){
  int i=mouseX/5+2,j=mouseY/5+2;
  w[i][j]=b[i][j]=1;
  a();
}
void a(){
  for(i=0;i<h-2;i++)
    for(j=0;j<h-2;j++)
      if(w[i+2][j+2]==1)
        rect(i*5,j*5,5,5);
  }
— খাদ্যশস্য
সূত্র
3

মতলব (152)

b=uint8(rand(20)<0.2)
s=@(m)imfilter(m,[1 1 1;1 0 1;1 1 1],'circular')
p=@(m,n)uint8((n==3)|(m&(n==2)))
while 1
imshow(b)
drawnow
b=p(b,s(b))
end

আমি এটি পরীক্ষা করার জন্য মাতলাব এখনই ইনস্টল করা নেই, কয়েক বছর আগে আমি লিখেছি যে কোডটি আমি গল্ফ করেছিলাম।
Ungolfed:

%% initialize
Bsize = 20;
nsteps = 100;
board = uint8(rand(Bsize)<0.2); % fill 20% of the board
boardsum = @(im) imfilter(im,[1 1 1; 1 0 1; 1 1 1], 'circular');
step = @(im, sumim) uint8((sumim==3) | (im & (sumim==2)) );

%% run
for i = 1:nsteps
    imshow(kron(board,uint8(ones(4))), [])
    drawnow
    ss(p,i) = sum(board(:));
    board = step(board, boardsum(board));
end
  • বোর্ডসাইজ হার্ডকডযুক্ত তবে কিছু হতে পারে
  • চারপাশে মোড়ানো
  • ব্যবহারকারীর ইনপুটটির জন্য একজন অন্য ম্যাট্রিক্সকে হার্ডকড করে অথবা ভেরিয়েবল সম্পাদক ব্যবহার করে ইনিটাল বোর্ড পরিবর্তন করতে পারে। সুন্দর নয়, তবে এটি কাজ করে
  • গ্রাফিকাল আউটপুট এড়িয়ে গেলে 20 অক্ষর সংরক্ষণ করা যায়, বোর্ডটি প্রতিটি পুনরাবৃত্তিতে পাঠ্য হিসাবে প্রিন্ট করা হবে। ওয়ান-পিক্সেল সেলগুলি যা প্রতি মিলিসেকেন্ডে পরিবর্তিত হয় যাইহোক, খুব বেশি কার্যকর নয়
— DenDenDo
সূত্র
আর -2014 এ কাজ করে, সবেমাত্র পরীক্ষিত হয়েছে
— এক্স 244
3

পার্ল, 218 216 211 202 বাইট

$,=$/;$~=AX3AAAx76;$b=pack('(A79)23',<>)x6;{print unpack'(a79)23a0',$b;select$v,$v,$v,0.1;$b=pack'(A)*',unpack'((x7a/(x13)X4Ax!18)1817@0)4',pack'((a*)17xx!18)*',unpack"x1737(AA$~Ax$~AA$~@)2222",$b;redo}

(এই কোডের শেষে কোনও নতুন লাইন নেই))

স্ট্যান্ডার্ড ইনপুট থেকে প্রারম্ভিক প্যাটার্নটি পড়ুন, পাঠ্য ফাইল হিসাবে যেখানে লাইভ কোষগুলি স্থান হিসাবে উপস্থাপিত হয় 1, মৃত কোষগুলিকে স্থান হিসাবে উপস্থাপন করা হয়, লাইনগুলি একটি নিউলাইন দ্বারা পৃথক করা হয়। ইনপুটটির এগুলি ব্যতীত অন্য কোনও অক্ষর থাকবে না। লাইনগুলি পরিবর্তনশীল দৈর্ঘ্য হতে পারে এবং প্যাডড বা বিছিন্নভাবে ঠিক 79 প্রশস্ত করা হবে 79 উদাহরণ ইনপুট একটি গ্লাইডার বন্দুক:

                                  1
                                1 1
                      11      11            11
                     1   1    11            11
          11        1     1   11
          11        1   1 11    1 1
                    1     1       1
                     1   1
                      11









                                         11
                                         1
                                          111
                                            1

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

গেম বোর্ডটি 79x23 আকারে কঠোর কোডে রয়েছে। এটি একটি টরাস দিয়ে জড়িত: আপনি বোর্ডটি নীচে রেখে দিলে আপনি শীর্ষে পৌঁছে যাবেন; আপনি যদি ডানদিকে ছেড়ে যান তবে আপনি বাম দিকে শেষ হয়ে গেলেও একটি সারি নীচে সরিয়ে নিয়েছেন।

এখানে একটি বিকল্প সংস্করণ যা কোনও ইনপুট পড়েন না এবং এলোমেলো বোর্ড থেকে শুরু হয়:

$,=$/;$/=AX3AAAx76;$b=pack("(A)*",map{rand 3<1}0..1816)x6;{print unpack'(a79)23a0',$b;select$v,$v,$v,0.1;$b=pack'(A)*',unpack'((x7a/(x13)X4Ax!18)1817@0)4',pack'((a*)17xx!18)*',unpack"x1737(AA$/Ax$/AA$/@)2222",$b;redo}

এই কোডটি আমি বছর কয়েক আগে লিখেছি লাইফ পার্ল প্রোগ্রামের একটি আবদ্ধ খেলা থেকে উদ্ভূত হয়েছে । বোর্ডটিকে টরয়েডাল এবং গল্ফ কোড তৈরি করতে আমি এটিকে অনেক পরিবর্তন করেছি।

গেম অফ লাইফ পার্লে বাস্তবায়নের জন্য এটি সম্ভবত সবচেয়ে সংক্ষিপ্ত পদ্ধতি নয়, তবে এটি কম বোধগম্যতার মধ্যে একটি।

বোর্ডটি $bস্ট্রিং হিসাবে সংরক্ষণ করা হয় '1'এবং ' 'প্রতিটি কক্ষের জন্য একটি করে কেবল পুরো জিনিসটি কমপক্ষে তিনবার পুনরাবৃত্তি হয়। তৃতীয় আনপ্যাক কলটি প্রতিটি কক্ষের জন্য 17 টি মান সঞ্চার করে: এককভাবে একটি কক্ষে সেলের জন্য একটি এবং আটটি প্রতিবেশী কোষের জন্য দুটি থাকে এবং প্রতিটি মান হয় '1'বা একটি ফাঁকা স্ট্রিং। পরের পুনরাবৃত্তিতে সেলটি লাইভ হওয়া উচিত যদি '1'এই 17 টি মানের মধ্যে মানের সংখ্যা 5, 6 বা 7 হয় তবে তৃতীয় প্যাক কল এই 17 টি মানকে 18 টি অক্ষরের প্রশস্ত ক্ষেত্রের সাথে সংযুক্ত করে ডানদিকে নুল বাইট সহ প্যাড করবে । দ্বিতীয় আনপ্যাক কলটি এই জাতীয় 18 প্রশস্ত ক্ষেত্র গ্রহণ করে, 7 অক্ষরে অক্ষরে প্রেরণ করে, অবস্থান 17 থেকে স্থানটি প্যাক করে যদি এটি একটি হয়'1', বা অন্যথায় 4 অবস্থান থেকে অক্ষরটি আনপ্যাক করে। এই ফলাফলটি হ'ল পরবর্তী প্রজন্মের ঘরে থাকা উচিত ঠিক সেই মূল্য।

— b_jonas
সূত্র
2

পাইথন, 589 বাইট

মাউস বোতামগুলি: বাম - একটি ঘর রাখুন, ডান - একটি ঘর সরিয়ে ফেলুন, মাঝারি - শুরু করুন / স্টপ করুন।

টিনকিটার আমদানি থেকে *
আমদানি অনুলিপি
z- র = পরিসীমা
এফ = 50
টি = টাকা ()
এস = 9
f = [এফ * [0] আমি ইন' in'এফ'এফের জন্য]
গ = ক্যানভাস (টি, প্রস্থ = এস * এফ, উচ্চতা = এস * ফারেনহাইট)
c.pack ()
ডিফ পি (এক্স, ওয়াই, এ): এফ [ওয়াই] [এক্স] = এফ [ওয়াই] [এক্স] বা সি-ক্রিট_উয়াল (এক্স * এস, ওয়াই * এস, এক্স * এস + এস, ওয়াই * এস + এস) যদি অন্য কোন সিডিলেট (f [y] [এক্স]) থাকে
R = 1
ডিফ আর (ই): গ্লোবাল আর; আর = 1-আর
এক্সিকিউট ("সি.বাইন্ড ('<বাটন-% i>', লাম্বদা ই: পি (প্রাক্তন / এস, আই / এস,% i));" * 2% (1,1,3,0))
c.bind ( '<বাটন-2>', আর)
ডিফ এল ():
 T.after (99, এল)
 যদি r: ফিরে আসুন
 ছ = copy.deepcopy (চ)
 জে জে (এফ) এর জন্য:
	এক্স ইন জেড (এফ) এর জন্য:
	 এন = 8
	 জে জে (-1,2) এর জন্য:
		আমি জেড (-1,2) এর জন্য:
		 যদি আমি বা জে: এন- = জি না [[y + j)% এফ] [(x + i)% এফ]
	 যদি 1 <এন <4:
		যদি এন == 3 এবং জি না [ইয়] [এক্স]: পি (এক্স, ওয়াই, 1)
	 অন্য: P (X, Y, 0)
এল ()
T.mainloop ()

এবং এখানে এমন একটি সংস্করণ রয়েছে যেখানে আপনি অঙ্কন করতে মাউস টানতে পারেন। গ্রাফিক্স কিছুটা বেশি মনোরম।

from Tkinter import*
import copy
z=range
F=50
T=Tk()
S=9
f=[F*[0]for i in'7'*F]
c=Canvas(T,bg='white',width=S*F,height=S*F)
c.pack()
def p(x,y,a):f[y][x]=f[y][x]or c.create_rectangle(x*S,y*S,x*S+S,y*S+S,fill='gray')if a else c.delete(f[y][x])
r=1
def R(e):global r;r=1-r
exec("c.bind('<Button-%i>',lambda e:p(e.x/S,e.y/S,%i));c.bind('<B%i-Motion>',lambda e:p(e.x/S,e.y/S,%i));"*2%(1,1,1,1,3,0,3,0))
c.bind('<Button-2>',R)
def L():
 T.after(99,L)
 if r:return
 g=copy.deepcopy(f)
 for y in z(F):
  for x in z(F):
   n=8
   for j in z(-1,2):
    for i in z(-1,2):
     if i or j:n-=not g[(y+j)%F][(x+i)%F]
   if 1<n<4:
    if n==3and not g[y][x]:p(x,y,1)
   else:p(x,y,0)
L()
T.mainloop()
— ওলেহ প্রাইপিন
সূত্র
এটি জীবনের নিয়মের গেমটি সঠিকভাবে অনুসরণ করে না।
— স্টিভেন রাম্বালস্কি
1
@ স্টিভেন রাম্বালস্কি: ওহ সত্যি?
— ওলেহ প্রাইপিন
2
সত্যিই। আপনার দ্বিতীয় সংস্করণে ইন্ডেন্টেশন ত্রুটি রয়েছে। শুরু হওয়া বিভাগটি if 1<n<4:একই স্তরে ইন্টেন্ট করা উচিতfor j in z(-1,2):
— স্টিভেন রাম্বালস্কি
2

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

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

Golf.py

import time,itertools as w,sys;t,q=map(lambda x:list(x[:-1]),sys.stdin.readlines()),list(w.product(range(-1,2),range(-1,2)));del q[4];n=map(lambda x:x[:],t[:])
while time.sleep(0.1)==None:
 for j in range(1,len(t)-1):
  for i in range(1,len(t[j])-1):x=sum(map(lambda s:1 if t[j+s[0]][i+s[1]]in'@'else 0,q));f=t[j][i];n[j][i]='@'if(f=='@'and(x==3 or x==2))or(f==' 'and x==3)else' '
 t=map(lambda x:x[:],n[:]);print'\n'.join(list(map(lambda x:''.join(x),t)))

ইনপুট.টেক্সট (শেষ লাইনে অতিরিক্ত স্থান নোট করুন)

+----------------------------------------+
|                    @                   |
|                     @                  |
|                   @@@                  |
|                                        |
|                                        |
|                                        |
|                                        |
|                                        |
|                                        |
|                                        |
|                                        |
|                                        |
|                                        |
|                                        |
|                                        |
|                                        |
|                                        |
|                                        |
|                                        |
|                                        |
+----------------------------------------+

কিভাবে চালানো যায়

python Golf.py < input.txt
— Raffi
সূত্র
time.sleep(0.1)==None=> not time.sleep(.1), (f=='@'and(x==3 or x==2)) বা (চ == '' এবং x == 3) =>x==3or f=='@'and x==2
— ক্যালকুলেটরফালাইন
^, আপনি একটি ভুলে গেছেন, 1 if=> 1if।
— জাকারি
2

প্রসেসিং 270.261 249 বাইট

গ্রিডটি স্ক্রিনের 100 * 100 পিক্সেল, ইনপুট পিএনজি ছবির আকারে আসে

void setup(){image(loadImage("g.png"),0,0);}void draw(){loadPixels();int n,i=0,j,l=10000;int[]a=new int[l],p=pixels;for(;i<l;a[i]=n==5?-1<<24:n==6?p[i]:-1,i++)for(j=n=0;j<9;j++)n+=j!=4?p[(i+l-1+j%3+100*(j/3-1))%l]&1:0;arrayCopy(a,p);updatePixels();}

Ungolfed 

void setup() {
  image(loadImage("g.png"), 0, 0);
}
void draw() {
  loadPixels();
  int c=100, i=0, n, l=c*c, b=color(0);
  int[]a=new int[l], p=pixels;
  for (; i<l; i++) {
    n=p[(i+l-101)%l]&1;
    n+=p[(i+l-100)%l]&1;
    n+=p[(i+l-99)%l]&1;
    n+=p[(i+l-1)%l]&1;
    n+=p[(i+1)%l]&1;
    n+=p[(i+99)%l]&1;
    n+=p[(i+100)%l]&1;
    n+=p[(i+101)%l]&1;
    a[i]=n==5?b:p[i]==b&&n==6?b:-1;
  }
  arrayCopy(a, pixels, l);
  updatePixels();
}

স্ক্রিনশট

— PrincePolka
সূত্র
2

লুয়া + লভ / লাভ 2 ডি , 653 বাইট

l=love f=math.floor t={}s=25 w=20 S=1 for i=1,w do t[i]={}for j=1,w do t[i][j]=0 end end e=0 F=function(f)loadstring("for i=1,#t do for j=1,#t[i]do "..f.." end end")()end function l.update(d)if S>0 then return end e=e+d if e>.2 then e=0 F("c=0 for a=-1,1 do for b=-1,1 do if not(a==0 and b==0)then c=c+(t[((i+a-1)%w)+1][((j+b-1)%w)+1]>0 and 1 or 0)end end end g=t[i][j]t[i][j]=(c==3 or(c==2 and g==1))and(g==1 and 5 or-1)or(g==1 and 4 or 0)")F("t[i][j]=t[i][j]%2")end end function l.draw()F("l.graphics.rectangle(t[i][j]==1 and'fill'or'line',i*s,j*s,s,s)")end function l.mousepressed(x,y)S=0 o,p=f(x/s),f(y/s)if t[o]and t[o][p]then t[o][p]=1 S=1 end end

বা স্পেস আউট:

l=love
f=math.floor
t={}s=25
w=20
S=1
for i=1,w do
    t[i]={}
    for j=1,w do
        t[i][j]=0
    end
end
e=0
F=function(f)
    loadstring("for i=1,#t do for j=1,#t[i] do  "..f.." end end")()
end
function l.update(d)
    if S>0 then
        return
    end
    e=e+d
    if e>.2 then
        e=0
        F([[
        c=0
        for a=-1,1 do
            for b=-1,1 do
                if not(a==0 and b==0)then
                    c=c+(t[((i+a-1)%w)+1][((j+b-1)%w)+1]>0 and 1 or 0)
                end
            end
        end
        g=t[i][j]
        t[i][j]=(c==3 or(c==2 and g==1))and(g==1 and 5 or-1) or (g==1 and 4 or 0)]])
        F("t[i][j]=t[i][j]%2")
    end
end
function l.draw()
    F("l.graphics.rectangle(t[i][j]==1 and'fill'or'line',i*s,j*s,s,s)") end
function l.mousepressed(x,y)
    S=0
    o,p=f(x/s),f(y/s)
    if t[o]and t[o][p] then
        t[o][p]=1
        S=1
    end
end

জীবন্ত কক্ষগুলি যুক্ত করতে মাঠে ক্লিক করুন। এটি চালানোর জন্য মাঠের বাইরে ক্লিক করুন।

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

এখানে চিত্র বর্ণনা লিখুন

— Sheepolution
সূত্র
1

পুনশ্চ 529 515

রোসেটা কোড থেকে উদাহরণ দিয়ে শুরু হয়েছিল । ফাইল নাম আর্গুমেন্ট ( gs -- gol.ps pulsar), 20 * 20 বাইনারি সংখ্যা (স্থান দ্বারা পৃথক) সম্বলিত ফাইলটি দিয়ে দাওয়াত করুন । অসীম লুপ: বোর্ড আঁকুন, প্রবেশের জন্য অপেক্ষা করুন, পরবর্তী প্রজন্মের গণনা করুন।

[/f ARGUMENTS 0 get(r)file/n 20>>begin[/m
n 1 sub/b[n{[n{f token pop}repeat]}repeat]/c 400
n div/F{dup 0 lt{n add}if dup n ge{n sub}if}>>begin{0
1 m{dup 0 1 m{2 copy b exch get exch get 1 xor setgray
c mul exch c mul c c rectfill dup}for pop pop}for
showpage/b[0 1 m{/x exch def[0 1 m{/y exch def 0
y 1 sub 1 y 1 add{F dup x 1 sub 1 x
1 add{F b exch get exch get 3 2 roll add exch
dup}for pop pop}for b x get y get sub b x get y get
0 eq{3 eq{1}{0}ifelse}{dup 2 eq exch 3 eq
or{1}{0}ifelse}ifelse}for]}for]def}loop

কয়েকটি স্ট্যাক মন্তব্যে (কেবলমাত্র আমার প্রয়োজনের সাথে) ব্যবধানযুক্ত।

[
/f ARGUMENTS 0 get(r)file
/n 20
/sz 400
%/r{rand 2147483647 div}
>>begin
[
/m n 1 sub
/b[
%n{[n{r .15 le{1}{0}ifelse}repeat]}repeat
 n{[n{f token pop}repeat]}repeat
]
/c sz n div
/F{dup 0 lt{n add}if dup n ge{n sub}if}
>>begin
{
    0 1 m{dup % y y
    0 1 m{ % y y x
        2 copy b exch get exch get 1 xor setgray
        c mul exch c mul c c rectfill
        dup 
    }for pop pop}for
    pstack
    showpage
    /b[0 1 m{/x exch def
      [0 1 m{/y exch def
          0   
          y 1 sub 1 y 1 add{F dup %s y y
          x 1 sub 1 x 1 add{F %s y y x
              b exch get exch get %s y bxy
              3 2 roll add exch %s+bxy y
              dup %s y y
          }for pop pop}for
          b x get y get sub
          b x get y get
          0 eq{3 eq{1}{0}ifelse}{dup 2 eq exch 3 eq or{1}{0}ifelse}ifelse
      }for]
      }for]def
}loop

পালসার ডেটা ফাইল:

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 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 1 1 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 0 1 0 0 0 0 1 0 1 0 0 0 0 1 0 0 0 0
0 0 0 1 0 0 0 0 1 0 1 0 0 0 0 1 0 0 0 0
0 0 0 1 0 0 0 0 1 0 1 0 0 0 0 1 0 0 0 0
0 0 0 0 0 1 1 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 0 0 0 1 1 1 0 0 0 1 1 1 0 0 0 0 0 0
0 0 0 1 0 0 0 0 1 0 1 0 0 0 0 1 0 0 0 0
0 0 0 1 0 0 0 0 1 0 1 0 0 0 0 1 0 0 0 0
0 0 0 1 0 0 0 0 1 0 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 0 0
0 0 0 0 0 1 1 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 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 0 0 0 0 0 0 0 0 0 0 0
— লুজার ড্রাগ
সূত্র
1

জাভাস্ক্রিপ্ট 676

দুঃখিত গ্রিফিন, আমি কেবল আপনার কোডটি দেখতে পারি না এবং এটি আবার কিছুটাও লিখতে পারি না ... দুটি চরিত্র শেভ করতে হয়েছিল তবে এটি মূল্যহীন!

b=[];r=c=s=20;U=document;onload=function(){for(z=E=0;z<c;++z)for(b.push(t=[]),j=0;j<r;j++)with(U.body.appendChild(U.createElement("button")))t.push(0),id=z+"_"+j,style.position="absolute",style.left=s*j+"px",style.top=s*z+"px",onclick=a}; ondblclick=function(){A=E=E?clearInterval(A):setInterval(function(){Q=[];for(z=0;z<c;++z){R=[];for(j=0;j<r;)W=(c+z-1)%c,X=(c+z+1)%c,Y=(r+j-1)%r,Z=(r+j+1)%r,n=b[W][Y]+b[z][Y]+b[X][Y]+b[W][j]+b[X][j]+b[W][Z]+b[z][Z]+b[X][Z],R.push(b[z][j++]?4>n&&1<n:3==n);Q.push(R)}b=Q.slice();d()})};function a(e){E?0:P=e.target.id.split("_");b[P[0]][P[1]]^=1;d()}function d(){for(z=0;z<c;++z)for(j=0;j<r;)U.getElementById(z+"_"+j).innerHTML=b[z][j++]-0}

তবে তারা যেমন বলেছে, অনুমতি চেয়ে ক্ষমা চাওয়া আরও সহজ ...;)

— WallyWest
সূত্র
1

অক্টাভা (153)

শর্টেস্ট গেম অফ লাইফ- এ ডেনডেনডোর মতলব-এর মতোই , তবে চিত্রাবলীতে চিত্রাবলীতে পরিবর্তন আনতে হয়েছিল:

b=uint8(rand(20)<0.2)
s=@(m)imfilter(m,[1 1 1;1 0 1;1 1 1],'circular')
p=@(m,n)uint8((n==3)|(m&(n==2)))
while 1
imagesc(b)
drawnow
b=p(b,s(b))
end
— মার্টিন নভি
সূত্র
1

পাইথন 2: 334 বাইট

মাত্র 6 বছর দেরী।

import time
s='';s=map(list,iter(raw_input,s));k=len(s);l=(-1,0,1);n=int;z=range
while 1:
 r=[[0]*k for i in z(k)]
 for i in z(k*k):
  a,b=i//k,i%k
  m,g=sum([n(s[(a+c)%k][(b+d)%k])for c in l for d in l if c|d]),n(s[a][b])
  r[a][b]=n((m==2)&g or m==3)
  print'*'if r[a][b]else' ',
  if b-k+1==0:print
 s=r;time.sleep(.2);print"\033c"

আপনি এটি চালাতে পারেন:

python gol.py
0000000
0001000
0000100
0011100
0000000
0000000
0000000

যেখানে 0 এবং 1 গুলি মৃত এবং লাইভ কোষকে উপস্থাপন করে, শেষে একটি অতিরিক্ত নতুন লাইন কার্যকর করা শুরু করে।

গ্রিডগুলি অবশ্যই বর্গাকার হতে হবে।

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

এটি আরও 100 বাইট, তাই এখানে।

— Backerupper
সূত্র
0

পিএইচপি, 201 বাইট (পরীক্ষিত নয়)

for($s=file(f);print"\n";$s=$t)foreach($s as$y=>$r)for($x=-print"
";"
"<$c=$s[$y][++$x];print$t[$y][$x]=" X"[$n<4&$n>2-$a])for($n=-$a=$c>A,$i=$x-!!$x-1;$i++<=$x;)for($k=$y-2;$k++<=$y;)$n+=$s[$k][$i]>A;

সাথে চালাও -nr।

ভাঙ্গন

for($s=file(f);                         # import input from file "f"
    print"\n";                              # infinite loop: 1. print newline
    $s=$t)                                  # 3. copy target to source, next iteration
    foreach($s as$y=>$r)                    # 2. loop through lines
        for($x=-print"\n";"\n"<$c=$s[$y][++$x]; # print newline, loop $x/$c through line characters (before line break)
            print                                   # 5. print new cell
                $t[$y][$x]=" X"[$n>2-$a&$n<4])      # 4. new cell is alive if neighbour count<4 and >2 (>1 if alive)
            for($n=-                                # 2. init neighbour count: exclude self
                $a=$c>A,                            # 1. $a=cell is alife
                $i=$x-!!$x-1;$i++<=$x;)             # 3. loop $i from one left to one right of current position
                for($k=$y-2;$k++<=$y;)                  # loop $k from one above to one below current position
                    $n+=$s[$k][$i]>A;                       # increase neighbor count if neighbour is alife
— তিতাস
সূত্র
আমাদের সাইট ব্যবহার করে, আপনি স্বীকার করেছেন যে আপনি আমাদের কুকি নীতি এবং গোপনীয়তা নীতিটি পড়েছেন এবং বুঝতে পেরেছেন ।
Licensed under cc by-sa 3.0 with attribution required.