गेम ऑफ लाइफ एरोलाइट्स


26

पृष्ठभूमि

यह चुनौती अप्सिलर्स के सम्मान में है , जिन्होंने बेस्ट ऑफ पीपीसीजी 2016 में सर्वश्रेष्ठ के रूप में नहीं जीता है, उनकी चुनौती के साथ क्या मेरा 4-नोट संगीत बॉक्स उस गाने को खेल सकता है? बधाई हो!

उनके "मेरे बारे में" पृष्ठ पर, इस उपयोगकर्ता के पास गेम ऑफ लाइफ सेलुलर ऑटोमेटन के लिए एक बहुत साफ सिम्युलेटर है । (गंभीरता से, इसकी जांच करें।) दूसरी ओर, एस्पिलेरा शब्द "तीरंदाजी" के लिए स्पेनिश है। इन तथ्यों के प्रकाश में, यह चुनौती गेम ऑफ लाइफ में एरोलाइट्स के बारे में है।

गेम ऑफ लाइफ एरोलाइट्स

GoL में, हम एक ग्लाइडर द्वारा एक तीर , और एक दीवार को ब्लॉकों के अनुक्रम द्वारा दर्शाएंगे । एक एकल ग्लाइडर ऊपर से दीवार के पास पहुंचता है, और दीवार में एक अंतराल (एरोलीट) के माध्यम से उड़ान भरने की कोशिश करता है। आपका काम यह जांचना है कि ग्लाइडर तीर के माध्यम से गुजरता है या दीवार में क्रैश होता है।

इनपुट

आपका इनपुट बिट्स का एक ग्रिड है, जो एक गोएल कॉन्फ़िगरेशन का प्रतिनिधित्व करता है। आप इसे किसी भी उचित प्रारूप में ले सकते हैं (किसी भी दो डिस्टिक्ट प्रिंट करने योग्य ASCII वर्णों की बहुस्तरीय स्ट्रिंग, तार की सूची, पूर्णांक के 2 डी सरणी, बूलियन के 2 डी सरणी)। स्पष्टता के लिए, मैं .#निम्नलिखित में वर्णों के बहुस्तरीय तारों का उपयोग करूंगा ।

इनपुट में कई गुण होने की गारंटी है। सबसे पहले, इसकी ऊंचाई कुछ एन and 6 के लिए 2N है , और इसकी चौड़ाई कम से कम 2N + 2 है । इनपुट सभी s होगा, सिवाय इसके कि शीर्ष तीन पंक्तियों में कहीं एक ग्लाइडर है, और दो मध्य पंक्तियों पर ब्लॉकों की एक दीवार है। ग्लाइडर दक्षिण-पश्चिम या दक्षिण-पूर्व की ओर जाएगा, और इसकी स्थिति ऐसी है कि यदि दीवारें हटा दी जाती हैं, तो यह नीचे के किनारे तक पहुंचने से पहले साइड किनारे से नहीं गुजरेगी (लेकिन यह ग्रिड के एक कोने तक पहुंच सकती है)। ग्लाइडर शुरू में कम से कम एक कदम से बाएं और दाएं किनारों से अलग होता है । यह किसी भी चरण में हो सकता है।..

दीवार में ब्लॉक होते हैं, जो .एस के एक कॉलम से अलग होते हैं , एक जगह को छोड़कर, जहां वे .एस के कम से कम दो कॉलम से अलग हो जाएंगे । ग्लाइडर की तरह, बाएं और दाएं ब्लॉक को भी .एस के एक कदम से किनारों से अलग किया जाता है । हमेशा बाएं किनारे पर कम से कम एक ब्लॉक और दाएं किनारे पर एक ब्लॉक होगा।

यहां एक मान्य इनपुट ग्रिड का एक उदाहरण दिया गया है:

....#......................
..#.#......................
...##......................
...........................
...........................
...........................
.##.##............##.##.##.
.##.##............##.##.##.
...........................
...........................
...........................
...........................
...........................
...........................

उत्पादन

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

...#...........
.#.#...........
..##...........
...............
...............
##...........##
##...........##

...#...........
....#..........
..###..........
...............
...............
##...........##
##...........##

यदि ग्लाइडर दीवार के माध्यम से उड़ता है, तो आप एक सत्य मूल्य, और अन्यथा एक मिथ्या मूल्य का उत्पादन करेंगे। ऊपर के उदाहरण के लिए, सही आउटपुट गलत है, क्योंकि ग्लाइडर दीवार के बाएं हिस्से में दुर्घटनाग्रस्त हो जाएगा।

इस चुनौती के प्रयोजनों के लिए, आप यह मान सकते हैं कि यदि आप 2 * (ऊंचाई - 3) चरणों के लिए इनपुट पर GoL का अनुकरण करते हैं , तो ग्लाइडर अपेक्षित स्थिति में नीचे की पंक्ति में है और दीवार बरकरार है, तो आउटपुट सत्य है ।

नियम और स्कोरिंग

आप एक पूर्ण कार्यक्रम या एक फ़ंक्शन लिख सकते हैं। सबसे कम बाइट गिनती जीतती है।

परीक्षण के मामलों

मैंने परीक्षण मामलों को एक GitHub रिपॉजिटरी में एकत्र किया है , क्योंकि वे काफी बड़े हैं। यहां अलग-अलग फ़ाइलों के लिंक दिए गए हैं:


क्या इनपुट में दीवार के नीचे की खाली पंक्तियों को शामिल करने का कोई कारण है?
मार्टिन एंडर

@MartinEnder वे समाधान बनाते हैं जहाँ आप वास्तव में अधिक व्यावहारिक (कम से कम मुझे आशा है) इनपुट पर GoL का अनुकरण करते हैं।
ज़गरब

ग्लाइडर हमेशा शीर्ष पंक्ति पर शुरू होगा?
रॉड

@ रोड हाँ, यह दक्षिण-पश्चिम या दक्षिण-पूर्व की ओर शीर्ष पंक्ति पर होगा।
जगरब

जीवन का एक और खेल: पी
क्रिस्टोफर

जवाबों:


15

पायथन 2 , 142 136 135 बाइट्स

-6 बाइट्स ElPedro
-1 बाइट की बदौलत TuukkaX को धन्यवाद

p=input()
z=p[2].index(1)
m=(p[1][z]-p[1][z+1]<1)*2-1
k=i=0
for b in p[3:]:x=p[2][::m].index(1)+i;k|=1in b[::m][x-2:x+8];i+=1
print 1-k

इसे ऑनलाइन आज़माएं! या सभी परीक्षण मामलों को सत्यापित करें

अभिविन्यास की जाँच करना (पूर्व / पश्चिम):

पश्चिम पूर्व
का उपयोग करते हुए z=p[2].index(1)3 पंक्ति पर पहले वर्ग (लाल चौक द्वारा प्रतिनिधित्व) प्राप्त करने के लिए, और उसके बाद m=(p[1][z]-p[1][z+1]<1)*2-1इस तरह से सही छोड़ दिया (नीला) पर एक से (हरा) पर मूल्य घटाना, सभी 4 ग्लाइडर्स कहा गया है कि जा रहे हैं दक्षिण-पश्चिम में परिणाम 1(छवि में शीर्ष पंक्ति), जबकि दक्षिण-पूर्व में जाने वाले परिणाम में 0या -1
फिर कन्वर्ट करें: 1 -> -1और 0,-1 -> 1पश्चिम के साथ काम करते समय सूचियों को उलटने के लिए पैरामीटर पर उपयोग किया जा सकता है। इस तरह दक्षिण-पश्चिम की ओर जाने वाले ग्लाइडर को उसी तरह से धमकाया जाता है जैसे कि दक्षिण-पूर्व में जाना।

ग्लाइडर आंदोलन

ग्लाइडिंग
यह वह आंदोलन है जो ग्लाइडर दक्षिण-पूर्व की ओर जाता है, इसमें "सीढ़ी" पैटर्न है, और तीसरी पंक्ति पर सबसे बाईं ओर का ब्लॉक हर पैटर्न के लिए स्थिर है। शुरुआती बिंदु के रूप में इसका उपयोग करते हुए, बाएं और दाएं पर आसपास के 3 ब्लॉक, और मध्य 4 ब्लॉक को 1एस की उपस्थिति के लिए जांचा जाता है (जो कि दीवार होगी)।
बाणों
arrowslits_path


मुझे लगता है कि आप एक चर सेट करके 4 बाइट खो सकते हैं iकरने के लिए 0बाहर forपाश प्रत्येक पास तो यह यह करने के लिए 1 जोड़ने और इतने से छुटकारा पाने के enumerate। काम करने लगता है जब मैंने इसे आपके TIO के साथ आज़माया। एक शांत जवाब के लिए +1 कि मैं सही हूं या गलत।
एलपेड्रो

अच्छा! आप व्हॉट्सएप को हटाकर एक बाइट को बचा सकते हैं 1 in। +1।
यति

2
+1 "
भोज

4

ऑक्टेव, 123 122 108 बाइट्स

@LuisMendo की बदौलत 2 बाइट बच गईं

B=A=input("");B(1:3,:)=0;do;until nnz((A=A&(s=conv2(A,(m=-1:1)|m','same'))>1&s<4|~A&s==3)-B)-5;any(A(end,:))

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

या

सभी परीक्षण मामलों की जाँच करें

रॉड परीक्षण मामलों की तैयारी के लिए धन्यवाद।

B=A=input("");
B(1:3,:)=0;
do
until nnz((A=A&(s=conv2(A,(m=-1:1)|m','same'))>1&s<4|~A&s==3)-B)-5
any(A(end,:))

पिछला उत्तर:

B=A=input("");
B(1:3,:)=0;
while nnz(A~=B)==5
    s=conv2(A,(m=-1:1)|m','same');
    x=~A;
    A&=~A|~(s<2|s>3);
    A|=x&s==3;
end;
any(A(end,:))

सबसे पहले चर के रूप में दीवार पैटर्न निकालें B
जब तक दीवार पैटर्न और सिम्युलेटेड पैटर्न में 5 से अधिक अलग-अलग सेल न हों, तब तक GoL सिमुलेशन करें।
यदि ग्लाइडर ने अंतिम पंक्ति प्राप्त की है तो फ़ंक्शन सही है।


1
जब तक दीवार पैटर्न और सिम्युलेटेड पैटर्न में 5 से अधिक विभिन्न सेल नहीं होते हैं। यह चालाकी है!
लुइस मेंडो

@LuisMendo धन्यवाद, एक बाइट बचाई
rahnema1

हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.