Tulis program atau fungsi yang mengambil dalam bilangan bulat positif N dan serangkaian angka desimal ( 0123456789). Tali mewakili otomat seluler satu dimensi sepuluh negara . Setiap digit menempati satu sel dan aturan pembaruan dari satu generasi ke generasi berikutnya adalah bahwa setiap sel menjadi digit yang dihasilkan dari jumlah sel N yang berpusat pada sel, modulo 10.

Sel pertama dan terakhir membungkus seolah-olah tetangga, sehingga sel selalu dapat memiliki sel N yang berpusat padanya. Perhatikan bahwa N mungkin lebih besar dari panjang string, yang berarti N dapat membungkus beberapa kali dan beberapa digit karenanya akan menjadi jumlah beberapa kali.

Sebagai contoh, jika N adalah 7 dan string adalah 038, untuk memvisualisasikan sel untuk dijumlahkan, kita dapat menulis 038berulang di kedua arah

...038038038038038...

maka digit yang 0akan diubah menjadi jumlah dari 7 digit yang berpusat di sekitar sembarang 0, modulo 10:

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

Ini (0+3+8+0+3+8+0)%10, yang 2.

Demikian pula digit 3dan 8berubah menjadi didefinisikan oleh (3+8+0+3+8+0+3)%10= 5dan (8+0+3+8+0+3+8)%10= 0masing-masing.

Jadi, generasi berikutnya 038adalah 250ketika N adalah 7.

Program atau fungsi Anda perlu mencetak atau mengembalikan string digit generasi berikutnya dari string digit input. yaitu menerapkan aturan pembaruan satu kali untuk setiap sel dan memberikan output. Kode terpendek dalam byte menang.

Uji Kasus

[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 byte

1 byte terima kasih kepada @FryAmTheEggman.

sm`esmv@z-+dk/Q2Qlz

Cobalah online . Suite uji .

CJam, 21 byte

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

Uji di sini.

Penjelasan

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 byte

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

Python 3, 114 92 86 80 byte

Melepas 6 byte berkat Sp3000 dan 6 byte lainnya berkat 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)

Menentukan fungsi bernama ayang mengambil Ndan Dsebagai parameter, string N dan digit yang didefinisikan dalam tantangan.

Penjelasan

Dalam Python 3, andantara dua string akan menjadi yang terakhir. Oleh karena itu, D[i:]and ...hubung singkat begitu semua posisi tengah telah diiterasi karena D[i:]akan menjadi string kosong dan karenanya palsu. (D*N)[(i-N//2)%len(D):][:N]menduplikasi string digit beberapa kali, kemudian mengirisnya di tempat yang tepat untuk memberikan substring yang memiliki digit yang benar sebagai pusat. Ingat sejenak bahwa jumlah digit basis 10 nomor modulo 9 sama dengan jumlah itu sendiri modulo 9. str(int(...,10)%10)memperlakukan string angka yang dihasilkan seolah-olah basis 11 dan mendapatkan sisa modulo 10, kemudian mengkonversi kembali ke tali. Akhirnya, a(N,D,i+1)pindah ke posisi tengah berikutnya. Karena itu +, setelah rekursi selesai, semua digit yang dihasilkan disatukan dan dikembalikan.

Haskell, 92 byte

Konversi string sangat mahal di Haskell ...

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

Ini mendefinisikan fungsi infiks !, digunakan sebagai berikut:

> "1234"!3
"7698"

Penjelasan

Di sebelah kanan yang kita miliki [div(1-n)2`mod`length x..], yang hanya daftar bilangan bulat mulai dari (1-n)/2modulo length(x)(kita mengambil modulus, karena kita ingin elemen pertama menjadi non-negatif). Ini sesuai dengan indeks awal dari lingkungan CA. Kami mengatasinya denganx hanya untuk mendapatkan daftar panjang yang benar.

Fungsinya <$>adalah versi infiks map, dan argumen kirinya adalah komposisi fungsi yang dibaca dari kanan ke kiri. Jadi untuk setiap bilangan bulat dalam daftar di atas (diekstraksi dengan fst), kami menjatuhkan banyak karakter dari cycle x(yang merupakan gabungan dari salinan tak terhingga dari x), mengambil nkarakter dari sisanya, mengubahnya menjadi string dan kemudian integer dengan read.pure, ambil jumlah mereka, mengonversi itu menjadi string dengan show, dan mengambil karakter terakhir dari itu, yang sesuai dengan sisa mod 10.

NARS2000 APL, 37 karakter (72 byte)

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

Penjelasan:

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

Oktaf, 64 byte

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

J, 41 byte

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

Ternyata lebih lama dari yang saya harapkan. Harus golf.

Kami menghasilkan matriks dengan elemen dalam baris yang menunjukkan posisi yang nilainya harus ditambahkan (mod 10) untuk mendapatkan jumlah untuk suatu posisi.

Pemakaian:

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

Cobalah online di sini.