Escriba un programa o función que tome un entero positivo impar N y una cadena de dígitos decimales ( 0123456789). La cadena representa un autómata celular unidimensional de diez estados . Cada dígito ocupa una celda y la regla de actualización de una generación a la siguiente es que cada celda se convierte en el dígito resultante de la suma de las N celdas centradas en la celda, módulo 10.

La primera y la última celda se envuelven como si fueran vecinas, por lo que las celdas siempre pueden tener N celdas centradas en ellas. Tenga en cuenta que N puede ser mayor que la longitud de la cadena, lo que significa que podría ajustarse varias veces y, en consecuencia, algunos dígitos estarán en la suma varias veces.

Como ejemplo, si N es 7 y la cadena es 038, para visualizar las celdas para sumar podemos escribir 038repetidamente infinitamente en ambas direcciones

...038038038038038...

entonces el dígito en el 0que cambiará es la suma de los 7 dígitos centrados alrededor de cualquiera 0, módulo 10:

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

Esto es lo (0+3+8+0+3+8+0)%10que es 2.

De manera similar, los dígitos en los que 3y 8cambian están definidos por (3+8+0+3+8+0+3)%10= 5y (8+0+3+8+0+3+8)%10= 0respectivamente.

Por lo tanto, la generación posterior 038es 250cuando N es 7.

Su programa o función necesita imprimir o devolver la cadena de dígitos de la próxima generación de la cadena de dígitos de entrada. es decir, aplique la regla de actualización una vez a cada celda y proporcione el resultado. El código más corto en bytes gana.

Casos de prueba

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

1 byte gracias a @FryAmTheEggman.

sm`esmv@z-+dk/Q2Qlz

Pruébalo en línea . Banco de pruebas .

CJam, 21 bytes

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

Pruébalo aquí.

Explicación

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

¡Despegó 6 bytes gracias a Sp3000 y otros 6 bytes gracias a 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)

Define una función con nombre aque toma Ny Dcomo parámetros, la cadena de N y dígitos definida en el desafío.

Explicación

En Python 3, andentre dos cadenas terminará siendo la última. Por lo tanto, D[i:]and ...los cortocircuitos una vez que todas las posiciones centrales se han iterado, ya D[i:]que será una cadena vacía y, por lo tanto, falsa. (D*N)[(i-N//2)%len(D):][:N]duplica la cadena de dígitos varias veces, luego la corta en los lugares correctos para dar la subcadena que tiene el dígito correcto como centro. Recuerde por un momento que la suma de los dígitos de un número de base 10 módulo 9 es la misma que el número en sí mismo módulo 9. str(int(...,10)%10)trata la cadena numérica resultante como si fuera la base 11 y obtiene el módulo 10 restante, luego vuelve a convertir a cuerda. Finalmente, a(N,D,i+1)pasa a la siguiente posición central. Debido a que +, una vez que se realiza la recursión, todos los dígitos resultantes se agrupan y se devuelven.

Haskell, 92 bytes

La conversión de cadenas es realmente costosa en Haskell ...

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

Esto define una función infija !, utilizada de la siguiente manera:

> "1234"!3
"7698"

Explicación

A la derecha tenemos [div(1-n)2`mod`length x..], que es solo la lista infinita de enteros que comienzan desde el (1-n)/2módulo length(x)(tomamos el módulo, ya que queremos que el primer elemento no sea negativo). Estos corresponden a los índices iniciales de los vecindarios de California. Lo comprimimos xsolo para obtener una lista de la longitud correcta.

La función <$>es la versión infija de map, y su argumento izquierdo es una composición de función leída de derecha a izquierda. Por lo tanto, para cada número entero en la lista anterior (extraído con fst), eliminamos esa cantidad de caracteres de cycle x(que es la concatenación de infinitas copias de mayo x), tomamos ncaracteres del resto, los convertimos en cadenas y luego enteros con read.pure, tomamos su suma, Convierta eso en una cadena con show, y tome el último carácter de eso, que corresponde al resto del mod 10.

NARS2000 APL, 37 caracteres (72 bytes)

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

Explicación:

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

Octava, 64 bytes

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

J, 41 bytes

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

Resultó más de lo que esperaba. Debería ser golfable.

Generamos una matriz con elementos en una fila que muestra las posiciones cuyos valores deben agregarse (mod 10) para obtener la suma de una posición.

Uso:

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

Pruébelo en línea aquí.