Escreva um programa ou função que obtenha um número inteiro positivo ímpar N e uma sequência de dígitos decimais ( 0123456789). A string representa um autômato celular unidimensional de dez estados . Cada dígito ocupa uma célula e a regra de atualização de uma geração para a seguinte é que cada célula se torna o dígito resultante da soma das N células centralizadas na célula, módulo 10.

A primeira e a última célula envolvem-se como se fossem vizinhas, para que as células sempre possam ter N células centradas nelas. Observe que N pode ser maior que o comprimento da string, o que significa que ela pode quebrar várias vezes e alguns dígitos estarão na soma várias vezes.

Por exemplo, se N é 7 e a string é 038, para visualizar as células para somar, podemos escrever 038repetindo infinitamente nas duas direções

...038038038038038...

então o dígito em que a 0alteração será convertida é a soma dos 7 dígitos centralizados em qualquer 0módulo 10:

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

Isto é (0+3+8+0+3+8+0)%10, o que é 2.

Da mesma forma, os dígitos 3e os números 8são alterados por (3+8+0+3+8+0+3)%10= 5e (8+0+3+8+0+3+8)%10= 0respectivamente.

Assim, a geração seguinte 038é 250quando N é 7.

Seu programa ou função precisa imprimir ou retornar a sequência de dígitos da próxima geração da sequência de dígitos de entrada. ou seja, aplique a regra de atualização uma vez a cada célula e forneça a saída. O código mais curto em bytes vence.

Casos de teste

[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

Pitão, 20 19 bytes

1 byte graças a @FryAmTheEggman.

sm`esmv@z-+dk/Q2Qlz

Experimente online . Conjunto de teste .

CJam, 21 bytes

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

Teste aqui.

Explicação

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

Decolou 6 bytes graças ao Sp3000 e outros 6 bytes graças ao 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 uma função nomeada aque assume Ne Dcomo parâmetros, a cadeia de caracteres N e dígito definida no desafio.

Explicação

No Python 3, andentre duas strings acabará sendo a última. Portanto, os D[i:]and ...curtos-circuitos, uma vez que todas as posições centrais foram iteradas, D[i:]serão uma string vazia e, portanto, falsas. (D*N)[(i-N//2)%len(D):][:N]duplica a sequência de dígitos várias vezes e as corta nos lugares certos para fornecer a substring que tem o dígito correto como o centro. Lembre-se por um momento que a soma dos dígitos do módulo 9 do número base 10 é igual ao módulo 9 em si. str(int(...,10)%10)Trata a sequência numérica resultante como se fosse a base 11 e obtém o restante módulo 10 e depois converte novamente em corda. Finalmente, a(N,D,i+1)passa para a próxima posição central. Por causa disso +, uma vez que a recursão é feita, todos os dígitos resultantes são agrupados e retornados.

Haskell, 92 bytes

Conversão de string é muito cara em Haskell ...

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

Isso define uma função infix !, usada da seguinte maneira:

> "1234"!3
"7698"

Explicação

À direita, temos [div(1-n)2`mod`length x..], que é apenas a lista infinita de números inteiros começando com o (1-n)/2módulo length(x)(pegamos o módulo, pois queremos que o primeiro elemento seja não negativo). Eles correspondem aos índices iniciais dos bairros da CA. Nós o compactamos xapenas para obter uma lista do comprimento correto.

A função <$>é a versão infix de mape seu argumento esquerdo é uma composição de função lida da direita para a esquerda. Assim, para cada número inteiro na lista acima (extraído com fst), eliminamos muitos caracteres de cycle x(que é a concatenação de infinitas cópias de x), pegamos ncaracteres do restante, os convertemos em strings e, em seguida, números inteiros com read.pure, pegamos sua soma, converta isso em string com showe pegue o último caractere dele, que corresponde ao restante mod 10.

NARS2000 APL, 37 caracteres (72 bytes)

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

Explicação:

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

Oitava, 64 bytes

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

J, 41 bytes

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

Acabou por mais tempo do que eu esperava. Deve ser jogável.

Geramos uma matriz com elementos em uma linha mostrando as posições cujos valores devem ser adicionados (mod 10) para obter soma para uma posição.

Uso:

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

Experimente online aqui.