Viết chương trình hoặc hàm lấy số nguyên dương N lẻ và một chuỗi các chữ số thập phân ( 0123456789). Chuỗi đại diện cho một máy tự động tế bào một chiều mười trạng thái . Mỗi chữ số chiếm một ô và quy tắc cập nhật từ thế hệ này sang thế hệ tiếp theo là mọi ô trở thành chữ số kết quả từ tổng số các ô N tập trung vào ô, modulo 10.

Các ô đầu tiên và cuối cùng bao quanh như thể các lân cận, vì vậy các ô luôn có thể có các ô N tập trung vào chúng. Lưu ý rằng N có thể lớn hơn độ dài của chuỗi, có nghĩa là nó có thể bao quanh nhiều lần và một số chữ số sẽ theo tổng số nhiều lần.

Ví dụ, nếu N là 7 và chuỗi là 038, để trực quan hóa các ô để tính tổng, chúng ta có thể viết 038lặp lại vô hạn theo cả hai hướng

...038038038038038...

sau đó chữ số mà ý 0chí sẽ thay đổi thành tổng của 7 chữ số xoay quanh bất kỳ 0, modulo 10:

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

Đây là (0+3+8+0+3+8+0)%10, đó là 2.

Tương tự, các chữ số 3và 8thay đổi thành được xác định bởi (3+8+0+3+8+0+3)%10= 5và (8+0+3+8+0+3+8)%10= 0tương ứng.

Như vậy, thế hệ sau 038là 250khi N bằng 7.

Chương trình hoặc hàm của bạn cần in hoặc trả về chuỗi chữ số của thế hệ tiếp theo của chuỗi chữ số đầu vào. tức là áp dụng quy tắc cập nhật một lần cho mỗi ô và đưa ra đầu ra. Mã ngắn nhất tính bằng byte thắng.

Các trường hợp thử nghiệm

[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

Bình thường, 20 19 byte

1 byte nhờ @FryAmTheEggman.

sm`esmv@z-+dk/Q2Qlz

Hãy thử trực tuyến . Bộ thử nghiệm .

CJam, 21 byte

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

Kiểm tra nó ở đây.

Giải trình

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.

Toán học, 85 byte

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

Python 3, 114 92 86 80 byte

Đã loại bỏ 6 byte nhờ Sp3000 và 6 byte khác nhờ 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)

Xác định một hàm được đặt tên alấy Nvà Dlàm tham số, chuỗi N và chữ số được xác định trong thử thách.

Giải trình

Trong Python 3, andgiữa hai chuỗi sẽ kết thúc là chuỗi sau. Do đó, D[i:]and ...ngắn mạch một khi tất cả các vị trí trung tâm đã được lặp đi lặp lại D[i:]sẽ là một chuỗi trống và do đó sai lệch. (D*N)[(i-N//2)%len(D):][:N]nhân đôi chuỗi chữ số một loạt các lần, sau đó cắt nó ở đúng vị trí để đưa ra chuỗi con có chữ số chính xác làm trung tâm. Nhớ lại một lúc rằng tổng các chữ số của một số 10 số cơ bản modulo 9 giống với số của chính nó modulo 9. str(int(...,10)%10)xử lý chuỗi số kết quả như thể nó là cơ sở 11 và lấy modulo 10 còn lại, sau đó chuyển đổi thành chuỗi. Cuối cùng, a(N,D,i+1)chuyển sang vị trí trung tâm tiếp theo. Bởi vì +, một khi đệ quy được thực hiện, tất cả các chữ số kết quả được gộp lại với nhau và trả về.

Haskell, 92 byte

Chuyển đổi chuỗi thực sự tốn kém trong Haskell ...

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

Điều này định nghĩa một hàm infix !, được sử dụng như sau:

> "1234"!3
"7698"

Giải trình

Ở bên phải chúng ta có [div(1-n)2`mod`length x..], đó chỉ là danh sách vô hạn các số nguyên bắt đầu từ (1-n)/2modulo length(x)(chúng ta lấy mô đun, vì chúng ta muốn phần tử đầu tiên không âm). Chúng tương ứng với các chỉ số bắt đầu của các vùng lân cận CA. Chúng tôi nén nó xchỉ để có được một danh sách có độ dài chính xác.

Hàm <$>này là phiên bản trung gian của mapvà đối số bên trái của nó là một thành phần hàm được đọc từ phải sang trái. Do đó, đối với mỗi số nguyên trong danh sách trên (được trích xuất bằng fst), chúng tôi thả nhiều ký tự từ cycle x(đó là phép nối vô hạn có thể sao chép x), lấy các nký tự từ phần còn lại, chuyển đổi chúng thành chuỗi và sau đó lấy số nguyên read.pure, lấy tổng của chúng, chuyển đổi chuỗi đó thành chuỗi với showvà lấy ký tự cuối cùng của chuỗi đó, tương ứng với mod 10 còn lại.

NARS2000 APL, 37 ký tự (72 byte)

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

Giải trình:

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

Octave, 64 byte

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

J, 41 byte

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

Hóa ra lâu hơn tôi mong đợi. Nên chơi golf.

Chúng tôi tạo một ma trận với các phần tử trong một hàng hiển thị các vị trí có giá trị được thêm vào (mod 10) để lấy tổng cho một vị trí.

Sử dụng:

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

Hãy thử trực tuyến tại đây.