एक मधुमक्खी का अजीब जीवन

Question

शोधकर्ताओं ने हाल ही में एक दिलचस्प मधुमक्खी कॉलोनी की खोज की है जो मधुकोश के अनंत क्षेत्र में रहती है:

प्रत्येक कोशिका में मधुमक्खी हो सकती है या नहीं। वास्तव में, उन प्राणियों का जीवन एक सा प्रतीत होता है ... अराजक। यह गणना की जा सकती है कि एक कॉलोनी हमेशा निम्नलिखित पैटर्न से शुरू होती है:

_{(बी द्वारा तैयार एम्मानुएल Boutet पर विकिमीडिया कॉमन्स । यह मधुकोश और मधुमक्खियों छवि इस प्रकार के तहत जारी की है CC-BY-SA । शिकायत )}

उसके बाद मधुमक्खी के जीवन चक्र को तथाकथित पीढ़ियों में विभाजित किया जाता है। प्रत्येक पीढ़ी की पुरानी मधुमक्खियां मर जाती हैं और नए बच्चे पैदा होते हैं और यह मुख्य रूप से उनके सेल के पड़ोसियों पर निर्भर करता है:

• यदि एक मधुमक्खी के दो पड़ोसी से कम होते हैं तो वह अकेलेपन के कारण मर जाती है।
• यदि मधुमक्खी के तीन से अधिक पड़ोसी हैं तो यह अधिक भीड़ के कारण मर जाता है।
• यदि एक कोशिका में पड़ोसी कोशिकाओं में दो, तीन या चार जीवित मधुमक्खियाँ होती हैं, तो अगली पीढ़ी में वहाँ एक नई मधुमक्खी होती है।

मरने वाली मधुमक्खियां एक पीढ़ी के अंत तक नहीं मरती हैं, इसलिए वे अभी भी आसपास की कोशिकाओं को प्रभावित करती हैं जो अगली पीढ़ी में मधुमक्खियों का शिकार हो सकती हैं।

अब जब हम जानते हैं कि इस तरह की कॉलोनी कैसे काम करती है, तो हम इसे किसी भी पीढ़ी के माध्यम से अनुकरण कर सकते हैं।

इनपुट

इनपुट एक एकल नंबर एन है , जो मानक इनपुट पर दिया जाता है, जिसे लाइन ब्रेक द्वारा समाप्त किया जाता है। 0 of N ≤ 150। यह अनुकरण करने वाली कई पीढ़ियों की संख्या है।

उत्पादन

आउटपुट एक एकल संख्या है, मानक आउटपुट पर और वैकल्पिक रूप से एकल पंक्ति विराम के बाद, जो एन पीढ़ियों के बाद जीवित मधुमक्खियों की संख्या का प्रतिनिधित्व करता है ।

मानक त्रुटि पर अतिरिक्त आउटपुट को अनदेखा किया जाता है।

नमूना इनपुट

0
5
42
100

नमूना आउटपुट

6
44
1029
5296

जीतने की स्थिति

सबसे कम कोड जीतता है, जैसा कि गोल्फ में प्रथागत है। एक टाई के मामले में, पहले वाला समाधान जीत जाता है।

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

समान परीक्षण मामलों वाले दो परीक्षण स्क्रिप्ट हैं:

• दे घुमा के
• शक्ति कोशिका

मंगलाचरण दोनों मामलों में है: <test script> <my program> [arguments]जैसे ./test ruby beehive.rbया ./test.ps1 ./beehive.exe।

मुझे पता है कि 151 के बजाय केवल 22 परीक्षण हैं (मुख्यतः क्योंकि समाधान अक्सर काफी धीमी गति से होते हैं)। कृपया कार्य को हल करने के बजाय सटीक परीक्षण मामलों को एम्बेड करने से बचें। ये स्क्रिप्ट आपके लिए यह परीक्षण करने की सुविधा है कि क्या परिवर्तन अभी भी प्रोग्राम को सही ढंग से व्यवहार करने का कारण बनता है; ऐसा नहीं है कि आप अपने कोड को विशिष्ट परीक्षण मामलों में अनुकूलित कर सकते हैं।

एक और नोट

यह कार्य 2011-डब्ल्यू 24 के दौरान मेरे विश्वविद्यालय में आयोजित एक गोल्फ प्रतियोगिता का हिस्सा था। हमारे प्रतियोगियों के स्कोर और भाषाएँ इस प्रकार थीं:

• 336 - सी
• 363 - सी
• 387 - सी
• 389 - हास्केल
• 455 - सी

हमारा अपना समाधान था

• 230 - रूबी

Comments

यह कॉनवे के जीवन के खेल जैसा लगता है।

— पीटर ओल्सन

बेशक; इसलिए इसे इस तरह से टैग किया गया है। यह वास्तव में बहुत पतला है।

— जॉय

Answer 1

रूबी, 181 163 153 146 वर्ण

h=[0]*4e4
[0,-200,201,202,2,3].map{|i|h[i]=1}
gets.to_i.times{h=h.map{[g=1,200,201].map{|x|g+=h[x]+h[-x]};g>5-h.rotate![-1]||g<3?0:1}}
p h.count 1

यह कार्यान्वयन एक सरणी h(आयाम 200x 200चपटा) का उपयोग करते हुए एक मानक दृष्टिकोण का अनुसरण करता है , जहां प्रत्येक तत्व या तो 0(कोई मधुमक्खी) या 1(मधुमक्खी शामिल) है। सरणी [0,-200,201,202,2,3]मधुमक्खियों की प्रारंभिक स्थिति (किसी भी प्रारंभिक सेल के सापेक्ष) का वर्णन करती है।

इनपुट और आउटपुट जैसा कि ऊपर निर्दिष्ट किया गया है, सभी परीक्षण मामलों को परिभाषित करता है।

संपादित करें 1: "अतिरिक्त स्थान" -version (जो एक मध्यवर्ती संस्करण में छोटा था, लेकिन अब कई अक्षर लंबा है) के बजाय एक रैपिंग समाधान में बदल गया।

संपादित 2:b पूरी तरह से हटाए गए चर ।

संपादन 3: चेतावनी: इस संपादन ने कार्यक्रम को बहुत धीमा कर दिया। मैंने इस प्रकार आयामों को 200 तक घटा दिया जो अभी भी 150 पुनरावृत्तियों के लिए पर्याप्त है। सरणी को एक चर द्वारा अनुक्रमित करने के बजाय हम लगातार सरणी को आगे घुमाते हैं। वास्तव में अच्छा डिज़ाइन नहीं है, लेकिन अब हम 150 से काफी नीचे हैं।

Answer 2

पाइथन, 152 अक्षर

P=[0,2,3,1j,1+1j,1-1j]
for i in' '*input():Q=[p+d for d in(1,-1,1j,-1j,1j-1,1-1j)for p in P];P=set(p for p in Q if 1<Q.count(p)<5-(p in P))
print len(P)

यह समाधान जटिल संख्याओं के समूह के साथ मधुमक्खी स्थानों का ट्रैक रखता है। यह बहुत धीमा है क्योंकि आंतरिक लूप मधुमक्खियों की संख्या में द्विघात है। मैंने 50 तक परीक्षण किया है और यह काम करता है।

Comments

Python2.7 ने समझ स्थापित की है

— gnibbler

मैंने मधुमक्खियों को ट्रैक करने के बारे में सोचा, लेकिन इसे जटिल संख्याओं के साथ करना जैसे वास्तव में साफ-सुथरा है! इसके अलावा आप एक निष्पादन के साथ लूप के लिए 3 वर्णों को बचा सकते हैं (जैसे मैंने किया था)।

— जूल्स ओलेन

Python2.7 ने शाब्दिक रूप से भी सेट किया है, इसलिए आप लिख सकते हैं P={0,2,3,1j,1+1j,1-1j}और फिर {p}<Pसदस्यता के लिए परीक्षण करने के लिए उपयोग कर सकते हैं (1 char बचाता है)

— gnibbler

Answer 3

पायथन, 171 169 158 चार्ट

w=300
s=w*w
x=[0]*297
h=[1,1,0]+x+[1,0,1,1]+x+[1]+x*s
exec('h=[1<sum(h[(i+x)%s]for x in[-1,-w-1,-w,1,w+1,w])<5-h[i]for i in range(s)];'*input())
print sum(h)

मैं दुनिया को एक 300 * 300 = 900000 1D सरणी के रूप में मॉडल करता हूं ( hवास्तव में बड़ा है, लेकिन अंत का उपयोग नहीं किया जाता है), जहां एक मधुमक्खी 1 है और खाली है 0. आकार 300 का ठीक है क्योंकि अधिकांश में विकास होगा प्रत्येक पीढ़ी के लिए प्रत्येक आयाम में 2, और 150 से अधिक पीढ़ी नहीं है।

यहाँ थोड़ा असंयमित और टिप्पणी किया गया संस्करण है:

w=300 # width and height of the world
s=w*w
# create initial grid
l=[1,1]+[0]*298+[1,0,1,1]+[0]*297+[1]+[0]*s

for k in range(input()):
  h=l[:]

  for i in range(s):

    # for each point, compute the number of neighbors
    n=sum(map(lambda x:h[(i+x)%s],[-1,-w-1,-w,1,w+1,w]))

    # if that number verifies the conditions, put 1 here, if not put 0
    l[i]=1<n<5-h[i]

print sum(l)