डिजिटल सेलुलर ऑटोमेटा

17

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

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

एक उदाहरण के रूप में, यदि N 7 है और स्ट्रिंग है 038, तो कोशिकाओं को कल्पना करने के लिए कि हम 038दोनों दिशाओं में असीम दोहराव लिख सकते हैं

...038038038038038...

फिर वह अंक जो 0वसीयत में बदल जाएगा, वह 7 अंकों का योग है, जो किसी भी ओर केंद्रित है 0, modulo 10:

...038038038038038...
      ^_____^
         |
    sum all these

यह वह जगह है (0+3+8+0+3+8+0)%10जो, 2।

इसी प्रकार अंकों 3और 8में क्रमशः (3+8+0+3+8+0+3)%10= 5और (8+0+3+8+0+3+8)%10= द्वारा परिभाषित किया 0गया है।

इस प्रकार, पीढ़ी के बाद 038है 250जब एन 7 है।

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

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

[digit string] -> [N = 1], [N = 3], [N = 5], [N = 7], [N = 9], [N = 43]
0 -> 0, 0, 0, 0, 0, 0
1 -> 1, 3, 5, 7, 9, 3
2 -> 2, 6, 0, 4, 8, 6
3 -> 3, 9, 5, 1, 7, 9
4 -> 4, 2, 0, 8, 6, 2
5 -> 5, 5, 5, 5, 5, 5
6 -> 6, 8, 0, 2, 4, 8
7 -> 7, 1, 5, 9, 3, 1
8 -> 8, 4, 0, 6, 2, 4
9 -> 9, 7, 5, 3, 1, 7
00 -> 00, 00, 00, 00, 00, 00
07 -> 07, 47, 41, 81, 85, 47
10 -> 10, 12, 32, 34, 54, 12
11 -> 11, 33, 55, 77, 99, 33
12 -> 12, 54, 78, 10, 34, 54
34 -> 34, 10, 78, 54, 12, 10
66 -> 66, 88, 00, 22, 44, 88
80 -> 80, 86, 46, 42, 02, 86
038 -> 038, 111, 294, 250, 333, 472
101 -> 101, 222, 343, 545, 666, 989
987 -> 987, 444, 901, 765, 222, 543
1234 -> 1234, 7698, 3412, 9876, 1234, 7698
26697 -> 26697, 54128, 00000, 56982, 84413, 54128
001002 -> 001002, 211122, 331332, 335334, 455544, 113112
129577020 -> 129577020, 326194923, 474081605, 961120291, 333333333, 183342413
6023845292173530 -> 6023845292173530, 6853571632015189, 1197228291289874, 9238433109901549, 0110956118726779, 1982123699138828
code-golf  number  arithmetic  sequence  cellular-automata 
— केल्विन के शौक
स्रोत
@ LegionMammal978 इसे एक स्ट्रिंग के रूप में रखता है।
— काल्विन के शौक
@ LegionMammal978 नहीं। मैं मानता हूं कि मैं इसे मूल रूप से अनुमति दे सकता था, लेकिन अब ऐसा करने से मौजूदा उत्तरों का गलत प्रभाव पड़ेगा जो तार का उपयोग करते हैं।
— केल्विन के
खैर, मेरे जवाब के आकार को दोगुना करने के लिए धन्यवाद ...
— लीजनमैमल 978

जवाबों:

10

सीजेएम, 21 बाइट्स

l~_,\2/f-l:~fm>:.+Af%

इसका परीक्षण यहां करें।

व्याख्या

l~   e# Read and evaluate N.
_,   e# Duplicate and turn into range [0 1 ... N-1]
\2/  e# Swap with other copy and (integer) divide by 2.
f-   e# Subtract this from each element in the range to get
     e# [-(N-1)/2 ... -1 0 1 ... (N-1)/2]
l:~  e# Read string and evaluate each digit separately.
fm>  e# Make one copy of the result for each element i in the range, shifting the array
     e# i cells to the right, cyclically.
:.+  e# Sum the columns of the resulting matrix.
Af%  e# Take each of those sums modulo 10.
— मार्टिन एंडर
स्रोत
4

पायथन 3, 114 92 86 80 बाइट्स

बंद करने के लिए 6 बाइट्स धन्यवाद ले लिया Sp3000 और एक अन्य 6 करने के लिए धन्यवाद बाइट्स XNOR !

a=lambda N,D,i=0:D[i:]and str(int((D*N)[(i-N//2)%len(D):][:N],11)%10)+a(N,D,i+1)

एक नामित फ़ंक्शन को परिभाषित करता है जो मापदंडों के रूप में aलेता है Nऔर Dचुनौती में परिभाषित एन और अंक स्ट्रिंग।

व्याख्या

पायथन 3 में, andदो तारों के बीच अंत में बाद वाला होगा। इसलिए, D[i:]and ...सभी केंद्रों की स्थिति को देखते हुए शॉर्ट-सर्किट D[i:]एक खाली स्ट्रिंग और इसलिए मिथ्या होगा। (D*N)[(i-N//2)%len(D):][:N]अंक स्ट्रिंग को समय का एक गुच्छा डुप्लिकेट करता है, फिर इसे सही स्थानों में स्लाइस करता है ताकि केंद्र के रूप में सही अंक हो। एक क्षण के लिए स्मरण करो कि आधार १० संख्या के अंक ९ के अंक का जोड़ वही है जो संख्या के रूप में ही है।str(int(...,10)%10) है। परिणामी संख्या को जैसे कि यह आधार 11 था और शेष मोडुलो 10 प्राप्त करता है, फिर वापस अभिसरण करता है। स्ट्रिंग। अंत में, a(N,D,i+1)अगले केंद्र की स्थिति पर आगे बढ़ता है। क्योंकि +, एक बार पुनरावृत्ति हो जाने के बाद, सभी परिणामी अंक एक साथ लंबित हो जाते हैं और वापस आ जाते हैं।

— एलेंडिया स्ट्राटन
स्रोत
3

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

स्ट्रिंग रूपांतरण वास्तव में Haskell में महंगा है ...

x!n=last.show.sum.map(read.pure).take n.(`drop`cycle x).fst<$>zip[div(1-n)2`mod`length x..]x

यह एक infix फ़ंक्शन को परिभाषित करता है !, जिसका उपयोग निम्नानुसार किया जाता है:

> "1234"!3
"7698"

व्याख्या

दाईं ओर हमारे पास है [div(1-n)2`mod`length x..], जो (1-n)/2मोडुलो से शुरू होने वाले पूर्णांक की अनंत सूची है length(x)(हम मापांक लेते हैं, क्योंकि हम चाहते हैं कि पहला तत्व गैर-नकारात्मक हो)। ये CA पड़ोस के शुरुआती सूचकांकों के अनुरूप हैं। हम इसे xसही लंबाई की सूची प्राप्त करने के लिए इसके साथ ज़िप करते हैं ।

फ़ंक्शन <$>का इनफ़िक्स संस्करण है map, और इसका बायां तर्क एक फ़ंक्शन रचना है जिसे दाईं से बाईं ओर पढ़ा जाता है। इस प्रकार उपरोक्त सूची में प्रत्येक पूर्णांक के लिए ( fstहम साथ निकाले गए हैं ), हम बहुत से वर्णों को छोड़ देते हैं cycle x(जो कि अनंत रूप से प्रतियां हो सकती हैं x), nशेष में से वर्ण लें , उन्हें तार में बदलें और फिर पूर्णांक के साथ read.pure, उनका योग लें। इसे स्ट्रिंग के साथ परिवर्तित करें show, और उस के अंतिम वर्ण को लें, जो शेष 10 मॉड से मेल खाता है।

— Zgarb
स्रोत
2

NARS2000 APL, 37 अक्षर (72 बाइट्स)

⎕←10⊥10∣+⌿⊃({⍵..-⍵}⌊⎕÷2)∘.⌽⊂49-⍨⎕AV⍳⍞

स्पष्टीकरण:

  ⎕←10⊥10∣+⌿⊃({⍵..-⍵}⌊⎕÷2)∘.⌽⊂49-⍨⎕AV⍳⍞
⍝ ⎕←                                    output
⍝   10⊥                                 the base-10 digits in
⍝      10∣                              the modulo-10
⍝         +⌿                            column-wise sum of
⍝           ⊃                           the matrix version of
⍝                         ∘.⌽           the outer-product rotation of
⍝                            ⊂            the scalar version of
⍝                                 ⎕AV⍳    the index in the atomic vector of
⍝                                     ⍞   an input string
⍝                             49-⍨        minus 49 ('0' + 1)
⍝                                       by
⍝             {⍵..-⍵}                     the range ⍵ to -⍵, where ⍵ is
⍝                    ⌊                    the floor of
⍝                     ⎕                   an input integer
⍝                      ÷2                 divided by 2
— ओबेरोन
स्रोत
क्या APL एक वर्ण प्रति बाइट नहीं है, क्योंकि एन्कोडिंग UTF-8 नहीं है? APL APL कोड पेज का उपयोग करता है ।
— mbomb007
@ mbomb007 NARS2000 एपीएल कोड पेज का समर्थन नहीं करता है जहां तक ​​मुझे पता है, और ..आदिम गैर-मानक है और इस तरह "पोर्टेबल" नहीं है।
— ओबेरॉन
क्या शायद Dyalog APL का उपयोग करना कम होगा?
— mbomb007
1

ऑक्टेव, 64 बाइट्स

@(s,n)["" mod(sum(bsxfun(@shift,s'-48,(1:n)-ceil(n/2))'),10)+48]
— alephalpha
स्रोत
1

जे, 41 बाइट्स

"."0@]{~(1":10|+/@:)#@]|-:@<:@[-~(+/&i.#)

मेरी अपेक्षा से अधिक समय बीत गया। गोल्फ होना चाहिए।

हम पदों को दर्शाने वाली एक पंक्ति में उन तत्वों के साथ एक मैट्रिक्स उत्पन्न करते हैं, जिनका मान किसी स्थिति के लिए योग करने के लिए जोड़ा जाना चाहिए (mod 10)।

उपयोग:

   7 ("."0@]{~(1":10|+/@:)#@]|-:@<:@[-~(+/&i.#)) '038'
250

इसे यहाँ ऑनलाइन आज़माएँ।

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