Schreiben Sie ein Programm oder eine Funktion, die eine ungerade positive Ganzzahl N und eine Folge von Dezimalstellen ( 0123456789) enthält. Die Zeichenfolge repräsentiert einen eindimensionalen Zellularautomaten mit zehn Zuständen . Jede Ziffer belegt eine Zelle, und die Aktualisierungsregel von einer Generation zur nächsten lautet, dass jede Zelle die Ziffer wird, die sich aus der Summe der N auf der Zelle zentrierten Zellen Modulo 10 ergibt.

Die ersten und letzten Zellen werden wie Nachbarn umgebrochen, sodass auf Zellen immer N Zellen zentriert sein können. Beachten Sie, dass N möglicherweise größer als die Länge der Zeichenfolge ist. Dies bedeutet, dass die Zeichenfolge mehrfach umgebrochen werden kann und einige Ziffern dementsprechend mehrfach in der Summe enthalten sind.

Wenn beispielsweise N 7 ist und die Zeichenfolge 7 ist 038, können wir zur Visualisierung der zu summierenden Zellen 038unendlich viele Wiederholungen in beide Richtungen schreiben

...038038038038038...

dann ist die Stelle, in die sich der 0Wille ändert, die Summe der 7 Stellen, die um ein beliebiges 0Modulo 10 zentriert sind :

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

Das ist (0+3+8+0+3+8+0)%10, was ist 2.

In ähnlicher Weise werden die Ziffern, in die sich 3und 8ändern, durch (3+8+0+3+8+0+3)%10= 5bzw. (8+0+3+8+0+3+8)%10= definiert 0.

Somit wird , nachdem die Erzeugung 038ist , 250wenn N 7 ist.

Ihr Programm oder Ihre Funktion muss die Ziffernfolge der nächsten Generation der eingegebenen Ziffernfolge drucken oder zurückgeben. Wenden Sie die Aktualisierungsregel einmal auf jede Zelle an und geben Sie die Ausgabe aus. Der kürzeste Code in Bytes gewinnt.

Testfälle

[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 bis 19 Bytes

1 Byte danke an @FryAmTheEggman.

sm`esmv@z-+dk/Q2Qlz

Probieren Sie es online aus . Testsuite .

CJam, 21 Bytes

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

Teste es hier.

Erläuterung

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 Bytes

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

Python 3, 114 92 86 80 Bytes

6 Bytes dank Sp3000 und weitere 6 Bytes dank 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)

Definiert eine benannte Funktion , adie nimmt Nund Dals Parameter, die N und Ziffernfolge in der Herausforderung definiert.

Erläuterung

In Python 3 werden andzwei Zeichenfolgen letztere sein. Daher D[i:]and ...wurden Kurzschlüsse einmal alle Mittelpositionen iteriert wie D[i:]wird ein leerer String und daher falsy sein. (D*N)[(i-N//2)%len(D):][:N]dupliziert die Ziffernfolge ein paarmal und schneidet sie dann an den richtigen Stellen, um die Teilzeichenfolge zu erhalten, die die richtige Ziffer als Mittelpunkt hat. Erinnern Sie sich für einen Moment daran, dass die Summe der Ziffern einer Zahl modulo 9 zur Basis 10 mit der Zahl modulo 9 identisch ist. str(int(...,10)%10)Die resultierende Zahlenfolge wird so behandelt, als ob sie zur Basis 11 gehörte, und der Rest modulo 10 wird zurück in konvertiert Zeichenfolge. Geht schließlich a(N,D,i+1)zur nächsten Mittelposition über. Aufgrund dessen +werden nach Abschluss der Rekursion alle resultierenden Ziffern zusammengefasst und zurückgegeben.

Haskell, 92 Bytes

Die Stringkonvertierung ist in Haskell sehr teuer ...

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

Dies definiert eine Infix-Funktion !, die wie folgt verwendet wird:

> "1234"!3
"7698"

Erläuterung

Rechts haben wir [div(1-n)2`mod`length x..], das ist nur die unendliche Liste von ganzen Zahlen, beginnend mit (1-n)/2Modulo length(x)(wir nehmen den Modul, da wir wollen, dass das erste Element nicht negativ ist). Diese entsprechen den Startindizes der CA-Stadtteile. Wir zippen es mit xnur um eine Liste der richtigen Länge zu erhalten.

Die Funktion <$>ist die Infix-Version von mapund ihr linkes Argument ist eine Funktionszusammensetzung, die von rechts nach links gelesen wird. Also lassen fstwir für jede Ganzzahl in der obigen Liste (extrahiert mit ) so viele Zeichen weg cycle x(was die Verkettung von unendlich vielen Kopien von ist x), nehmen nZeichen aus dem Rest, konvertieren sie in Zeichenfolgen und dann Ganzzahlen mit read.pure, nehmen ihre Summe, konvertiere das in einen String mit showund nimm das letzte Zeichen davon, das dem Rest von Mod 10 entspricht.

NARS2000 APL, 37 Zeichen (72 Byte)

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

Erläuterung:

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

Oktave, 64 Bytes

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

J, 41 Bytes

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

Länger ausgefallen als ich erwartet hatte. Sollte golffähig sein.

Wir erzeugen eine Matrix mit Elementen in einer Reihe, die die Positionen zeigt, deren Werte addiert werden sollen (Mod 10), um die Summe für eine Position zu erhalten.

Verwendung:

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

Probieren Sie es hier online aus.