Info

Les nombres 1 à 9 représentent chacun une cellule dans le quartier de Moore , 5 étant la cellule centrale. Donc:

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}

Le défi

Vous pouvez saisir des données via STDIN, ARGV ou un argument de fonction et renvoyer le résultat ou l'imprimer dans STDOUT. L'entrée est une grille N x N (topologie en tore, ce qui signifie si x ou y est <1, alors x ou y = N, et si x ou y> N, alors x ou y = 1), et votre programme doit produire une interaction de cette en remplaçant chaque cellule par la valeur de sa cellule de quartier de Moore.

Exemple de grille d'entrée (2 x 2):

13
79

Production:

97
31

Explication:

À partir de la position 1,1, nous avons la valeur 1, car la valeur 1 = {- 1, -1}, nous devons récupérer 1 + (- 1), 1 + (- 1) = 0,0. Et parce que c'est un tore 0,0, nous enroulons autour de N. Nous récupérons donc la valeur de la cellule en position 1,1 (1) avec la valeur de la cellule en position 2,2 (9).

Pour la cellule 1,2 suivante, nous avons la valeur 3 (= -1, 1) donc 1 + (- 1), 2 + (1) = 0,3. S'enveloppe à 2,1, ce qui correspond à la valeur 7.

La valeur de cellule suivante à 2,1 est 7 (= 1, -1), donc 2+ (1), 1 + (- 1) = 3,0. S'enveloppe à 1,2, ce qui correspond à la valeur 3.

La valeur de cellule suivante à 2,2 est 9 (= 1, 1), donc 2+ (1), 2 + (1) = 3,3. S'enveloppe à 1,1, ce qui correspond à la valeur 1.

Plus d'exemples

Grille d'entrée (3 x 3):

123
456
789

Production attendue:

987
654
321

Grille d'entrée (5 x 5):

77497
81982
32236
96336
67811

Production attendue:

28728
37337
11923
73369
77433

Notes finales

Si vous avez des questions, n'hésitez pas à commenter. Ceci est un défi de golf de code, le code le plus court gagne!

APL (33)

APL a été conçu pour cela. Il s'agit d'une fonction qui prend la grille d'entrée en tant que matrice N par N et renvoie la grille de sortie en tant que matrice N par N.

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

Tester:

      ⍝ 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 n'était pas fait pour ça ... APL l' était!

Python, 105

Prend et retourne une liste de listes:

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

Prend et retourne une chaîne (148 caractères):

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 octets

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 était légèrement moins conçu pour cela que APL, mais légèrement plus conçu pour cela que Python. ;)

Sortie de test

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