11

Bene, il mio secondo tentativo di giocare a code golf, vediamo come va.

Fai finta di avere una matrice di 9 valori. Ora immagina quell'array in una griglia 3x3.

È necessario restituire ai vicini quel numero che ha come indici dell'array.

0 | 1 | 2

3 | 4 | 5

6 | 7 | 8

Regole:

È il golf del codice, quindi vince la risposta più breve.
L'indice dell'array pretend può iniziare da 0 o 1. (tutti gli esempi usano 0 però)
Restituire i valori dei valori è malvisto (come if 3: return 046)
L'invio può essere solo una procedura / funzione / metodo, ma un esempio sarebbe utile
Il valore restituito può essere in qualsiasi ordine (come se l'input è 0, potrebbe essere 13 o 31)
se lo si desidera, l'output può essere un elenco di numeri, ad esempio [0,4,6]anziché046
le diagonali non contano, come si vede dagli esempi.

Esempi:

ingresso:

0

produzione:

13

ingresso:

3

produzione:

046

ingresso:

4

produzione:

1357

code-golf grid

— hcorion
fonte

4

Sembra che questa sfida possa beneficiare di un po 'di tempo nella Sandbox . Puoi pubblicare la tua sfida lì in modo che altri possano esaminarla e darti una mano prima di inviarla alla main. Dai tuoi esempi immagino che non stai contando le diagonali. Potresti voler aggiungere questo alla domanda stessa. Si menziona anche il requisito di produrre gli indici dell'array vicini. Penso che questo potrebbe essere semplicemente codificato per una griglia 3x3. Sarebbe forse meglio produrre gli stessi vicini?

— Colpisce il

7

Solo così, sai, disapprovare non è davvero qualcosa che facciamo qui; hardcoding l'output è consentito o non lo è. Dal momento che di solito è piuttosto difficile definire ciò che conta esattamente come hardcoding, personalmente lo consentirei o darei la dimensione della griglia come input aggiuntivo.

— Dennis,

1

L'output può essere un elenco di numeri, ad esempio [0,4,6]anziché 046?

— Laikoni,

@Laikoni Sì, un po 'troppo tardi perché hai già risposto.

— hcorion,

@Dennis Sì, non ero abbastanza sicuro di come dirlo. Mi piace come hanno fatto le risposte C e Python, fornendo entrambi, ma avendo la risposta non hard codificata come finale. Volevo incoraggiare algoritmi piuttosto che hard-coding, ma non ero sicuro che fosse possibile (senza risposte eccessivamente lunghe) e non volevo avere risposte alla mia domanda.

— hcorion,

2

Gelatina , 16 13 byte

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

Provalo online!

Come funziona

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.

— Dennis
fonte

Le regole dichiarano: "L'indice dell'array pretend può iniziare da 0 o 1." - puoi rilasciare il decremento alla fine.

— Steenbergh,

@steenbergh Presumo che dovrei prendere anche l'input basato su 1, che costa tanti byte quanti ne salva.

— Dennis,

9

MATL , 17 16 byte

9:qWIe1Y6Z+i)BPf

L'array è basato su 1, ovvero contiene numeri da 1a 9.

Provalo online! Oppure verifica tutti i casi di test .

Spiegazione

Considera l'input 2come esempio.

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]

— Luis Mendo
fonte

1

Wat? Come ti è venuto in mente questo?

— Robert Fraser,

1

@RobertFraser Queste sfide nel trovare i vicini mi suggeriscono sempre un approccio convoluzione. Ma la convoluzione aggiunge intrinsecamente i valori dei vicini, quindi dovevo essere in grado di separarli alla fine --- ecco i poteri di due e le parti dell'espansione binaria

— Luis Mendo,

5

Mathematica, 32 byte

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

Utilizza un grafico anziché un array. GridGraph@{3,3}costruisce un grafico a griglia 3x3, mostrato di seguito, che Mathematica etichetta in modo utile con i numeri 1–9 per i vertici di default. Quindi ~AdjacencyList~#&ti dice i vicini di un vertice.

— Non un albero
fonte

Devo amare quei builtin ...

— Neil

4

Mathematica, 40 byte

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

1-indicizzati. Cerca solo la risposta. Qualcuno può fare di meglio in Mathematica?

— Greg Martin
fonte

3

Sono sorpreso che non ci sia un incorporato per questo. Come se mi aspettassi che ci fosse un builtin per trovare tutti i vicini di un elemento in un array 2D, ma non sono sicuro, non so nulla di Mathematica oltre al fatto che ha troppi builtin.

— HyperNeutrino,

2

È possibile salvare un byte utilizzando 0-indexing e 31[420,51,...,75][[#]]&.

— Martin Ender,

1

È possibile utilizzare GridGraph@{3,3}~AdjacencyList~#&per 32 byte, con 1-indicizzazione.

— Non un albero il

@ lanlock4 Fantastico! Per favore, fai una risposta così posso votarla!

— Greg Martin,

4

Ottava, 42 40 39 byte

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

1 indice basato.

Verifica tutti i casi di test.

Spiegazione:

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.

Esempio: n = 2

(In Octave i dati sono archiviati per colonna.)

d =

   1.00000   1.41421   2.23607
   0.00000   1.00000   2.00000
   1.00000   1.41421   2.23607

indice logico in cui la distanza è 1:

d == 1

 1   0   0
 0   1   0
 1   0   0

find(d ==1)

 1
 3
 5

— rahnema1
fonte

3

Python 2, 71 byte

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

1-indicizzato
Provalo online!

Ottenere il risultato da un elenco predefinito di risultati è più breve (46 byte):

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

0 indicizzato
Provalo online!

— OVS
fonte

2

Haskell , 74 71 68 byte

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]

Provalo online! Utilizza una griglia con 1 indice. Esempio di utilizzo: f 3ritorna [2,6].

Modifica: salvato 3 6 byte grazie a Ørjan Johansen!

Per 77 75 byte, la seguente funzione #funziona con una dimensione della griglia arbitraria 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]

Provalo online! Per ognuno nl'elenco [n-m,n-1,n+1,n+m]contiene tutti e quattro i vicini. Per ogni voce xin questo elenco controlliamo -1<xe x<m*mper assicurarci che xnon sia sopra o sotto la griglia, mod n 3>0||n-1/=xper imporre il bordo sinistro della griglia e mod(n+1)m>0||n+1/=xper il bordo sinistro.

— Laikoni
fonte

1

Puoi usare [n-3,n-1..n+3]e gcd 3n>1.

— Ørjan Johansen,

Oops, non importa quella gcdparte. Avrebbe dovuto essere <3, e quindi si rompe per n==0. Si potrebbe essere in grado di utilizzare quel trucco se si cambia tutto per 1-indexed.

— Ørjan Johansen,

Oh, e il n/=2&&n/=5può essere sostituito da mod x 3>0. (O la gcdversione con reindicizzazione, che ora potrebbe essere utilizzata due volte.)

— Ørjan Johansen,

2

Rubino , 51 48 45 byte

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

Provalo online!

Crea 2 array, con vicini verticali e orizzontali, quindi selezionane uno o più.

Ruby hardcoded, 44 byte

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

... Non ne vale la pena.

— GB
fonte

2

C, 100 92 91 83 78 74 byte

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-indicizzati. Grazie a @Neil per aver salvato 4 byte.

Provalo online!

Versione hardcoded, 56 byte

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

0-indicizzato

— Steadybox
fonte

2

Nella prima versione, non puoi scrivere n>3&&p(n-3)ecc. Per salvare 4 byte? Nella seconda versione, non puoi scrivere l[]=per salvare un byte?

— Neil,

@Neil Sì, posso. Grazie!

— Steadybox

Sei sicuro che il tuo codice sia attualmente corretto? Quando provo i casi di test fallisce per tutti e tre ..: S Provalo qui. Potresti forse fornire un collegamento TIO funzionante, forse sto facendo qualcosa di sbagliato?

— Kevin Cruijssen,

1

Aggiunto il link TIO @KevinCruijssen e sembra che mi sia dimenticato di modificare il codice effettivo nell'ultima modifica ... Oh, bene. Anche il tuo collegamento funziona correttamente, ma nota che la mia risposta è 1 indicizzata, mentre i casi di esempio di esempio sono 0.

— Steadybox

@Steadybox Ah, hai davvero ragione. Ho perso la parte 1 indicizzata, mio male. Grazie per aver aggiunto il TIO. +1

— Kevin Cruijssen,

1

Python 2, 51 byte

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

Basato su una versione precedente di my risposta su Ruby , l'ho trovato interessante perché era principalmente lo stesso codice, usando un trucco diverso e produce lo stesso risultato. Avere capito bene mi ha aiutato a golf un po 'di più la risposta del rubino.

Fondamentalmente, ruby lo ha più corto perché l'indice di slice dell'array è inclusivo, python ha bisogno di a +1 compenso.

Spiegazione

Prendi i 2 array (vicini verticali e orizzontali), quindi seleziona uno o entrambi in base ad alcuni calcoli.

— GB
fonte

1

Java 7, 63 byte (hardcoded)

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

0-indexed
(output ordine invertito perché 024e 046non sono numeri interi validi). Funziona
~~ancora su una versione non hardcoded, ma~~ posso assicurarti che non sarà più breve ..

Provalo qui.

82 byte

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

1 indicizzato
Basato sulla risposta C di @Steadybox

Provalo qui.

— Kevin Cruijssen
fonte

0

JavaScript + lodash, 71 byte

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

— Brian McCutchon
fonte

0

Lotto, 116 byte

@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-indicizzati.

— Neil
fonte

Restituisce l'indice dei vicini in una griglia 3x3

Gelatina , 16 13 byte

Come funziona

MATL , 17 16 byte

Spiegazione

Mathematica, 32 byte

Mathematica, 40 byte

Ottava, 42 40 39 byte

Python 2, 71 byte

Haskell , 74 71 68 byte

Rubino , 51 48 45 byte

Ruby hardcoded, 44 byte

C, 100 92 91 83 78 74 byte

Python 2, 51 byte

Spiegazione

Java 7, 63 byte (hardcoded)

JavaScript + lodash, 71 byte

Lotto, 116 byte