Informacion

Cada uno de los números del 1 al 9 representa una celda en el vecindario de Moore , siendo 5 la celda central. Entonces:

123
456
789

1={-1,-1} 2={-1, 0} 3={-1, 1}
4={ 0,-1} 5={ 0, 0} 6={ 0, 1} 
7={ 1,-1} 8={ 1, 0} 9={ 1, 1}

El reto

Puede tomar datos a través de STDIN, ARGV o argumento de función y devolver el resultado o imprimirlo en STDOUT. La entrada es una cuadrícula N x N (topología de toro, lo que significa que si x o y es <1, entonces x o y = N, y si x o y> N, entonces x o y = 1), y su programa debe generar una interacción de eso cuadrícula reemplazando cada celda con el valor en su celda Moore's Neighborhood.

Ejemplo de cuadrícula de entrada (2 x 2):

13
79

Salida:

97
31

Explicación:

Comenzando en la posición 1,1 tenemos el valor 1, ya que el valor 1 = {- 1, -1} tenemos que recuperar 1 + (- 1), 1 + (- 1) = 0,0. Y debido a que es un toro 0,0, nos ajustamos a N. Entonces recuperamos el valor de la celda en la posición 1,1 (1) con el valor de la celda en la posición 2,2 (9).

Para la siguiente celda 1,2 tenemos el valor 3 (= -1, 1), entonces 1 + (- 1), 2 + (1) = 0,3. Se ajusta a 2,1, que es el valor 7.

El siguiente valor de celda en 2,1 es 7 (= 1, -1), entonces 2+ (1), 1 + (- 1) = 3,0. Se ajusta a 1,2, que es el valor 3.

El siguiente valor de celda en 2,2 es 9 (= 1, 1), entonces 2+ (1), 2 + (1) = 3,3. Se ajusta a 1,1, que es el valor 1.

Más ejemplos

Cuadrícula de entrada (3 x 3):

123
456
789

Rendimiento esperado:

987
654
321

Cuadrícula de entrada (5 x 5):

77497
81982
32236
96336
67811

Rendimiento esperado:

28728
37337
11923
73369
77433

Notas finales

Si tiene alguna pregunta, no dude en comentar. Este es un desafío de código de golf, ¡el código más corto gana!

APL (33)

APL fue hecho para esto. Esta es una función que toma la cuadrícula de entrada como una matriz N-por-N y devuelve la cuadrícula de salida como una matriz N-por-N.

{(⍳⍴⍵)⌷¨(,∆∘.⊖(∆←2-⌽⍳3)∘.⌽⊂⍵)[⍵]}

Prueba:

      ⍝ define input matrices
      ∆1 ← ↑(1 3)(7 9)
      ∆2 ← ↑(1 2 3)(4 5 6)(7 8 9)
      ∆3 ← ↑(7 7 4 9 7)(8 1 9 8 2)(3 2 2 3 6)(9 6 3 3 6)(6 7 8 1 1)
      ⍝ show input matrices
      ∆1 ∆2 ∆3
 1 3  1 2 3  7 7 4 9 7 
 7 9  4 5 6  8 1 9 8 2 
      7 8 9  3 2 2 3 6 
             9 6 3 3 6 
             6 7 8 1 1 
      ⍝ apply function to input matrices giving output matrices
      {(⍳⍴⍵)⌷¨(,∆∘.⊖(∆←2-⌽⍳3)∘.⌽⊂⍵)[⍵]} ¨ ∆1 ∆2 ∆3
 9 7  9 8 7  2 8 7 2 8 
 3 1  6 5 4  3 7 3 3 7 
      3 2 1  1 1 9 2 3 
             7 3 3 6 9 
             7 7 4 3 3 

Python, 174

def t(b):b=b.split("\n");E=enumerate;C=[-1]*3+[0]*3+[1]*3+[-1,0,1]*3;print"\n".join("".join(b[(i+C[int(x)-1])%len(b)][(j+C[int(x)+8])%len(y)]for j,x in E(y))for i,y in E(b))

Python no fue hecho para esto ... APL fue!

Python, 105

Toma y devuelve una lista de listas:

def f(a):e=enumerate;n=len(a);return[[a[(y+(v-1)/3-1)%n][(x+(v-1)%3-1)%n]for x,v in e(u)]for y,u in e(a)]

Toma y devuelve una cadena (148 caracteres):

def f(s):
 a=[map(int,l)for l in s.split()];n=len(a);e=enumerate
 for y,u in e(a):print''.join(`a[(y+(v-1)/3-1)%n][(x+(v-1)%3-1)%n]`for x,v in e(u))

MATLAB - 121 bytes

function O=X(I),m=size(I,1);n=3*m;o=-1:1;c=o<2;M=c'*o+n*o'*c;D=repmat(I,3);C=D;C(:)=1:n*n;t=m+(1:m);O=C+M(D);O=D(O(t,t));

MATLAB estaba un poco menos hecho para esto que APL, pero un poco más hecho para esto que Python. ;)

Prueba de salida

X( [1 2 3; 4 5 6; 7 8 9] )

ans =

     9     8     7
     6     5     4
     3     2     1

X( [7 7 4 9 7; 8 1 9 8 2; 3 2 2 3 6; 9 6 3 3 6; 6 7 8 1 1] )

ans =

     2     8     7     2     8
     3     7     3     3     7
     1     1     9     2     3
     7     3     3     6     9
     7     7     4     3     3