3 डी में जीवन के खेल को लागू करें

Question

चुनौती 3 डी ( उदाहरण ) में जीवन के खेल के सबसे कम कार्यान्वयन को खोजने के लिए है । ये नियम हैं:

केवल 1 या उससे कम पड़ोसियों के साथ कोशिकाएं (इस मामले में, क्यूब्स) मर जाती हैं, जैसे कि अकेलेपन से।
यदि वास्तव में 5 कोशिकाएं एक खाली सेल को घेरती हैं, तो वे प्रजनन करते हैं और उसे भरते हैं।
यदि किसी कक्ष में 8 या अधिक पड़ोसी हैं, तो यह अधिक भीड़ से मर जाता है।

इसे कम से कम 10x10x10 बनाओ, जहां परतों को व्यक्तिगत रूप से इस तरह से आउटपुट किया जाता है:

0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0
0 X 0 0 X 0 0 0 0 0
0 0 X X X 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0

बेशक, एक ग्राफिक 3 डी सिमुलेशन भी स्वीकार किया जाता है
प्रारंभिक स्थिति हार्डकोड हो सकती है लेकिन इसे किसी भी प्रारंभिक स्थिति में बदल दिया जाना चाहिए। यह किसी भी पीढ़ी की गणना करने में सक्षम होना चाहिए, और उपयोगकर्ता को अगली पीढ़ी के लिए मैन्युअल रूप से पूछने में सक्षम होना चाहिए।

पात्रों में सबसे छोटा कोड जीतता है!

मैंने इसे किसी भी (क्यूब) आकार के लिए अपना स्वयं का कार्यान्वयन बनाया: http://jensrenders.site88.net/life3D.htm आप परीक्षण करने के लिए इसका उपयोग कर सकते हैं, और आप अपना कोड मेरे आधार पर कर सकते हैं, हालांकि मैंने यह टिप्पणी नहीं की थी ।

Comments

अपने बयान से कोड-गोल्फ टैग को लागू करें सबसे कम कार्यान्वयन खोजें । कृपया जांचें कि क्या यह आप चाहते हैं। आपको इनपुट, कैसे कई चक्र, एनिमेटेड हां / नहीं, के बारे में कुछ विवरण देना चाहिए ... क्योंकि कोड-गोल्फ के लिए एक मजबूत विनिर्देश होना आवश्यक है।

— हावर्ड

@ हॉवर्ड मैंने कुछ और स्पेसिफिकेशन्स जोड़े, और हाँ, कोड-गोल्फ टैग भूल गया;) इसके लिए धन्यवाद।

— जेन्स रेंडर

@PeterTaylor हाँ बिल्कुल 5, मैं इसे संपादित करूँगा।

— जेन्स रेंडर

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

— जोनाथन वान मैट्रे

क्या आप वास्तव में सभी खामियों को रोकने के लिए थे में उस मेटा थ्रेड में चर्चा की गई या केवल उन (डिस) अनुमोदन मानदंड (+5 स्कोर, कम से कम दो बार के रूप में कई चढ़ाव के रूप में) पर चर्चा ? क्योंकि मुझे यकीन है कि मैं पूरी तरह से कुछ दिलचस्प दिलचस्प "खामियों" के बारे में चर्चा करने के लिए सोच सकता था ... ;-)

— इल्मरी करोनें

Answer 1

गणितज्ञ - 120 बाइट्स

g=CellularAutomaton[{(l=Flatten@#;c=l[[14]];n=Total@Drop[l,{14}];Which[n<2||n>7,0,n==5||c==1,1,0<1,0])&,{},{1,1,1}},##]&

निश्चित रूप से जीत के दावेदार नहीं, लेकिन यह मेरा इरादा नहीं था। इसके अलावा, यह संभवतः नियम संख्या का अनुमान लगाकर काफी नीचे गिराया जा सकता है। मैं वास्तव में एक विज़ुअलाइज़ेशन लिखना चाहता था (हालांकि मुझे वास्तव में यकीन है कि वहाँ पहले से ही बाहर टन हैं)। तो अब हम शुरू करें):

animateGol3d[size_, i_, n_] := 
  ListAnimate[
    Graphics3D[
      Cuboid /@ Position[#, 1], 
      PlotRange -> {{0, size}, {0, size}, {0, size}} + 1
    ] & /@ g[i, n]
  ];

और प्रारंभिक स्थितियों के एक समूह के साथ प्रयोग करने के बाद, मुझे निम्नलिखित चीजें मिलीं:

और यहाँ ग्रिड आकार के साथ एक है 20x20x20। इसे अनुकरण और प्रस्तुत करने में कुछ सेकंड लगे:

वैसे, यह आवधिक सीमा की स्थितियों को मानता है।

Comments

क्या वे वास्तव में एक संतुलन राज्य में प्रवेश कर रहे हैं, या यह सिर्फ एनीमेशन रोक रहा है? अगर पूर्व, आपने मुझे कुछ साफ विचार दिए ...

— Kroltan

@Kroltan यह एक समय हो गया है, लेकिन मुझे पूरा यकीन है कि वे संतुलन तक पहुंच रहे थे।

— मार्टिन एंडर

अच्छा धन्यवाद। संतुलन के अलग-अलग स्लाइस कहने के लिए बहुत कमरे-मानचित्र-वाई दिखते हैं, एक रौगेलिक गेम।

— २०

Answer 2

एपीएल, ४६

यह मुझे कुछ समय लगा, लेकिन मैंने इसे 46 वर्णों तक सीमित कर दिया:

{(5=m)∨⍵∧3>|5.5-m←⊃+/,i∘.⌽i∘.⊖(i←2-⍳3)⌽[2]¨⊂⍵}

यह एक ऐसा फ़ंक्शन है जो किसी भी आकार के बूलियन 3 डी मैट्रिक्स लेता है और दिए गए नियमों के अनुसार, अगली पीढ़ी की गणना करता है। सीमा की स्थिति निर्दिष्ट नहीं की गई थी, इसलिए मैंने दूसरे पक्ष के चारों ओर लपेटने के लिए चुना, जैसा कि टॉरोइडल स्पेस में है।

व्याख्या

{                           ⊂⍵}   Take the argument matrix and enclose it in a scalar
               (i←2-⍳3)           Prepare an array with values -1 0 1 and call it i
                       ⌽[2]¨      Shift the matrix along the 2nd dim. by each of -1 0 1
           i∘.⊖                   Then for each result do the same along the 1st dimension
       i∘.⌽                       And for each result again along the 3rd dimension
 m←⊃+/,                           Sum element-wise all 27 shifted matrices and call it m

मध्यवर्ती परिणाम mमूल मैट्रिक्स के समान आकार वाला एक मैट्रिक्स है, जो प्रत्येक तत्व के लिए मायने रखता है कि उसके 3 × 3 × 3 पड़ोस में कितने सेल जीवित हैं, जिसमें स्वयं भी शामिल है। फिर:

           |5.5-m   For each element (x) in m, take its distance from 5.5
       ⍵∧3>         If that distance is <3 (which means 3≤x≤8) and the original cell was 1,
 (5=m)∨             or if the element of m is 5, then the next generation cell will be 1.

उदाहरण

एक यादृच्छिक 4 × 4 × 4 मैट्रिक्स को लगभग 1/3 कोशिकाओं = 1 के साथ परिभाषित करें और इसकी पहली और दूसरी पीढ़ी की गणना करें। ⊂[2 3]मोर्चे पर सिर्फ एक चाल खड़ी की क्षैतिज बजाय विमानों मुद्रित करने के लिए है:

      ⊂[2 3] m←1=?4 4 4⍴3
 1 0 0 0  1 0 1 0  1 0 1 0  0 0 0 1 
 1 1 0 0  0 0 0 0  0 0 0 1  1 0 1 0 
 0 0 0 0  0 1 0 0  0 0 0 0  0 0 1 0 
 1 1 0 0  0 0 0 1  1 0 0 1  0 0 1 0 
      ⊂[2 3] {(5=m)∨⍵∧3>|5.5-m←⊃+/,i∘.⌽i∘.⊖(i←2-⍳3)⌽[2]¨⊂⍵} m
 0 0 0 0  0 0 1 0  1 0 1 0  0 0 0 0 
 1 0 0 0  0 0 1 0  0 0 0 0  1 0 1 0 
 0 0 0 0  0 1 0 0  0 0 0 0  0 0 1 0 
 1 1 0 0  0 0 0 0  1 0 0 0  0 0 1 0 
      ⊂[2 3] {(5=m)∨⍵∧3>|5.5-m←⊃+/,i∘.⌽i∘.⊖(i←2-⍳3)⌽[2]¨⊂⍵}⍣2⊢ m
 0 0 1 0  1 0 1 0  1 0 1 0  0 0 0 0 
 1 0 1 0  0 0 1 1  0 0 0 0  1 0 1 0 
 1 0 0 0  1 1 0 0  0 0 1 0  1 0 1 0 
 1 1 1 0  1 0 0 1  1 0 1 0  0 0 1 0 

Comments

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

— जेन्स रेंडर

Answer 3

जे - ४२ चार

हम तीनों आयामों में एक टॉरॉइडल बोर्ड (चारों ओर लपेटता) मान रहे हैं। जे का स्वचालित प्रदर्शन आउटपुट 1सेल्स का अनुसरण करता है, जो जीवित कोशिकाओं के लिए और 0मृत के लिए उपयोग होता है । यह कोड किसी भी चौड़ाई, लंबाई और ऊंचाई के बोर्ड पर काम करता है (10x10x10, 4x5x6, और इसी तरह) हो सकता है।

(((1&<*<&8)@-*]+.5=-)~[:+/(,{3#<i:1)|.&><)

एक स्पष्टीकरण इस प्रकार है:

• ,{3#<i:1 - सेल और उसके सभी पड़ोसियों के लिए ऑफ़सेट की सूची का Subexpression।
  • <i:1 - 1 और -1 के बीच पूर्णांकों की सूची।
  • ,{3#- सूची की तीन प्रतियां बनाएं ( 3#), और कार्टेशियन उत्पाद ( ,{) लें।
• (,{3#<i:1)|.&><- 3 डी ऑफसेट के प्रत्येक सेट के लिए, ऐरे को शिफ्ट करें। 3 अक्षरों की लागत से, आप बदल सकते हैं |.&>करने के लिए|.!.0&> रैप-अराउंड नहीं लिए ।
• [:+/ - सभी शिफ्ट किए गए बोर्ड को एक साथ जोड़ दें।
• ((1&<*<&8)@-*]+.5=-)~- लंबी बाहरी क्रिया एक हुक थी इसलिए यह बाईं और दाईं ओर बोर्ड को प्राप्त करती है, और दाईं ओर की तरफ हम स्थानांतरण और योग करते हैं। ~स्वैप इस आंतरिक क्रिया के लिए इस के आसपास।
  • 5=- - 1 प्रत्येक सेल में जो कि शिफ्ट-ऑफ-शिफ्ट-बोर्ड का मूल बोर्ड घटाता है (यानी पड़ोसी की गिनती) सभी में 5, और 0 के बराबर होता है।
  • ]+. - मूल बोर्ड के साथ तार्किक या उपरोक्त।
  • (1&<*<&8) - 1 यदि संख्या 1 और 8 के बीच तुलना की जा रही है, तो 0 अन्यथा।
  • (1&<*<&8)@-* - पड़ोसी की गिनती की तुलना करें (ऊपर), और (यानी तार्किक और जब डोमेन केवल 1 या 0 हो) तार्किक या इसके द्वारा परिणाम।

उपयोग एपीएल के साथ है, बस प्रत्येक चरण के लिए प्रारंभिक बोर्ड में फ़ंक्शन लागू करें। J के पास ^:इसे आसान बनाने के लिए एक कार्यात्मक-शक्ति ऑपरेटर है।

   life =: (((1&<*<&8)@-*]+.5=-)~[:+/(,{3#<i:1)|.&><)  NB. for convenience
   board =: 1 = ?. 4 4 4 $ 4  NB. "random" 4x4x4 board with approx 1/4 ones
   <"2 board  NB. we box each 2D plane for easier viewing
+-------+-------+-------+-------+
|0 0 0 0|1 1 0 0|0 1 0 0|0 0 1 0|
|0 1 0 0|0 0 0 0|0 0 0 1|1 0 0 0|
|0 0 0 0|0 0 1 0|0 1 0 0|0 0 0 1|
|1 1 0 0|1 0 0 0|0 0 0 1|0 1 1 0|
+-------+-------+-------+-------+
   <"2 life board
+-------+-------+-------+-------+
|0 0 0 0|0 1 0 1|0 1 0 0|0 0 1 0|
|1 1 1 1|0 0 0 0|0 0 0 1|1 1 0 0|
|0 0 0 0|0 0 1 1|0 1 0 0|0 0 0 1|
|1 0 0 0|1 0 0 1|0 0 0 1|0 1 1 1|
+-------+-------+-------+-------+
   <"2 life^:2 board  NB. two steps
+-------+-------+-------+-------+
|0 0 0 0|0 1 0 0|0 1 0 0|0 0 0 0|
|0 1 0 0|0 0 0 0|0 0 0 1|0 1 0 0|
|0 0 0 0|0 0 0 0|0 1 0 0|0 0 0 0|
|0 0 0 0|0 0 0 1|0 0 0 0|0 1 1 1|
+-------+-------+-------+-------+
   <"2 life^:3 board  NB. etc
+-------+-------+-------+-------+
|0 1 0 0|1 1 1 0|0 1 0 0|0 1 0 0|
|0 1 0 0|1 0 1 0|1 0 1 0|1 1 1 0|
|1 0 0 0|0 0 0 0|0 1 0 0|0 1 0 0|
|0 0 1 0|0 0 0 0|0 1 0 0|0 1 1 0|
+-------+-------+-------+-------+

मैं कहता हूं "यादृच्छिक" क्योंकि ?.हर बार एक निश्चित बीज का उपयोग करके आदिम प्रजनन योग्य यादृच्छिक परिणाम देता है। ?सच्चा RNG है।

Comments

शाप J और उसका फक |.वर्ब !! बहुत बढ़िया।

— टोबिया