Okay, mein zweiter Versuch, Code Golf zu spielen, mal sehen, wie das geht.

Stellen Sie sich vor, Sie haben ein Array mit 9 Werten. Stellen Sie sich nun dieses Array in einem 3x3-Raster vor.

Sie müssen Nachbarn zurückgeben, die diese Nummer als Indizes des Arrays hat.

0 | 1 | 2

3 | 4 | 5

6 | 7 | 8

Regeln:

• Es ist Code Golf, also gewinnt die kürzeste Antwort.
• Der Index des Pretend-Arrays kann bei 0 oder 1 beginnen (alle Beispiele verwenden jedoch 0).
• Nur die Rückgabe von Werten Werte ist verpönt (wie if 3: return 046)
• Die Einreichung kann nur eine Prozedur / Funktion / Methode sein, aber ein Beispiel wäre schön
• Der zurückgegebene Wert kann in beliebiger Reihenfolge angegeben werden (z. B. wenn die Eingabe 0 ist, können es 13 oder 31 sein).
• Wenn Sie möchten, kann die Ausgabe eine Liste von Zahlen sein, z. B. [0,4,6]anstelle von046
• Diagonalen zählen nicht, wie die Beispiele zeigen.

Beispiele:

Eingang:

0

Ausgabe:

13

Eingang:

3

Ausgabe:

046

Eingang:

4

Ausgabe:

1357

Gelee , 16 13 Bytes

9Ḷ,d3ạ/S€=1T’

Probieren Sie es online aus!

Wie es funktioniert

9Ḷ,d3ạ/S€=1T’  Main link. Argument: n (0, ..., 8)

9              Set the return value to 9.
 Ḷ             Unlength; yield [0, ..., 8].
  ,            Pair; yield [[0, ..., 8], n].
   d3          Divmod 3; yield [[[0, 0], ..., [2, 2]], [n:3, n%3]]].
     ạ/        Reduce by absolute difference, yielding
               [[|0 - n:3|, |0 - n%3|], ..., [[|2 - n:3|, |2 - n%3|]].
       S€      Sum each, yielding
               [|0 - n:3| + |0 - n%3|, ..., [|2 - n:3| + |2 - n%3|].
         =1    Compare the sums with 1.
           T   Truth; yield all 1-based indices of 1.
            ’  Decrement to yield all 0-based indices of 1.

MATL , 17 16 Bytes

9:qWIe1Y6Z+i)BPf

Das Array ist 1-basiert, dh es enthält Zahlen von 1bis 9.

Probieren Sie es online aus! Oder überprüfen Sie alle Testfälle .

Erläuterung

Betrachten Sie die Eingabe 2als Beispiel.

9:q  % Push [0 1 2 ... 8]
     % STACK: [0 1 2 ... 8]
W    % Rise to 2, element-wise
     % STACK: [1 2 4 ... 256]
Ie   % Reshape as 3-row matrix (column-major order)
     % STACK: [1   8  64;
               2  16 128;
               4  32 256]
1Y6  % Push [0 1 0; 1 0 1; 0 1 0]
     % STACK: [1   8  64;
               2  16 128;
               4  32 256],
              [0   1   0;
               1   0   1;
               0   1   0]
Z+   % Convolution, maintaining size
     % STACK: [10  81 136;
               21 170 336;
               34 276 160]
i    % Take input, n
     % STACK: [10  81 136;
               21 170 336;
               34 276 160],
               2
 )   % Get n-th entry (1-based; column-major order)
     % STACK: 21
B    % Convert to binary
     % STACK: [1 0 1 0 1]
P    % Flip
     % STACK: [1 0 1 0 1]
f    % Find: gives indices of nonzeros. Implicitly display
     % STACK: [1 3 5]

Mathematica, 32 Bytes

GridGraph@{3,3}~AdjacencyList~#&

Verwendet ein Diagramm anstelle eines Arrays. GridGraph@{3,3}erstellt ein unten gezeigtes 3x3-Gitter, das Mathematica standardmäßig mit den Zahlen 1–9 für die Scheitelpunkte beschriftet. Dann ~AdjacencyList~#&sagt Ihnen die Nachbarn eines Scheitelpunktes.

Mathematica, 40 Bytes

{24,135,26,157,2468,359,48,579,68}[[#]]&

1-indiziert. Schlägt nur die Antwort nach. Kann jemand in Mathematica besser abschneiden?

Oktave, 42 40 39 Bytes

@(n,x=~e(3),y=x(n)=1)find(bwdist(x)==1)

1-basierter Index.

Überprüfen Sie alle Testfälle.

Erläuterung:

x=~e(3);         % create a 3*3 matrix of zeros
x(n)=1;          % set the element with index n to 1
d=bwdist(x);     % compute the distance transform of the matrix
find(d == 1)     % find where the distance is 1.

Beispiel: n = 2

x =

   0   0   0
   1   0   0
   0   0   0

(In Oktave werden Daten spaltenweise gespeichert.)

d =

   1.00000   1.41421   2.23607
   0.00000   1.00000   2.00000
   1.00000   1.41421   2.23607

logischer Index mit Abstand 1:

d == 1

 1   0   0
 0   1   0
 1   0   0

find(d ==1)

 1
 3
 5

Python 2, 71 Bytes

lambda n:filter(abs,[(n-3)*(n>3),(n+3)*(n<7),~-n*(n%3!=1),-~n*(n%3>0)])

1-indexiert
Online ausprobieren!

Das Abrufen des Ergebnisses aus einer vordefinierten Ergebnisliste ist kürzer (46 Byte):

[13,204,15,406,1357,248,37,468,57].__getitem__

0-indiziert
Probieren Sie es online aus!

Haskell , 74 71 68 Bytes

f n=[x|x<-[n-3,n-1..n+3],0<x,x<10,gcd 3x<2||n-1/=x,gcd 3n<2||n+1/=x]

Probieren Sie es online aus! Verwendet ein 1-indiziertes Raster. Anwendungsbeispiel: f 3Gibt zurück [2,6].

Edit: 3 6 Bytes dank Ørjan Johansen gespeichert !

Für 77 75 Bytes funktioniert die folgende Funktion #für eine beliebige Rastergröße m:

n#m=[x|x<-[n-m,n-1,n+1,n+m],0<x,x<=m*m,gcd x m<m||n-1/=x,gcd n m<m||n+1/=x]

Probieren Sie es online aus! Für jeden enthält ndie Liste [n-m,n-1,n+1,n+m]alle vier Nachbarn. Für jeden Eintrag xin dieser Liste überprüfen wir -1<xund x<m*msicher zu machen xist nicht über oder unter dem Gitter, mod n 3>0||n-1/=xdie linke Gitter Grenze und zur Durchsetzung mod(n+1)m>0||n+1/=xfür den linken Rand.

Ruby , 51 48 45 Bytes

->a{[a+3,a-3][a/6..a/3]+[a+1,a-1][a%-3..a%3]}

Probieren Sie es online aus!

Erstellen Sie zwei Arrays mit vertikalen und horizontalen Nachbarn und wählen Sie dann eines oder mehrere aus.

Ruby fest codiert, 44 Bytes

->a{%w(13 024 15 046 1357 248 37 468 57)[a]}

... Ist es nicht wert.

C 100 92 91 83 78 74 Bytes

p(n){putchar(n+48);}f(n){n>3&&p(n-3);n<7&&p(n+3);n%3&&p(n+1);--n%3&&p(n);}

1-indiziert. Vielen Dank an @Neil für das Speichern von 4 Bytes.

Probieren Sie es online aus!

Hardcodierte Version, 56 Bytes

l[]={13,204,15,406,1357,248,37,468,57};
#define L(n)l[n]

0-indiziert

Python 2, 51 Bytes

lambda x:[x+3,x-3][x/6:x/3+1]+[x+1,x-1][x%-3:x%3+1]

Basierend auf einer früheren Version meiner Ruby- Antwort fand ich sie interessant, da es sich meistens um denselben Code handelte, der einen anderen Trick verwendete und dasselbe Ergebnis lieferte. Das Richtige zu tun hat mir geholfen, die Rubinantwort ein bisschen mehr zu spielen.

Grundsätzlich hat Ruby es kürzer, weil der Array-Slice-Index inklusive ist, Python braucht ein +1, um dies zu kompensieren.

Erläuterung

Holen Sie sich die 2 Arrays (vertikale und horizontale Nachbarn) und wählen Sie dann eines oder beide basierend auf einigen Berechnungen aus.

Java 7, 63 Bytes (fest codiert)

int c(int i){return new int[]{31,420,51,640,7531,842,73,864,75}[i];}

0-indiziert
(Ausgabe in umgekehrter Reihenfolge, da 024und 046keine gültigen Ganzzahlen sind.)
Arbeitet immer noch an einer nicht fest codierten Version, aber ich kann Ihnen versichern, dass sie nicht kürzer sein wird.

Probieren Sie es hier aus.

82 Bytes

String c(int n){return""+(n>3?n-3:"")+(n<7?n+3:"")+(n%3>0?n+1:"")+(--n%3>0?n:"");}

1-indiziert
Basierend auf der Antwort von @Steadybox 'C.

Probieren Sie es hier aus.

JavaScript + lodash, 71 Bytes

f=a=>_.range(9).filter(b=>a>b?f(b).includes(a):[,1,,1][b-a]&&b%3|a%3<2)

Stapel, 116 Bytes

@set c=cmd/cset/a%1
@set/ar=%1%%3
@if %1 gtr 2 %c%-3
@if %r% gtr 0 %c%-1
@if %r% lss 2 %c%+1
@if %1 lss 6 %c%+3

0-indiziert.