เขียนโปรแกรมหรือฟังก์ชั่นที่ใช้ในจำนวนเต็มบวกคี่และสตริงของเลขทศนิยม ( 0123456789) สตริงหมายถึงสิบรัฐหนึ่งมิติเซลล์หุ่นยนต์ แต่ละหลักครอบครองหนึ่งเซลล์และกฎการอัปเดตจากรุ่นหนึ่งไปยังอีกรุ่นหนึ่งคือทุกเซลล์กลายเป็นตัวเลขที่เกิดจากผลรวมของเซลล์ N ที่มีศูนย์กลางอยู่ที่เซลล์ modulo 10

เซลล์แรกและเซลล์สุดท้ายล้อมรอบราวกับว่าเพื่อนบ้านดังนั้นเซลล์จึงสามารถมีเซลล์ N อยู่กึ่งกลางได้ โปรดทราบว่า N อาจมีขนาดใหญ่กว่าความยาวของสตริงซึ่งหมายความว่ามันสามารถพันได้หลายครั้งและบางหลักจะอยู่ในผลรวมหลายครั้ง

ตัวอย่างเช่นถ้า N คือ 7 และสตริงคือ038เพื่อให้เห็นภาพของเซลล์เพื่อหาผลรวมเราสามารถเขียน038ซ้ำแบบไม่สิ้นสุดในทั้งสองทิศทาง

...038038038038038...

ดังนั้นตัวเลขที่0จะเปลี่ยนเป็นผลรวมของ 7 หลักอยู่ที่ใด ๆ0โมดูโล 10:

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

นี่คือซึ่งเป็น(0+3+8+0+3+8+0)%102

ในทำนองเดียวกันตัวเลข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 ฐาน 10 นั้นเหมือนกับโมดูโลของตัวมันเอง 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เพียงเพื่อให้ได้รายการความยาวที่ถูกต้อง

ฟังก์ชั่น<$>เป็นรุ่นของ infix mapและอาร์กิวเมนต์ซ้ายของมันคือองค์ประกอบของฟังก์ชั่นที่อ่านจากขวาไปซ้าย ดังนั้นสำหรับแต่ละจำนวนเต็มในรายการข้างต้น (แยกด้วยfst) เราวางที่ตัวละครจำนวนมากจากcycle x(ซึ่งเป็น concatenation ของอนันต์อาจคัดลอกของ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

ลองออนไลน์ได้ที่นี่