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 038
repetidamente infinitamente en ambas direcciones
...038038038038038...
entonces el dígito en el 0
que 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)%10
que es 2
.
De manera similar, los dígitos en los que 3
y 8
cambian están definidos por (3+8+0+3+8+0+3)%10
= 5
y (8+0+3+8+0+3+8)%10
= 0
respectivamente.
Por lo tanto, la generación posterior 038
es 250
cuando 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
fuente
Respuestas:
Pyth,
2019 bytes1 byte gracias a @FryAmTheEggman.
Pruébalo en línea . Banco de pruebas .
fuente
e<num>
es equivalente a%<num>T
CJam, 21 bytes
Pruébalo aquí.
Explicación
fuente
Mathematica, 85 bytes
fuente
.5
lugar de1/2
?Python 3,
114928680 bytes¡Despegó 6 bytes gracias a Sp3000 y otros 6 bytes gracias a xnor !
Define una función con nombre
a
que tomaN
yD
como parámetros, la cadena de N y dígitos definida en el desafío.Explicación
En Python 3,
and
entre dos cadenas terminará siendo la última. Por lo tanto,D[i:]and ...
los cortocircuitos una vez que todas las posiciones centrales se han iterado, yaD[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.fuente
Haskell, 92 bytes
La conversión de cadenas es realmente costosa en Haskell ...
Esto define una función infija
!
, utilizada de la siguiente manera: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)/2
módulolength(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 comprimimosx
solo para obtener una lista de la longitud correcta.La función
<$>
es la versión infija demap
, 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 confst
), eliminamos esa cantidad de caracteres decycle x
(que es la concatenación de infinitas copias de mayox
), tomamosn
caracteres del resto, los convertimos en cadenas y luego enteros conread.pure
, tomamos su suma, Convierta eso en una cadena conshow
, y tome el último carácter de eso, que corresponde al resto del mod 10.fuente
NARS2000 APL, 37 caracteres (72 bytes)
Explicación:
fuente
..
primitiva no es estándar y, por lo tanto, no es "portátil".Octava, 64 bytes
fuente
J, 41 bytes
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:
Pruébelo en línea aquí.
fuente