Die Info

Die Zahlen 1 bis 9 repräsentieren jeweils eine Zelle in der Nachbarschaft von Moore , wobei 5 die zentrale Zelle ist. So:

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}

Die Herausforderung

Sie können Eingaben über STDIN, ARGV oder Funktionsargument vornehmen und entweder das Ergebnis zurückgeben oder an STDOUT drucken. Die Eingabe ist ein N x N-Gitter (Torustopologie, dh wenn x oder y <1 ist, dann ist x oder y = N, und wenn x oder y> N, dann ist x oder y = 1), und Ihr Programm muss eine Interaktion davon ausgeben Raster durch Ersetzen jeder Zelle durch den Wert in der Moore's Neighborhood-Zelle.

Beispiel Eingabegitter (2 x 2):

13
79

Ausgabe:

97
31

Erläuterung:

Ab Position 1,1 haben wir den Wert 1, da Wert 1 = {- 1, -1}, müssen wir 1 + (- 1), 1 + (- 1) = 0,0 abrufen. Und weil es ein Torus 0,0 ist, wickeln wir uns um N. Also rufen wir den Zellenwert an Position 1,1 (1) mit dem Zellenwert an Position 2,2 (9) ab.

Für die nächste Zelle 1,2 haben wir den Wert 3 (= -1, 1), also 1 + (- 1), 2 + (1) = 0,3. Wraps um 2,1, was Wert 7 ist.

Der nächste Zellenwert bei 2,1 ist 7 (= 1, -1), also 2+ (1), 1 + (- 1) = 3,0. Wraps um 1,2, was Wert 3 ist.

Der nächste Zellenwert bei 2,2 ist 9 (= 1, 1), also 2+ (1), 2 + (1) = 3,3. Wraps um 1,1, was Wert 1 ist.

Mehr Beispiele

Eingabegitter (3 x 3):

123
456
789

Erwartete Ausgabe:

987
654
321

Eingabegitter (5 x 5):

77497
81982
32236
96336
67811

Erwartete Ausgabe:

28728
37337
11923
73369
77433

Schlussbemerkungen

Wenn Sie Fragen haben, zögern Sie nicht zu kommentieren. Dies ist eine Code-Golf-Herausforderung, der kürzeste Code gewinnt!

APL (33)

APL wurde dafür gemacht . Dies ist eine Funktion, die das Eingangsraster als N-mal-N-Matrix verwendet und das Ausgangsraster als N-mal-N-Matrix zurückgibt.

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

Prüfung:

      ⍝ 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 wurde nicht dafür gemacht ... APL war!

Python, 105

Nimmt eine Liste von Listen und gibt sie zurück:

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

Nimmt eine Zeichenfolge (148 Zeichen) und gibt sie zurück:

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 wurde etwas weniger dafür gemacht als APL, aber etwas mehr dafür als Python. ;)

Testausgabe

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