编写一个程序或函数，该程序或函数需要一个奇数正整数N和一串十进制数字（0123456789）。该字符串表示十状态一维元胞自动机。每个数字占用一个单元，并且从一代到下一代的更新规则是，每个单元成为由以该单元为中心的N个单元的总和取模得到的数字。

第一个和最后一个单元像邻居一样环绕，因此单元始终可以将N个单元居中。请注意，N可能大于字符串的长度，这意味着它可能会多次缠绕，因此某些数字将多次相加。

例如，如果N为7且字符串为038，为使单元格可视化，我们可以038在两个方向上无限重复地写

...038038038038038...

则将0变为的数字是以010 为模的任意7个数字的总和：

...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当N为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

Pyth，20个 19字节

1个字节，感谢@FryAmTheEggman。

sm`esmv@z-+dk/Q2Qlz

在线尝试。测试套件。

CJam，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.

Mathematica，85个字节

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

Python 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作为参数，N和数字串中的挑战来定义。

说明

在Python 3中，and两个字符串之间将最终成为后者。因此，D[i:]and ...一旦所有中心位置都被迭代，则短路，这D[i:]将是一个空字符串，因此是虚假的。(D*N)[(i-N//2)%len(D):][:N]将数字字符串重复多次，然后在正确的位置对其进行切片，以给出以正确数字为中心的子字符串。回想一下，以10为底的模9的数字总和与以数字9为模的数字本身相同。str(int(...,10)%10)将所得的数字字符串视为以11为底，然后得到余数以10为模，然后转换回串。最后，a(N,D,i+1)移至下一个中心位置。由于的原因+，一旦完成递归，所有得到的数字将集中在一起并返回。

Haskell，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仅用zip压缩以获得正确长度的列表。

该函数<$>是的中缀版本map，其左参数是从右到左读取的函数组成。因此，对于上述列表中的每个整数（用提取fst），我们从中删除了许多字符cycle x（这是的无穷多个可能的副本的串联x），n从其余字符中提取字符，将其转换为字符串，然后使用read.pure，将其整数取和，使用将其转换为字符串show，并采用该字符的最后一个字符，该字符对应于其余的mod 10。

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

八度，64字节

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

J，41个字节

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

结果比我预期的更长。应该是可打高尔夫球的。

我们生成一个矩阵，其中的元素在一行中显示了位置，这些位置的值应相加（mod 10）以获取位置的总和。

用法：

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

在这里在线尝试。