Scrivi un programma o una funzione che accetta un numero intero dispari positivo N e una stringa di cifre decimali ( 0123456789). La stringa rappresenta un automa cellulare unidimensionale a dieci stati . Ogni cifra occupa una cella e la regola di aggiornamento da una generazione alla successiva è che ogni cella diventa la cifra risultante dalla somma delle N celle centrate sulla cella, modulo 10.

La prima e l'ultima cella si avvolgono come se fossero vicini, quindi le celle possono sempre avere N celle centrate su di esse. Si noti che N potrebbe essere più grande della lunghezza della stringa, il che significa che potrebbe avvolgersi più volte e che alcune cifre saranno pertanto nella somma più volte.

Ad esempio, se N è 7 e la stringa è 038, per visualizzare le celle per riassumere possiamo scrivere 038ripetendo all'infinito in entrambe le direzioni

...038038038038038...

quindi la cifra in cui 0cambierà è la somma delle 7 cifre centrate attorno a qualsiasi 0, modulo 10:

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

Questo è (0+3+8+0+3+8+0)%10, che è 2.

Allo stesso modo le cifre in 3e 8cambiano in sono definite rispettivamente da (3+8+0+3+8+0+3)%10= 5e (8+0+3+8+0+3+8)%10= 0.

Pertanto, la generazione successiva 038è 250quando N è 7.

Il programma o la funzione deve stampare o restituire la stringa di cifre della generazione della stringa di input immediatamente successiva. cioè applicare la regola di aggiornamento una volta per ogni cella e fornire l'output. Vince il codice più breve in byte.

Casi test

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

1 byte grazie a @FryAmTheEggman.

sm`esmv@z-+dk/Q2Qlz

Provalo online . Suite di test .

CJam, 21 byte

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

Provalo qui.

Spiegazione

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 byte

""<>ToString/@CellularAutomaton[{Tr@#~Mod~10&,{},#/2-1/2},FromDigits/@Characters@#2]&

Python 3, 114 92 86 80 byte

Ha tolto 6 byte grazie a Sp3000 e altri 6 byte grazie 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)

Definisce una funzione con nome ache accetta Ne, Dcome parametri, la stringa N e digit definita nella sfida.

Spiegazione

In Python 3, andtra due stringhe finirà per essere il secondo. Quindi, i D[i:]and ...cortocircuiti una volta ripetute tutte le posizioni centrali come D[i:]sarà una stringa vuota e quindi falsa. (D*N)[(i-N//2)%len(D):][:N]duplica un numero di volte la stringa di cifre, quindi la suddivide nei punti giusti per fornire la sottostringa che ha la cifra corretta come centro. Ricordiamo per un momento che la somma delle cifre di un numero di base 10 modulo 9 è la stessa del numero stesso modulo 9. str(int(...,10)%10)considera la stringa numerica risultante come se fosse la base 11 e ottiene il resto modulo 10, quindi converte nuovamente in corda. Infine, a(N,D,i+1)passa alla posizione centrale successiva. A causa di +, una volta effettuata la ricorsione, tutte le cifre risultanti vengono raggruppate insieme e restituite.

Haskell, 92 byte

La conversione delle stringhe è davvero costosa in Haskell ...

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

Questo definisce una funzione infix !, utilizzata come segue:

> "1234"!3
"7698"

Spiegazione

Sulla destra abbiamo [div(1-n)2`mod`length x..], che è solo l'elenco infinito di numeri interi che iniziano dal (1-n)/2modulo length(x)(prendiamo il modulo, poiché vogliamo che il primo elemento sia non negativo). Questi corrispondono agli indici di partenza dei quartieri della CA. Lo comprimiamo xsolo per ottenere un elenco della lunghezza corretta.

La funzione <$>è la versione infix di mape il suo argomento di sinistra è una composizione di funzioni letta da destra a sinistra. Pertanto, per ogni numero intero nell'elenco precedente (estratto con fst), eliminiamo che molti caratteri da cycle x(che è la concatenazione di copie di infinitamente possono x), prendono i ncaratteri dal resto, li convertono in stringhe e quindi i numeri interi con read.pure, prendono la loro somma, convertilo in stringa con showe prendi l'ultimo carattere di quello, che corrisponde al resto mod 10.

APL NARS2000, 37 caratteri (72 byte)

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

Spiegazione:

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

Ottava, 64 byte

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

J, 41 byte

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

È risultato più lungo di quanto mi aspettassi. Dovrebbe essere golfabile.

Generiamo una matrice con elementi in una riga che mostra le posizioni i cui valori dovrebbero essere aggiunti (mod 10) per ottenere la somma per una posizione.

Uso:

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

Provalo online qui.