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 038
unendlich viele Wiederholungen in beide Richtungen schreiben
...038038038038038...
dann ist die Stelle, in die sich der 0
Wille ändert, die Summe der 7 Stellen, die um ein beliebiges 0
Modulo 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 3
und 8
ändern, durch (3+8+0+3+8+0+3)%10
= 5
bzw. (8+0+3+8+0+3+8)%10
= definiert 0
.
Somit wird , nachdem die Erzeugung 038
ist , 250
wenn 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
quelle
Antworten:
Pyth,
20 bis19 Bytes1 Byte danke an @FryAmTheEggman.
Probieren Sie es online aus . Testsuite .
quelle
e<num>
entspricht%<num>T
CJam, 21 Bytes
Teste es hier.
Erläuterung
quelle
Mathematica, 85 Bytes
quelle
.5
anstelle von verwenden1/2
?Python 3,
114928680 Bytes6 Bytes dank Sp3000 und weitere 6 Bytes dank xnor !
Definiert eine benannte Funktion ,
a
die nimmtN
undD
als Parameter, die N und Ziffernfolge in der Herausforderung definiert.Erläuterung
In Python 3 werden
and
zwei Zeichenfolgen letztere sein. DaherD[i:]and ...
wurden Kurzschlüsse einmal alle Mittelpositionen iteriert wieD[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ßlicha(N,D,i+1)
zur nächsten Mittelposition über. Aufgrund dessen+
werden nach Abschluss der Rekursion alle resultierenden Ziffern zusammengefasst und zurückgegeben.quelle
Haskell, 92 Bytes
Die Stringkonvertierung ist in Haskell sehr teuer ...
Dies definiert eine Infix-Funktion
!
, die wie folgt verwendet wird: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)/2
Modulolength(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 mitx
nur um eine Liste der richtigen Länge zu erhalten.Die Funktion
<$>
ist die Infix-Version vonmap
und ihr linkes Argument ist eine Funktionszusammensetzung, die von rechts nach links gelesen wird. Also lassenfst
wir für jede Ganzzahl in der obigen Liste (extrahiert mit ) so viele Zeichen wegcycle x
(was die Verkettung von unendlich vielen Kopien von istx
), nehmenn
Zeichen aus dem Rest, konvertieren sie in Zeichenfolgen und dann Ganzzahlen mitread.pure
, nehmen ihre Summe, konvertiere das in einen String mitshow
und nimm das letzte Zeichen davon, das dem Rest von Mod 10 entspricht.quelle
NARS2000 APL, 37 Zeichen (72 Byte)
Erläuterung:
quelle
..
standardgemäß und daher nicht "portabel".Oktave, 64 Bytes
quelle
J, 41 Bytes
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:
Probieren Sie es hier online aus.
quelle