Muy bien, mi segundo intento en un código de golf, veamos cómo va esto.

Imagina que tienes una matriz de 9 valores. Ahora imagine esa matriz en una cuadrícula de 3x3.

Debe devolver a los vecinos que ese número tiene como índices de la matriz.

0 | 1 | 2

3 | 4 | 5 5

6 | 7 | 8

Reglas:

• Es el código de golf, por lo que gana la respuesta más corta.
• El índice de la matriz de simulación puede comenzar en 0 o 1. (todos los ejemplos usan 0)
• Solo devolver valores valores está mal visto (como if 3: return 046)
• El envío puede ser solo un procedimiento / función / método, pero un ejemplo sería bueno
• El valor devuelto puede estar en cualquier orden (como si la entrada es 0, podría ser 13 o 31)
• si lo desea, la salida puede ser una lista de números, por ejemplo, en [0,4,6]lugar de046
• las diagonales no cuentan, como se ve en los ejemplos.

Ejemplos:

entrada:

0 0

salida:

13

entrada:

3

salida:

046

entrada:

4 4

salida:

1357

Jalea , 16 13 bytes

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

Pruébalo en línea!

Cómo funciona

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

La matriz está basada en 1, es decir, contiene números desde 1hasta 9.

Pruébalo en línea! O verificar todos los casos de prueba .

Explicación

Considere la entrada 2como un ejemplo.

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~#&

Utiliza un gráfico en lugar de una matriz. GridGraph@{3,3}construye un gráfico en forma de cuadrícula de 3x3, que se muestra a continuación, que Mathematica etiqueta útilmente con los números 1–9 para los vértices de forma predeterminada. Luego ~AdjacencyList~#&te dice los vecinos de un vértice.

Mathematica, 40 bytes

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

1 indexado. Solo busca la respuesta. ¿Alguien puede mejorar en Mathematica?

Octava, 42 40 39 bytes

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

Índice basado en 1.

Verifique todos los casos de prueba.

Explicación:

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.

Ejemplo: n = 2

x =

   0   0   0
   1   0   0
   0   0   0

(En Octave, los datos se almacenan en columnas).

d =

   1.00000   1.41421   2.23607
   0.00000   1.00000   2.00000
   1.00000   1.41421   2.23607

índice lógico donde la distancia es 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 indexado ¡
Pruébelo en línea!

Obtener el resultado de una lista predefinida de resultados es más corto (46 bytes):

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

0 indexado ¡
Pruébelo en línea!

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]

Pruébalo en línea! Utiliza una cuadrícula indexada 1. Ejemplo de uso: f 3devoluciones [2,6].

Editar: ¡Guardado 3 6 bytes gracias a Ørjan Johansen!

Para 77 75 bytes, la siguiente función #funciona para un tamaño de cuadrícula arbitrario 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]

Pruébalo en línea! Para cada uno, nla lista [n-m,n-1,n+1,n+m]contiene los cuatro vecinos. Para cada entrada xen esta lista, verificamos -1<xy x<m*mpara asegurarnos de que xno esté encima o debajo de la cuadrícula, mod n 3>0||n-1/=xpara hacer cumplir el borde izquierdo de la cuadrícula y mod(n+1)m>0||n+1/=xpara el borde izquierdo.

Ruby , 51 48 45 bytes

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

Pruébalo en línea!

Cree 2 matrices, con vecinos verticales y horizontales, luego seleccione uno o más de ellos.

Ruby codificado, 44 ​​bytes

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

... No vale la pena.

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 indexado. Gracias a @Neil por guardar 4 bytes.

Pruébalo en línea!

Versión codificada, 56 bytes

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

0 indexado

Python 2, 51 bytes

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

Basado en una versión anterior de mi respuesta de Ruby , me pareció interesante porque era principalmente el mismo código, usando un truco diferente, y produce el mismo resultado. Conseguir esto correctamente me ayudó a responder un poco más al golf.

Básicamente, ruby ​​lo tiene más corto porque el índice de corte de matriz es inclusivo, python necesita un +1para compensar.

Explicación

Obtenga las 2 matrices (vecinas verticales y horizontales), luego seleccione una o ambas en función de algunos cálculos.

Java 7, 63 bytes (codificado)

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

0 indexados
(salida orden inverso debido 024y 046no son números enteros válidos.)
Seguimos trabajando en una versión no codificada, pero les puedo asegurar que no será más corto ..

Pruébalo aquí.

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 indexado
Basado en la respuesta de @Steadybox 'C

Pruébalo aquí.

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)

Lote, 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 indexado.