Tek bir pozitif tamsayı N ve bir ondalık basamak dizesi ( 0123456789) alan bir program veya işlev yazın . Dize, on durumlu tek boyutlu bir hücresel otomatı temsil eder . Her basamak bir hücreyi işgal eder ve bir nesilden diğerine güncelleme kuralı, her hücrenin, modulo 10 üzerinde merkezlenen N hücrelerinin toplamından kaynaklanan basamak haline gelmesidir.

İlk ve son hücreler komşularmış gibi sarılır, böylece hücrelerin her zaman üzerinde N hücreleri olabilir. N'nin dizenin uzunluğundan daha büyük olabileceğine dikkat edin, bu da birden çok kez sarılabileceği ve buna bağlı olarak bazı rakamların toplamda birden çok kez olacağı anlamına gelir.

Örnek olarak, eğer N 7 ve dize ise 038, hücrelerin toplamını görselleştirmek için 038her iki yönde sonsuz tekrar tekrar yazabiliriz

...038038038038038...

o 0zaman değişecek olan rakam 0, herhangi bir modulo 10 etrafında ortalanmış 7 basamağın toplamıdır :

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

Bu, (0+3+8+0+3+8+0)%10öyle 2.

Benzer şekilde parmaklara 3ve 8tanımlanır, değişikliği (3+8+0+3+8+0+3)%10= 5ve (8+0+3+8+0+3+8)%10= 0sırasıyla.

Bu nedenle, üretim sonrası 038bir 250N R7 olduğunda.

Programınızın veya işlevinizin, yeni nesil giriş basamak dizesinin basamak dizesini yazdırması veya döndürmesi gerekir. yani güncelleme kuralını her hücreye bir kez uygulayın ve çıktıyı verin. Bayt cinsinden en kısa kod kazanır.

Test Durumları

[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

Pyth, 20 19 bayt

@FryAmTheEggman sayesinde 1 bayt.

sm`esmv@z-+dk/Q2Qlz

Çevrimiçi deneyin . Test takımı .

CJam, 21 bayt

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

Burada test edin.

açıklama

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.

Mathematica, 85 bayt

""<>ToString/@CellularAutomaton[{Tr@#~Mod~10&,{},#/2-1/2},FromDigits/@Characters@#2]&

Python 3, 114 92 86 80 bayt

Sp3000 sayesinde 6 bayt ve xnor sayesinde 6 bayt aldı !

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)

Meydan okumada tanımlanan N ve basamak dizesini aalan Nve Dparametre olarak alan adlandırılmış bir işlevi tanımlar .

açıklama

Python 3'te, andiki dize arasında sonuncusu olur. Bu nedenle, D[i:]and ...tüm merkez konumlar tekrarlandığında kısa devreler D[i:]boş bir dize ve dolayısıyla sahte olacaktır. (D*N)[(i-N//2)%len(D):][:N]basamak dizesini birkaç kez çoğaltır, sonra doğru basamak olan alt dizeyi merkez olarak vermek için doğru yerlere dilimler. Bir taban 10 numara modulo 9'un rakamlarının toplamının, sayının kendisinin modulo 9 ile aynı olduğunu bir an için hatırlayın str(int(...,10)%10). Sonuçta elde edilen sayı dizesine, taban 11miş gibi davranır ve geri kalan modulo 10'u alır, sonra tekrar dize. Son olarak, bir a(N,D,i+1)sonraki orta konuma geçer. Çünkü +, özyineleme yapıldıktan sonra, elde edilen tüm rakamlar toplanır ve geri döndürülür.

Haskell, 92 bayt

Dize dönüştürme Haskell gerçekten pahalı ...

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

Bu, !aşağıdaki gibi kullanılan bir infix işlevini tanımlar :

> "1234"!3
"7698"

açıklama

Elimizdeki Sağda [div(1-n)2`mod`length x..]başlayarak tamsayılar sadece sonsuz listesini ise, (1-n)/2modülo length(x)(biz ilk eleman negatif olmayan olmak istiyorum çünkü biz, modül almak). Bunlar CA mahallelerinin başlangıç ​​endekslerine karşılık gelir. Biz zip ilex doğru uzunlukta bir listesini elde etmek sadece.

İşlev <$>, infix sürümüdür mapve sol argümanı sağdan sola okunan bir işlev bileşimidir. Böylece (ile ekstrakte yukarıdaki listedeki her tamsayı için fst), biz o sayıda karakter damla cycle x(sonsuz kopyaları olabilir oluşan birleşik olan x, almak) ngeri kalan karakterleri, dizeleri onları dönüştürmek ve daha sonra tamsayılar read.pure, onların toplamını almak, bunu dizeye dönüştürün showve kalan mod 10'a karşılık gelen son karakterini alın.

NARS2000 APL, 37 karakter (72 bayt)

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

Açıklama:

  ⎕←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

Oktav, 64 bayt

@(s,n)["" mod(sum(bsxfun(@shift,s'-48,(1:n)-ceil(n/2))'),10)+48]

J, 41 bayt

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

Beklediğimden daha uzun sürdü. Golf edilebilir olmalı.

Bir konumun toplamını almak için değerleri eklenmesi gereken konumları (mod 10) gösteren bir satırdaki öğeleri içeren bir matris üretiriz.

Kullanımı:

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

Burada çevrimiçi deneyin.