D'accord, ma deuxième tentative de golf de code, voyons comment cela se passe.

Imaginez que vous avez un tableau de 9 valeurs. Imaginez maintenant ce tableau dans une grille 3x3.

Vous devez renvoyer les voisins que ce nombre a comme index du tableau.

0 | 1 | 2

3 | 4 | 5

6 | 7 | 8

Règles:

• C'est le golf de code, donc la réponse la plus courte l'emporte.
• L'index du tableau de simulation peut commencer à 0 ou 1. (tous les exemples utilisent cependant 0)
• Le simple retour de valeurs est mal vu (comme if 3: return 046)
• La soumission peut être juste une procédure / fonction / méthode, mais un exemple serait bien
• La valeur retournée peut être dans n'importe quel ordre (comme si l'entrée est 0, elle peut être 13 ou 31)
• si vous le souhaitez, la sortie peut être une liste de nombres, par exemple [0,4,6]au lieu de046
• les diagonales ne comptent pas, comme le montrent les exemples.

Exemples:

contribution:

0

production:

13

contribution:

3

production:

046

contribution:

4

production:

1357

Gelée , 16 13 octets

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

Essayez-le en ligne!

Comment ça fonctionne

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 octets

9:qWIe1Y6Z+i)BPf

Le tableau est basé sur 1, c'est-à-dire qu'il contient les nombres de 1à 9.

Essayez-le en ligne! Ou vérifiez tous les cas de test .

Explication

Considérez la saisie 2comme exemple.

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 octets

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

Utilise un graphique au lieu d'un tableau. GridGraph@{3,3}construit un graphique en forme de grille 3x3, illustré ci-dessous, que Mathematica étiquette utilement avec les nombres 1–9 pour les sommets par défaut. ~AdjacencyList~#&Vous indique ensuite les voisins d'un sommet.

Mathematica, 40 octets

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

1 indexé. Cherche juste la réponse. Quelqu'un peut-il faire mieux dans Mathematica?

Octave, 42 40 39 octets

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

Index basé sur 1.

Vérifiez tous les cas de test.

Explication:

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.

Exemple: n = 2

x =

   0   0   0
   1   0   0
   0   0   0

(Dans Octave, les données sont stockées en colonnes.)

d =

   1.00000   1.41421   2.23607
   0.00000   1.00000   2.00000
   1.00000   1.41421   2.23607

indice logique où la distance est 1:

d == 1

 1   0   0
 0   1   0
 1   0   0

find(d ==1)

 1
 3
 5

Python 2, 71 octets

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

1 indexé
Essayez-le en ligne!

L'obtention du résultat à partir d'une liste de résultats prédéfinie est plus courte (46 octets):

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

0 indexé
Essayez-le en ligne!

Haskell , 74 71 68 octets

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]

Essayez-le en ligne! Utilise une grille à 1 index. Exemple d'utilisation: f 3retourne[2,6] .

Edit: sauvé 3 6 octets grâce à Ørjan Johansen!

Pour 77 75 octets, la fonction suivante fonctionne #pour une taille de grille arbitraire 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]

Essayez-le en ligne! Pour chacun, nla liste [n-m,n-1,n+1,n+m]contient les quatre voisins. Pour chaque entrée xde cette liste, nous vérifions -1<xet x<m*mpour nous assurer qu'il xn'est pas au-dessus ou en dessous de la grille, mod n 3>0||n-1/=xpour appliquer la bordure de grille gauche et mod(n+1)m>0||n+1/=xpour la bordure gauche.

Rubis , 51 48 45 octets

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

Essayez-le en ligne!

Créez 2 tableaux, avec des voisins verticaux et horizontaux, puis sélectionnez-en un ou plusieurs.

Ruby codé en dur, 44 octets

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

... Ça n'en vaut pas la peine.

C, 100 92 91 83 78 74 octets

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 indexé. Merci à @Neil d'avoir économisé 4 octets.

Essayez-le en ligne!

Version codée en dur, 56 octets

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

0 indexé

Python 2, 51 octets

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

Basé sur une version précédente de mon réponse Ruby , je l'ai trouvée intéressante car il s'agissait principalement du même code, utilisant une astuce différente, et produisant le même résultat. Obtenir celui-ci m'a aidé à jouer un peu plus la réponse de rubis.

Fondamentalement, ruby ​​l'a plus court car l'index de tranche de tableau est inclusif, python a besoin d'un +1 pour compenser.

Explication

Obtenez les 2 tableaux (voisins verticaux et horizontaux), puis sélectionnez l'un ou les deux en fonction de certains calculs.

Java 7, 63 octets (codé en dur)

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

0 indexé
(sortie d'ordre inversé car 024et 046ne sont pas des entiers valides.)
Toujours en train de travailler sur une version non codée en dur, mais je peux vous assurer que ce ne sera pas plus court ..

Essayez-le ici.

82 octets

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

1 indexé
basé sur la réponse @Steadybox 'C

Essayez-le ici.

JavaScript + lodash, 71 octets

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

Lot, 116 octets

@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 indexé.