Digital Cellular Automata

17

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
Calvins Hobbys
quelle
@ LegionMammal978 Lasst es uns als String behalten.
Calvins Hobbys
@ LegionMammal978 Nein. Ich gebe zu, ich hätte es ursprünglich zulassen können, aber jetzt würde dies bestehende Antworten, die Zeichenfolgen verwenden, in unfairer Weise beeinflussen.
Calvins Hobbys
Vielen

Antworten:

10

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.
Martin Ender
quelle
5

Mathematica, 85 Bytes

""<>ToString/@CellularAutomaton[{Tr@#~Mod~10&,{},#/2-1/2},FromDigits/@Characters@#2]&
LegionMammal978
quelle
Können Sie .5anstelle von verwenden 1/2?
mbomb007
@ mbomb007 Nein, es muss eine Ganzzahl sein.
LegionMammal978
4

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.

El'endia Starman
quelle
3

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.

Zgarb
quelle
2

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
Oberon
quelle
Ist APL nicht ein Byte pro Zeichen, da die Codierung nicht UTF-8 ist? APL verwendet die APL-Codepage .
mbomb007
@ mbomb007 NARS2000 unterstützt die APL-Codepage meines Wissens nicht, und das Grundelement ist nicht ..standardgemäß und daher nicht "portabel".
Oberon
Wäre es vielleicht kürzer, Dyalog APL zu verwenden?
mbomb007
1

Oktave, 64 Bytes

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

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.

randomra
quelle