जीवन पैटर्न के सामान्य खेल की गणना करें

Question

यहां कार्य एक गॉली .rleया प्लेनटेक्स्ट फ़ाइल (आपकी पसंद) से पढ़ना है जिसका फ़ाइल नाम एसटीडीआईएन (एक कमांड लाइन तर्क के रूप में) प्रदान किया गया है और ग्रिड एन्कोडेड में सामान्य पैटर्न की पहचान और गणना करें।

वैकल्पिक रूप से, आप इसके बजाय सीधे STDIN पर उपलब्ध कराई गई फ़ाइल की सामग्री का चयन कर सकते हैं।

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

इन दोलक के सभी चरणों को मान्यता दी जानी चाहिए, जैसा कि ग्लाइडर के सभी चार चरणों में होना चाहिए।

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

पैटर्न जो गिने जा रहे हैं अन्य पैटर्न का हिस्सा नहीं गिना जाना चाहिए। (उदाहरण के लिए, एक बीकन के 8-सेल चरण को भी दो ब्लॉकों के रूप में नहीं गिना जाना चाहिए, और एक जहाज-टाई को भी दो जहाजों के रूप में नहीं गिना जाना चाहिए)

आप यह मान सकते हैं कि इनपुट पहले ही स्थिर हो चुका है और इसमें कोई पैटर्न नहीं है, जो कि एनॉर्ममेंटेड सेट में नहीं है। आप यह भी मान सकते हैं कि इनपुट ग्रिड 1024x1024 बॉक्स के भीतर फिट होगा।

यह कोड-गोल्फ है , इसलिए सबसे छोटा कार्यक्रम जीतता है।

RLE फ़ाइल स्वरूप विवरण

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

पहली गैर-खाली, गैर-टिप्पणी लाइन फार्म की है x=<width>,y=<height>,rule=<rule>। इस कार्य के प्रयोजनों के लिए, नियम हमेशा रहेगा B3/S23। इसमें ऐसे स्थान हो सकते हैं जिन्हें इस लाइन को संसाधित करने से पहले छीन लिया जाना चाहिए (बेशक, इस लाइन को बिल्कुल भी संसाधित करना आवश्यक नहीं है)।

पहली के बाद गैर-टिप्पणी लाइनों को एक स्ट्रिंग के रूप में माना जाना चाहिए। यह केवल दशमलव अंक, वर्ण होने चाहिए $, bऔर o, और पंक्ति विराम, और अंक के साथ समाप्त नहीं होंगे। रेखा विराम को अनदेखा किया जाना चाहिए, लेकिन आप मान सकते हैं कि पंक्ति विराम अंकों के तार को बाधित नहीं करेगा।

इसे एकल द्वारा समाप्त किया जा सकता है !।

bएक मृत कोशिका का oप्रतिनिधित्व करता है, एक जीवित कोशिका का $प्रतिनिधित्व करता है , और एक पंक्ति के अंत का प्रतिनिधित्व करता है। किसी भी दशमलव संख्या से संकेत मिलता है कि निम्न प्रतीक को कई बार दोहराने के रूप में माना जाना है।

प्लेनटेक्स्ट पैटर्न एन्कोडिंग

अन्य विकल्प यहां वर्णित एक अन्य सादे प्रारूप में पैटर्न को पढ़ना है। इस एन्कोडिंग में, बंद कोशिकाओं को हाइफ़न के साथ दर्शाया जाता है और कोशिकाओं पर अपरकेस ओस के साथ प्रतिनिधित्व किया जाता है, जिसमें नई पंक्तियों को अलग किया जाता है।

आप मान सकते हैं कि सभी गैर-टिप्पणी पंक्तियों को हाइफ़न के साथ समान लंबाई तक गद्देदार किया जाएगा।

के साथ शुरू होने वाली लाइनें !टिप्पणी हैं और इसे अनदेखा किया जाना है।

कुछ परीक्षण मामले

RLE:

#This is a comment
x = 35, y = 16, rule = B3/S23
bo$2o$obo5$22bo$22bo$22bo2$18b3o3b3o2$22bo$22bo10b2o$22bo10b2o!

सादे पाठ:

!This is a comment
-O---------------------------------
OO---------------------------------
O-O--------------------------------
-----------------------------------
-----------------------------------
-----------------------------------
-----------------------------------
----------------------O------------
----------------------O------------
----------------------O------------
-----------------------------------
------------------OOO---OOO--------
-----------------------------------
----------------------O------------
----------------------O----------OO
----------------------O----------OO

परिणाम:

Glider 1
Blinker 4
Block 1

RLE:

x = 27, y = 15, rule = B3/S23
5b2o$5b2o9$11bo$o9bobo$o9bobo$o10bo12b3o!
#Here's a comment at the end

सादे पाठ:

-----OO--------------------
-----OO--------------------
---------------------------
---------------------------
---------------------------
---------------------------
---------------------------
---------------------------
---------------------------
---------------------------
-----------O---------------
O---------O-O--------------
O---------O-O--------------
O----------O------------OOO
!Here's a comment at the end

परिणाम:

Block 1
Blinker 2
Beehive 1

RLE:

#You may have multiple comments
#As shown here
x = 13, y = 11, rule = B3/S23
2o$2o2$12bo$12bo$12bo$2b2o$2b2o4b2o$7bo2bo$7bobo$8bo!

सादे पाठ:

!You may have multiple comments
!As shown here
OO-----------
OO-----------
-------------
------------O
------------O
------------O
--OO---------
--OO----OO---
-------O--O--
-------O-O---
--------O----

परिणाम:

Block 2
Blinker 1
Loaf 1

RLE:

# Pentadecathlon
# Discovered by John Conway
# www.conwaylife.com/wiki/index.php?title=Pentadecathlon
x = 10, y = 3, rule = B3/S23
2bo4bo2b$2ob4ob2o$2bo4bo!

सादे पाठ:

! Pentadecathlon
! Discovered by John Conway
! www.conwaylife.com/wiki/index.php?title=Pentadecathlon
--O----O--
OO-OOOO-OO
--O----O--

परिणाम:

Pentadecathlon 1

बोनस

यदि आप दोनों इनपुट फॉर्मेट्स (फाइल एक्सटेंशन का उपयोग कर रहे हैं ( .rleरीले फाइलों के लिए और प्लेनटेक्स्ट के लिए- तो .cellsअन्य एक्सटेंशन को कैसे पढ़ा जाए) अपरिभाषित है] या उनके बीच अंतर करने के लिए एक कमांड लाइन फ्लैग) आप अपने स्कोर से 5% घटा सकते हैं।

Comments

कैसे के बारे मेंOOO.OO\n....OO

— अक्काका

@ChristianIrwan खैर, यह एक स्थिर पैटर्न नहीं है, इसलिए आपको इसे इनपुट के रूप में वैसे भी नहीं दिया जाएगा।

— SuperJedi224

Answer 1

हास्केल, 2417 बाइट्स

इसमें काफी समय लगा और अभी भी कुछ बग हैं, लेकिन मुझे कई ट्रिक्स काम में लगीं, इसलिए यह इसके लायक था।

टिप्पणियाँ:

• यह केवल सादे प्रारूप को स्वीकार करता है, जिसे STDIN को पास किया जाता है
• यह O (n ^ 20) समय की तरह कुछ लेता है
• मैंने मान लिया कि गैर-टिप्पणी लाइनों में वर्णों की संख्या स्थिर है (एक विशिष्ट इनपुट के भीतर), जैसा कि इस उदाहरण में है
• सरणी बनाने के लिए क्रेज़िएस्ट ट्रिक यह था कि पैटर्न को कैसे अनपैक किया गया है, तत्वों (पदों की संख्या) मोडुलो (आउटपुट की लंबाई) पर तत्वों को निकालते हुए।

यह कुछ प्रमुख विचारों को जोड़ती है:

• पैटर्न और समरूपता पूर्व-गणना की जा सकती है
• एक एकल पैटर्न को पूर्णांक में पैक किया जा सकता है, जिसमें ज्ञात आयाम होते हैं
• सभी उपमाओं को खोजना आसान है
• बराबरी की गिनती आसान है

यहाँ कोड है:

r=[1..20]
a!0=a!!0
a!x=tail a!(x-1)
u[_,x,y,l]=[[odd$div l$2^i|i<-[0..y],mod i x==j]|j<-[0..x-1]]
main=interact(\s->let q=[map(=='O')l|l<-lines s,l!0/='!']in let g=[i|i<-[[[0,3,11,3339,0,4,11,924,0,4,11,3219,0,3,11,1638,1,4,15,19026,1,4,15,9636,2,3,11,1386,2,4,11,1686,3,7,48,143505703994502,3,7,48,26700311308320,3,7,48,213590917399170,3,7,48,8970354435120,4,2,3,15,5,3,8,171,5,3,8,174,5,3,8,426,5,3,8,234,6,4,15,36371,6,4,15,12972,6,4,15,51313,6,4,15,13644,6,4,15,50259,6,4,15,12776,6,4,15,51747,6,4,15,6028,7,4,15,26962,7,4,15,9622,7,4,15,19094,7,4,15,27044,8,5,24,9054370,8,5,24,2271880,9,4,15,51794,9,4,15,13732,9,4,15,19027,9,4,15,9644,10,4,19,305490,10,5,19,206412,10,5,19,411942,10,4,19,154020,11,3,8,427,11,3,8,238,12,6,35,52217012547,12,6,35,3306785328,13,3,8,170,14,3,8,428,14,3,8,458,14,3,8,107,14,3,8,167,14,3,8,482,14,3,8,302,14,3,8,143,14,3,8,233,14,3,8,241,14,3,8,157,14,3,8,286,14,3,8,370,14,3,8,181,14,3,8,115,14,3,8,346,14,3,8,412,15,4,15,51219,15,4,15,12684,15,4,15,52275,15,4,15,13260,16,1,2,7,16,3,2,7,17,3,29,313075026,17,10,29,139324548,17,3,23,16252911,17,8,23,16760319,17,5,49,152335562622276,17,10,49,277354493774076,17,7,69,75835515713922895368,17,10,69,138634868908666122360,17,9,89,135722011765098439128942648,17,10,89,58184575467336340020006960,17,5,59,160968502306438596,17,12,59,145347113669124612,17,5,59,524156984170595886,17,12,59,434193401052698118,17,5,69,164495599269019571652,17,14,69,222245969722444385292,17,5,69,517140479305239282702,17,14,69,222262922122170485772,17,3,47,83020951028178,17,16,47,39740928107556,17,3,35,62664969879,17,12,35,40432499049,17,3,41,1581499314234,17,14,41,1293532058322,17,3,41,4349006881983,17,14,41,3376910168355,17,3,47,92426891685930,17,16,47,83780021865522,17,3,47,79346167206930,17,16,47,11342241794640,18,13,168,166245817041425752669390138490014048702557312780060,18,15,224,1711376967527965679922107419525530922835414769336784993839766570000,18,13,168,141409121010242927634239017227763246261766273041932,19,2,7,126,19,4,7,231,19,4,7,126,19,2,7,189,19,4,15,24966,19,4,15,18834,19,4,15,10644,19,4,15,26646]!p|p<-[h..h+3]]|h<-[0,4..424]],j<-[[[q!y!x|x<-[a..a+c]]|y<-[b..b+d]]|c<-r,d<-r,a<-[0..(length$q!0)-c-1],b<-[0..length q-d-1]],u i==j]in show[(words"aircraftcarrier barge beehive biloaf1 block boat eater1 loaf longbarge longboat mango ship shiptie tub glider beacon blinker pentadecathlon pulsar toad"!(e!0),sum[1|f<-g,e!0==f!0])|e<-g])

यहाँ Mathematica कोड को 0,1 के एक सरणी को बाद में हेकेल प्रोग्राम द्वारा अनपैक करने के लिए प्रयोग किया जाता है:

rotate[m_]:=Transpose[Map[Reverse,m]]
findInversePermutation[m_]:=Block[{y=Length[First[m]], x=Length[m]}, InversePermutation[FindPermutation[Flatten[m], Flatten[Table[Table[Flatten[m][[i+1]], {i, Select[Range[0, x * y - 1], Mod[#, x]==j&]}], {j, 0, x - 1}]]]]]
enumShape[m_]:=Partition[Range[1, Length[Flatten[m]]], Length[m[[1]]]]
pack[m_]:={Length[rotate[rotate[m]]], Length[Flatten[rotate[rotate[m]]]], FromDigits[Permute[Flatten[rotate[rotate[m]]], findInversePermutation[enumShape[rotate[rotate[m]]]]], 2]}

यहाँ कोड का एक बहुत अधिक पूर्ण ungolfing है:

range = [1..16]          -- all of the patterns fall within this range

list ! 0        = list !! 0           -- this is a simple generic (!!)
list ! position = (tail list) ! (position - 1)

unpack [_, unpackedLength, unpackedSize, packed] = [ [odd $ div packed (2^i) | i <- [0..unpackedSize], (mod i unpackedLength) == j] | j <- [0..unpackedLength - 1]]

main=interact doer

doer input = show $ tallyByFirst (words nameString) foundPatterns -- this counts equalities between the list of patterns and the submatrices of the input
  where
    parsed = parse input -- this selects the non-comment lines and converts to an array of Bool's
    foundPatterns = countOccurrences partitioned subArrays
    subArrays     = allSubArrays parsed
    partitioned   = modPartition compressed 428 4 -- this partitions the compressed patterns into the form [name number, x length, x length * y length, packed integer]

countOccurrences patterns subArrays = [pattern | pattern <- patterns, subArray <- allSubArrays q, unpack pattern == subArray]

subArray m offsetX subSizeX offsetY subSizeY = [[m ! y ! x | x <- [offsetX..offsetX + subSizeX]] | y <- [offsetY..offsetY + subSizeY]]

allSubArrays m = [subArray m offsetX subSizeX offsetY subSizeY | subSizeX <- range, subSizeY <- range, offsetX <- [0.. (length $ head m) - subSizeX - 1], offsetY <- [0..(length m) - subSizeY - 1]]

tallyByFirst names list = [ (names ! (a ! 0), sum [1 | a <- list, (head a) == (head b)]) | b <- list]

parse string = [map (=='O') line | line <- lines string, head line /= '!']

modPartition list chunksize = [ [list ! position | position <- [offset..offset + chunksize - 1]] | offset <- [0, chunksize..(length list) - chunksize]]

Comments

PPCG में आपका स्वागत है! मैंने अभी तक यह कोशिश नहीं की है, लेकिन यह प्रभावशाली है। +1!

— एक

यह प्रभावशाली से अधिक है, +1!

— बिल्ली