Informazioni

I numeri da 1 a 9 rappresentano ciascuno una cella nel vicinato di Moore , con 5 che è la cella centrale. Così:

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}

La sfida

È possibile accettare input tramite STDIN, ARGV o argomento della funzione e restituire il risultato o stamparlo su STDOUT. L'input è una griglia N x N (topologia del toro, ovvero se x o y è <1 quindi x o y = N e se x o y> N quindi x o y = 1) e il programma deve generare un'interazione di quella griglia sostituendo ogni cella con il valore nella cella di vicinato di Moore.

Esempio di griglia di input (2 x 2):

13
79

Produzione:

97
31

Spiegazione:

A partire dalla posizione 1,1 abbiamo il valore 1, poiché il valore 1 = {- 1, -1} dobbiamo recuperare 1 + (- 1), 1 + (- 1) = 0,0. E poiché è un toro 0,0 ci spostiamo su N. Quindi recuperiamo il valore della cella nella posizione 1,1 (1) con il valore della cella nella posizione 2,2 (9).

Per la cella successiva 1,2 abbiamo valore 3 (= -1, 1) quindi 1 + (- 1), 2 + (1) = 0,3. Si avvolge intorno a 2,1 che è il valore 7.

Il valore della cella successiva a 2,1 è 7 (= 1, -1) quindi 2+ (1), 1 + (- 1) = 3,0. Si avvolge intorno a 1,2 che è il valore 3.

Il valore della cella successiva a 2,2 è 9 (= 1, 1) quindi 2+ (1), 2 + (1) = 3,3. Si avvolge intorno a 1,1 che è il valore 1.

Altri esempi

Griglia di input (3 x 3):

123
456
789

Uscita prevista:

987
654
321

Griglia di input (5 x 5):

77497
81982
32236
96336
67811

Uscita prevista:

28728
37337
11923
73369
77433

Note finali

Se hai qualche domanda, non esitare a commentare. Questa è una sfida del codice golf, vince il codice più corto!

APL (33)

APL è stato creato per questo. Questa è una funzione che accetta la griglia di input come matrice N-by-N e restituisce la griglia di output come matrice N-by-N.

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

Test:

      ⍝ 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 non è stato creato per questo ... APL lo era!

Python, 105

Prende e restituisce un elenco di elenchi:

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)]

Prende e restituisce una stringa (148 caratteri):

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 byte

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 era leggermente meno realizzato per questo di APL, ma leggermente più fatto per questo di Python. ;)

Uscita di prova

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