59

जीवन का कॉनवे गेम सेलुलर स्वचालन का उत्कृष्ट उदाहरण है। कोशिकाएँ एक वर्गाकार ग्रिड बनाती हैं और प्रत्येक में दो अवस्थाएँ होती हैं: जीवित या मृत। प्रत्येक मोड़ पर, प्रत्येक सेल अपने राज्य और उसके आठ पड़ोसियों के अनुसार एक साथ अपडेट करता है:

एक जीवित कोशिका जीवित रहती है अगर उसके पास दो या तीन जीवित पड़ोसी हों
एक मृत कोशिका जीवित हो जाती है अगर उसके पास तीन जीवित पड़ोसी हों

आपका मिशन, क्या आपको इसे स्वीकार करना चाहिए, अपनी पसंदीदा भाषा में सबसे कम गेम ऑफ लाइफ कार्यान्वयन को कोड करना है।

नियम:

ग्रिड कम से कम 20x20 का होना चाहिए
ग्रिड को चारों ओर लपेटना चाहिए (इसलिए ग्रिड टोरस की सतह की तरह है)
आपके कार्यान्वयन को उपयोगकर्ता को अपने शुरुआती पैटर्न को इनपुट करने की अनुमति देनी चाहिए
GoL थोड़ा व्यर्थ है अगर आप यह नहीं देख सकते कि क्या हो रहा है, तो आटोमेटन का विजुअल आउटपुट होना चाहिए, प्रत्येक मोड़ के परिणाम को लंबे समय तक देखा जाना चाहिए!

code-golf game-of-life cellular-automata

— दौड़ के लिये कभी भी न उतारा गया घोड़ा
स्रोत

8

पहले स्टैक ओवरफ्लो पर: कोड गोल्फ: कॉनवे का गेम ऑफ लाइफ , और टिप्पणियों में एपीएल कार्यान्वयन लिंक को देखना सुनिश्चित करें।

— dmckee

1

आह, मैंने वह नहीं देखा। लेकिन यह थोड़ा अलग है (मुझे एक साथ चुनौती देने वाले काम को हटाने से बचाओ?

— ग्रिफिन

6

यह कोई समस्या नहीं है। स्टैक ओवरफ्लो पर पहले से ही कई पहेलियां यहां भी की गई हैं, लेकिन लोग आपको बताएंगे कि मैं इसी तरह की चुनौतियों से जुड़ने के बारे में जुनूनी हूं।

— dmckee

@Griffin: आप उन सभी ;को }s से पहले हटा सकते हैं । इसके अलावा varसमय पर समाप्त किया जा सकता है (यदि यह आपके कोड को नहीं तोड़ता है)। और एक-लाइन forएस, ifएस आदि के लिए, आप { }पूरी तरह से समाप्त कर सकते हैं for(...) for(...) dosomething():।

— pimvdb

@pimvdb, चीयर्स, मैंने अभी तक इसे पूरी तरह से गोल्फ नहीं बनाया है, समय नहीं हुआ है। केवल यह दिखाना चाहता था कि मेरे पास एक चुनौती को निर्धारित करने के बजाय एक रास्ता भी था। जल्द ही इसे अधिकतम करने के लिए गोल्फ होगा।

— ग्रिफिन

27

जावास्क्रिप्ट के साथ एचटीएमएल 5 कैनवस, 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 वर्ण लंबा है क्योंकि jsFiddle कैनवास से पहले एक पाठ नोड डालता है (क्यों?) और इस तरह कैनवास अब पहला बच्चा नहीं है।

1 संपादित करें: बहुत सारे अनुकूलन और पुनर्गठन।

संपादित करें 2: कई छोटे बदलाव।

संपादन 3: पूर्ण स्क्रिप्ट ब्लॉक और छोटे बदलावों को रेखांकित करता है।

— हावर्ड
स्रोत

अच्छा है, लेकिन अंतराल 1धीमी गति से कदम रखने के बजाय इसे जितना जल्दी हो सके उतना देरी से बदल दें । यदि आप ड्राइंग (प्रत्येक वर्ग पर क्लिक करने के बजाय) लागू करना चाहते हैं, तो आप माउस की स्थिति को निकटतम ब्लॉक पर गोल कर सकते हैं और उस बिंदु पर आयत भर सकते हैं। अधिक वर्ण लेकिन अधिक अंक।

— ग्रिफिन

आप के new Array('#FFF','#800')साथ बदल सकते हैं ['#FFF','#800']।

— लॉजैकर

हालांकि यह कहना कि ड्राइंग के बारे में, मेरी सुपर-गोल्फिंग ड्राइंग की अनुमति नहीं देती है और पाप के रूप में बदसूरत है। Haha। आप अपने दो रंगों को sसरणी में सेट कर सकते हैं tanऔर redचूंकि वे दो रंग हैं जो सबसे कम प्रतिनिधित्व वाले हैं - आपको दो वर्ण बचाता है। इसके अलावा, यदि संभव हो, jतो अंतराल में शाब्दिक संस्करण डालें । मुझे यकीन है कि बाहर निचोड़ने के लिए बहुत अधिक है।

— ग्रिफिन

@Griffin और Lowjacker: बहुत-बहुत धन्यवाद। मुझे यह भी पूरा यकीन है कि आप इसे बहुत अधिक गोल्फ कर सकते हैं (और पहले से ही कुछ विचार हैं)। दुर्भाग्य से मुझे ऐसा करने का समय नहीं मिला। एक बेहतर गोल्फ वाला संस्करण कल का अनुसरण करेगा - मुझे उम्मीद है ...

— हावर्ड

2

आप html और बॉडी टैग हटा सकते हैं। यह वही कार्य करेगा

— अरोडेबाग

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 आदि है।

इसे 21 पंक्तियों के साथ एक टर्मिनल में चलाएं और यह बहुत सुंदर लग रहा है।

— कीथ रान्डेल
स्रोत

1

यह पूरी तरह से जीतना चाहिए था। मुझे लगता है कि 'इनपुट में आसानी' का वजन काफी अधिक था।

— प्रिमो

@primo मैं यहाँ तक जाऊँगा कि सुझाव देने के लिए एमएमए की एक अलग प्रतियोगिता होनी चाहिए।

— लूसर

2

तो क्या ये Life of Py है?

— क्रिस्टोफर विर्ट

आप हमेशा एक और चार बचा सकते हैं ... 2-(p in P)== 2-({p}<P)। लेकिन फिर आपको अपने इनपुट को {8,29,47,48,49}:)

— JBernardo

21

TI-BASIC, 96 बाइट्स (गैर-प्रतिस्पर्धी प्रविष्टि के लिए 87)

अपने TI-84 श्रृंखला रेखांकन कैलकुलेटर (!) के लिए। यह काफी एक चुनौती थी कोई आसान तरीका एक बफ़र ग्राफिक्स दिनचर्या (निश्चित रूप से कुछ भी नहीं है में बनाया गया) लिखना है वहाँ क्योंकि, और ग्राफ स्क्रीन केवल चार प्रासंगिक ग्राफिक्स आदेश दिया गया है: Pxl-On(), Pxl-Off(), Pxl-Change(), और pxl-Test()।

स्क्रीन पर प्रत्येक सुलभ पिक्सेल का उपयोग करता है, और सही ढंग से लपेटता है। प्रत्येक सेल एक पिक्सेल है, और स्क्रीन के दाईं ओर क्षैतिज रूप से लाइन द्वारा प्रोग्राम अपडेट लाइन है। क्योंकि कैलकुलेटर में केवल 15MHz z80 प्रोसेसर है और BASIC एक धीमी व्याख्या वाली भाषा है, कोड को केवल एक फ्रेम में लगभग पांच मिनट मिलते हैं।

उपयोगकर्ता इनपुट आसान है: प्रोग्राम चलाने से पहले, ग्राफ स्क्रीन पर अपना आकार खींचने के लिए पेन टूल का उपयोग करें।

कैलकुलेटर फोरम ओम्निमगा में एक कोड गोल्फ प्रतियोगिता में मेरी प्रविष्टि से अनुकूलित ।

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

यह संस्करण संभवतया सबसे अधिक गोल्फ कोड है जिसे मैंने कभी लिखा है, और इसमें कुछ सही मायने में आपत्तिजनक अनुकूलन शामिल हैं:

मैं एक ध्वज के रूप में घड़ी की स्थिति का उपयोग करता हूं। कार्यक्रम की शुरुआत में, दिनांक / समय घड़ी सक्षम होती है, और मैं यह निर्धारित करने के लिए वैश्विक isClockOn ध्वज के मूल्य का उपयोग करता हूं कि क्या यह पहला चलना है। पहला फ्रेम तैयार होने के बाद, मैं घड़ी को बंद कर देता हूं। कम से कम अन्य विधि पर एक बाइट बचाता है और स्पष्ट पद्धति पर लगभग चार।
मैं आधार -7 संख्या के 63-तत्व सरणी में अद्यतन किए जा रहे तीन कॉलम के राज्यों को संग्रहीत करता हूं। 49 का स्थान स्तंभ को दाईं ओर रखता है, 7 का स्थान मध्य स्तंभ रखता है, और इकाइयाँ स्थान बाएं स्तंभ को रखती है - 1 जीवित कोशिका के लिए और 0 मृत कोशिका के लिए। फिर मैं जीवित पड़ोसी कोशिकाओं की कुल संख्या को खोजने के लिए संशोधित किए जा रहे सेल के चारों ओर तीन संख्याओं के शेष मॉड 6 को लेता हूं (यह 9 चाल से विभाजन की तरह है - आधार 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

गणितज्ञ - ३३३

विशेषताएं:

इंटरएक्टिव इंटरफ़ेस: अपने पैटर्न बनाने के लिए कोशिकाओं पर क्लिक करें
अच्छा ग्रिड
बटन: रन, PAUSE, स्पष्ट

कोड नीचे है।

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 उदाहरण ऊपर दिए गए कोड का एक अधिक विस्तृत संस्करण (लाइव फूरियर विश्लेषण, बेहतर इंटरफ़ेस) है। उदाहरण आपके ब्राउज़र में मुफ्त प्लगइन डाउनलोड के बाद सही चलना चाहिए।

— विटालि कौरोव
स्रोत

2

+1, जाने के लिए अच्छा है। हाँ, इस साइट के साथ समस्या है, पुराने सवाल हैं जो एक को याद करते हैं।

— ग्रिफिन

@Griffin इसे बिल्कुल भी नोटिस करने के लिए धन्यवाद;)

— विटाली कौरोव

15

C 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
स्रोत

मुझे इस पर टिप्पणी करने वाला संस्करण देखना अच्छा लगेगा!

— लूसर ड्रॉग

1

यकीन है, अगर मुझे याद है कि मैं क्या सोच रहा था ... = p

— Kaslai

1

@luserdroog यहां यह pastebin.com/BrX6wgUj

— Kaslai

यह सिर्फ कमाल है।

— रेयरेंग -

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

रूबी 1.9 + एसडीएल (380 325 314)

संपादित करें : 314 वर्ण, और पहली बग पर जीवित दिखाई देने वाली अतिरिक्त कोशिकाओं के साथ एक बग को ठीक किया। ग्रिड आकार को 56 तक ले जाया गया क्योंकि रंग दिनचर्या केवल सबसे कम 8 बिट्स पर दिखती है।

संपादित करें : 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}

इस तरह दिखता है:

कार्रवाई में एप्लिकेशन का स्क्रीनशॉट

मजेदार चुनौती! मैं ऐसे किसी भी सुधार का स्वागत करता हूं जिसे कोई भी देख सकता है।

— पॉल प्रेस्टिज
स्रोत

अच्छा प्रयास करें लेकिन मैं सीधे देख सकता हूं कि आप गलत हो गए हैं। आपके पास GoL जैसा कोई पैटर्न नहीं हो सकता है। नियमों का एक और पढ़ें: en.wikipedia.org/wiki/Conway%27s_Game_of_Life#Rules

— ग्रिफिन

@Griffin मुझे लगता है कि स्क्रीनशॉट कुछ कोशिकाओं को मैन्युअल रूप से रोकने और टॉगल करने के बाद लिया गया था - मैं फिर से नियमों की जांच करूंगा। धन्यवाद!

— पॉल प्रेस्टिज

7

@ Giffin बीज पैटर्न किसी भी संभावित विन्यास में नहीं हो सकता?

— 4

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
    }
}

यहाँ कोड का बड़ा हिस्सा स्विंग GUI सामान है। खेल ही उस 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 पात्रों के लिए अग्रणी।

— अज्ञात अज्ञात

@user अज्ञात धन्यवाद। मैंने खुद को कुछ सुधार पाया - अब 1063 तक।

— गारेथ

लानत है तुम व्यस्त थे। कीप आईटी उप! जब कुछ और लोग उन्हें पोस्ट करेंगे तो मैं जवाबों का परीक्षण करूंगा।

— ग्रिफिन

7

शुद्ध बैश, 244 बाइट्स

एक toroidally-लपेटा 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 बाइट्स में गेम ऑफ लाइफ इंजन है।

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 बना सकता था, लेकिन यह बहुत ही कम लग रहा था)।

गोल्फ समझौता

आप केवल माउस से कोशिकाओं को चालू कर सकते हैं, बंद नहीं, इसलिए यदि आप कोई गलती करते हैं तो आपको प्रोग्राम को पुनरारंभ करना होगा।
कोई ग्रिड लाइनें नहीं हैं, लेकिन इससे प्लेबिलिटी बहुत अधिक नहीं होती है।
अपडेट की गति सीपीयू की गति के समानुपाती होती है, इसलिए बहुत तेज कंप्यूटर पर यह सिर्फ एक धब्बा होगा।
जीवित कोशिकाएं लाल होती हैं क्योंकि "काला" 2 अधिक वर्णों का उपयोग करता है।
कोशिकाओं की लघुता और तथ्य यह है कि वे सभी फॉर्म स्पेस का उपयोग नहीं करते हैं, चरित्र-बचत समझौता भी हैं।

— इग्बी लार्गेमैन
स्रोत

5

GW-BASIC, 1086 1035 बाइट्स (टोकन)

टोकन रूप में, यह 1035 बाइट्स है। (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; ये सेटिंग्स Qemu और (धीमी) dosbox के साथ काम करती हैं)। एक तारांकन *एक जीवाणु है।

यह दो-पास का काम करता है: पहला, जन्मस्थानों को चिह्नित किया जाता है +और मृत्यु अपने लक्ष्यों के साथ चिह्नित करती है .। दूसरे पास में, +और क्रमशः के .साथ *और बदल दिया जाता है।

TIMERबात यह प्रत्येक दौर के बाद आधे सेकंड के लिए प्रतीक्षा करने के लिए है, मामले में अपने QEMU मेजबान बहुत तेजी से ☺ है

मैं यहाँ कम से कम जीत की कीमत की उम्मीद नहीं कर रहा हूँ, लेकिन एक ठंडक के लिए, विशेष रूप से प्रारंभिक बोर्ड सेटअप पर विचार कर रहा हूँ। मुझे एक संस्करण भी मिला है जहाँ खेल इंजन को असेंबली कोड द्वारा बदल दिया गया था, यदि आप रुचि रखते हैं ...

— mirabilos
स्रोत

गैर-गोल्फ संस्करण पर आपने 1 से अपने लेबल को बढ़ाने पर विचार करते हुए, क्या गोल्फ संस्करण पर भी ऐसा करना संभव है? (यानी, 1, 2, 3, आदि) या लाइन नंबर गिनती नहीं करते हैं?

— ज़ाचारि

लाइन नंबर, जब टोकेलाइज किया जाता है, शब्द (16 बिट) के रूप में गिना जाता है, अगर मैं पूरी तरह से गलत नहीं हूं

— mirabilos

ठीक है, फिर लगता है कि मुझे कुछ अन्य मूल बोली के बारे में सोचना चाहिए।

— ज़ाचारि

@ Zacharý “GW-BASIC टोकन प्रोग्राम फॉर्मेट” पर क्लिक करें, फिर “प्रोग्राम फॉर्मेट” पर यहाँ देखें कि, वास्तव में, लाइन नंबर लगातार दो बाइट्स हैं, और टोकन फॉर्मेट में अधिक जानकारी के लिए।

— mirabilos

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

गणितज्ञ ठीक है, लेकिन जैसा कि नियम बताता है कि कार्यक्रम को उपयोगकर्ता को अपने स्वयं के पैटर्न को इनपुट करने की अनुमति देनी चाहिए। यह नियम जानबूझकर है क्योंकि कुछ भाषाएं इस तरह के छोटे कार्यान्वयन की अनुमति देती हैं, लेकिन कोई उपयोगकर्ता सहभागिता नहीं है। यकीन है कि आप अपने खुद के सरणी वहाँ रख सकते हैं, लेकिन यह जीतने वाला नहीं है।

— ग्रिफिन

Mathematica में "इनपुट" ज्यादातर नोटबुक इंटरफ़ेस के माध्यम से है, इसलिए मुझे नहीं लगता कि "उपयोगकर्ता इंटरैक्शन" वास्तव में संभव है। आप बस रैंडमइन्तेयर तर्क को सेल्युलर आटोमैटन फंक्शन में बदलें जो आप चाहते हैं, और कोड का पुनर्मूल्यांकन करें।

— जेरेमीकुन

3

उपयोगकर्ता सहभागिता संभव है। सबसे सरल तरीका है जिसके बारे में मैं अभी सोच सकता हूं कि यह एक बटन है। इसे एक आदमी दे दो।

— ग्रिफिन

4

जावा (ओपनजेडके 8) - 400 388 367 बाइट्स

दूसरा (शायद) अंतिम संपादन: इन (imo) सोने की खानों को खोजने के बाद एक अतिरिक्त 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);}}

इसे ऑनलाइन आज़माएं!

(मूल पोस्ट यहां से शुरू होती है।)

मैंने वास्तव में एक पल के लिए सोचा था कि मैं कम से कम जावा लॉल के अपने (यकीनन सीमित) ज्ञान के साथ सबसे अच्छे पायथन उत्तर को चुनौती देने में सक्षम हो जाऊंगा ... यह एक चुनौती थी जो मुझे पार्टी में शामिल होने के बावजूद मजा आया (शायद पार्टी में शामिल होने के बावजूद थोड़ी देर ...)

वहाँ वास्तव में यह करने के लिए बहुत कुछ नहीं है - मूल स्पष्टीकरण निम्नानुसार है (ungolfed):

/*
 * 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
स्रोत

अद्भुत पहली पोस्ट, PPCG में आपका स्वागत है!

— ज़ाचारि

धन्यवाद, मैं निश्चित रूप से इनमें से अधिक करने जा रहा हूं - वे मजेदार हैं :)

— NotBaal

हमसे जुड़ें, हमारे पास डेनिस है। इसके अलावा, यह एक पूर्ण कार्यक्रम नहीं है और न ही एक फ़ंक्शन है, जिसे इसे IIRC होना चाहिए।

— Zacharý

ओह राइट 'प्रोग्राम' भाग को भूल गए: पी एडिटिंग जो थोड़े में है।

— NotBaal

यह सिर्फ एक फंक्शन भी हो सकता है।

— Zacharý

4

स्टैंसिल , 6 बाइट्स

नहीं मेरी पसंदीदा भाषा है, लेकिन यह है कम ...

4 कोड बाइट्स के अलावा nlist ∊और Torus के झंडे।

3∊me

इसे ऑनलाइन आज़माएं!

है ...
3 3
∊ के एक सदस्य मीटर स्वयं या साथ oore-पड़ोस गिनती मूर ई स्वयं बिना -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

जे, ४५

मैंने सोचा कि मैं जम्मू की कोशिश करूँगा। यह अभी तक अच्छी तरह से गोल्फ नहीं है, लेकिन मैं इसे जल्द ही एक और कोशिश दूंगा।

(]+.&(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

Boardsize हार्डकोड किया गया है, लेकिन कुछ भी हो सकता है
चहुंओर लपेटता
उपयोगकर्ता इनपुट के लिए एक और मैट्रिक्स को हार्डकोड करके या वैरिएबल एडिटर का उपयोग करके इनलेट बोर्ड को बदल सकता है। सुंदर नहीं है, लेकिन यह काम करता है
यदि ग्राफ़िकल आउटपुट को छोड़ दिया जाए तो 20 वर्णों को बचाया जा सकता है, बोर्ड को अभी भी प्रत्येक पुनरावृत्ति पर पाठ के रूप में मुद्रित किया जाएगा। हर मिलिसेकंड को बदलने वाली एक-पिक्सेल कोशिकाएं वैसे भी बहुत उपयोगी नहीं होती हैं

— DenDenDo
स्रोत

R2014a में काम करता है, बस परीक्षण किया गया

— मास्टरएक्स 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 चौड़ी तक गद्देदार या छंटनी की जाएंगी। उदाहरण इनपुट एक ग्लाइडर बंदूक है:

                                  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 वर्णों के विस्तृत क्षेत्र में सम्‍मिलित करता है, जो संरेखित छोड़ दिया गया है और दाएं तरफ nul बाइट्स के साथ गद्देदार है। । दूसरा अनपैक कॉल इस तरह के 18 व्यापक क्षेत्र लेता है, स्थिति 7 पर चरित्र को भेजता है, यदि कोई हो'1', या स्थिति 4 से चरित्र को अनपैक करें अन्यथा। यह परिणाम वैसा ही है जैसा अगली पीढ़ी में सेल का होना चाहिए।

— b_jonas
स्रोत

2

पायथन, 589 बाइट्स

माउस बटन: बायां - एक सेल, दाएं - एक सेल को हटा दें, मध्य - प्रारंभ / रोक।

Tkinter आयात से *
आयात प्रति
z = रेंज
एफ = 50
टी = टी ()
एस = 9
i = 7 '* F] के लिए f = [F * [0]
c = कैनवास (टी, चौड़ाई = एस * एफ, ऊंचाई = एस * एफ)
c.pack ()
def p (x, y, a): f [y] [x] = f [y] [x] या c.create_oval (x * S, y * S, x * S + S, y * S + S) अगर कोई और c.delete (f [y] [x])
r = 1
डी आर (ई): वैश्विक आर; आर = 1-आर
निष्पादन ("c.bind ('<बटन-% i>', लंबो ई: पी (एक्स / एस, आई / एस,% आई));" * 2% (1,1,3,0))
c.bind ( '<बटन -2>', आर)
डी एल ():
 T.after (99, एल)
 अगर आर: वापसी
 जी = copy.deepcopy (च)
 y में z (F) के लिए:
	x in z (F) के लिए:
	 एन = 8
	 जे फॉर जेड (-1,2) में:
		i in z (-1,2) के लिए:
		 अगर i या j: n- = not g [(y + j)% F] [(x + i)% F]
	 यदि 1 <n <4:
		अगर n == 3and नहीं g [y] [x]: p (x, y, 1)
	 बाकी: पी (एक्स, वाई, 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

@StevenRumbalski: ओह सच में?

— ओलेह प्रिनपिन

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)))

Input.txt (अंतिम पंक्ति पर अतिरिक्त स्थान पर ध्यान दें)

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

कैसे चलाना है

python Golf.py < input.txt

— Raffi
स्रोत

time.sleep(0.1)==None=> not time.sleep(.1), (f=='@'and(x==3 or x==2)) या (f == '' और x == 3) =>x==3or f=='@'and x==2

— कैलक्यूलेटरफैनलाइन

^, आप एक भूल गए, 1 if=> 1if।

— जचारि

2

प्रसंस्करण 270,261 249 बाइट्स

ग्रिड 100 * 100 पिक्सेल की स्क्रीन है, इनपुट png चित्र के रूप में आता है

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

Lua + LuaVE / Love2D , 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

— luser droog
स्रोत

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

जहां 0s और 1s मृत और जीवित कोशिकाओं का प्रतिनिधित्व करते हैं, अंत में एक अतिरिक्त न्यूलाइन निष्पादन शुरू करता है।

ग्रिड चौकोर होना चाहिए।

यह सबसे छोटा अजगर एक से चलाने के लिए आसान है, किसी भी आकार के ग्रिड का समर्थन करता है, और चलाने पर सुंदर दिखता है।

यह भी 100 बाइट्स अधिक है, इसलिए ऐसा है।

— Backerupper
स्रोत

0

PHP, 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

— टाइटस
स्रोत

जीवन का सबसे छोटा खेल

जावास्क्रिप्ट के साथ एचटीएमएल 5 कैनवस, 940 639 586 519 अक्षर

पायथन, 219 वर्ण

TI-BASIC, 96 बाइट्स (गैर-प्रतिस्पर्धी प्रविष्टि के लिए 87)

ओमनिमागा संस्करण (87 बाइट्स)

C 1063 अक्षर

जे (39 अक्षर)

गणितज्ञ, 123 वर्ण

रूबी 1.9 + एसडीएल (380 325 314)

स्काला, 1181 1158 1128 1063 1018 1003 999 992 987 वर्ण

शुद्ध बैश, 244 बाइट्स

जावास्क्रिप्ट, 130

GW-BASIC, 1086 1035 बाइट्स (टोकन)

गणितज्ञ, 115 बाइट्स

जावा (ओपनजेडके 8) - 400 388 367 बाइट्स

स्टैंसिल , 6 बाइट्स

जे, ४५

प्रसंस्करण 536 532

मतलाब (152)

पर्ल, 218 216 211 202 बाइट्स

पायथन, 589 बाइट्स

पायथन 2, 456 बाइट्स

प्रसंस्करण 270,261 249 बाइट्स

Lua + LuaVE / Love2D , 653 बाइट्स

परिशिष्ट भाग 529 515

जावास्क्रिप्ट 676

ऑक्टेव (153)

पायथन 2: 334 बाइट्स

PHP, 201 बाइट्स (परीक्षण नहीं किया गया)