Qual è il significato di inizializzare gli array di direzione di seguito con i valori dati durante lo sviluppo del programma di scacchi?

Question

Sono nuovo di programmazione competitiva, e ho notato spesso, molti dei grandi programmatori hanno queste quattro linee nel loro codice (in particolare in quei array che coinvolgono):

int di[] = { 1, -1, 0, 0, 1, -1, 1, -1 }; 
int dj[] = { 0, 0, 1, -1, 1, -1, -1, 1 }; 
int diK[] = { -2, -2, -1, 1, 2, 2, 1, -1 }; 
int djK[] = { -1, 1, 2, 2, 1, -1, -2, -2 }; 

Cosa veramente significa e qual è la tecnica usato per?

Answer 1

Questa è una tecnica per codificare tutte le direzioni come array - ogni coppia di di[i],dj[i] è una direzione diversa.

Se immaginiamo di avere un pezzo in una posizione x, y, e vogliamo aggiungere sulla sua x e il suo valore y per spostarlo in una posizione vicina, 1,0 è est, -1,0 è ovest , 0,1 è sud, 0, -1 è nord e così via.

(Qui ho detto alto a sinistra è 0,0 e sotto a destra è 4,4 e mostrato quale mossa ogni indice delle matrici farà dal punto centrale, X, a 2,2.)

..... 
.536. 
.1X0. 
.724. 
..... 

Il modo in cui è impostato, se si fa ^1 (^ bit XOR bit nell'indice si ottiene la direzione opposta - 0 e 1 sono opposti, 2 e 3 sono opposti e così via. (Un altro modo per configurarlo è quello di andare in senso orario a partire da nord -. Allora ^4 si ottiene la direzione opposta)

Ora è possibile testare tutte le direzioni da un punto dato dal loop sulle vostre di e dj array, invece di aver bisogno di scrivere ogni direzione su una riga (per otto in totale!) (Basta non dimenticare di fare il controllo dei limiti :))

diK e djK Form knights directions invece di tutte le direzioni adiacenti. Qui, ^1 girerà lungo un asse, ^4 darà il salto opposto del cavaliere.

.7.6. 
0...5 
..K.. 
1...4 
.2.3. 

Answer 2

Per coloro che trovano difficile spiegare la spiegazione di Patashu, cercherò di chiarire.

Immagina di provare a considerare ogni possibile spostamento da un determinato punto su una scacchiera.

Se si esegue il looping degli array di e dj, interpretando i di valori come x offset ei valori dj come offset, si coprono ciascuna delle possibili 8 direzioni.

Supponendo che x positivo sia est e positivo y sia sud (come nella risposta di Patashu), si ottiene quanto segue;

 
    | di/x | dj/y | Direction 
--+------+------+----------- 
0 | 1 | 0 | east 
1 | -1 | 0 | west 
2 | 0 | 1 | south 
3 | 0 | -1 | north 
4 | 1 | 1 | south-east 
5 | -1 | -1 | north-west 
6 | 1 | -1 | north-east 
7 | -1 | 1 | south-west 

Gli array DIK e djk possono essere interpretate allo stesso modo per stabilire le possibili mosse per il pezzo cavaliere. Se non hai familiarità con gli scacchi, il Cavaliere si muove in un modello L - due quadrati in una direzione, e quindi un quadrato ad angolo retto rispetto a quello (o viceversa).

 
    | diK/x | djK/y | Direction 
--+-------+-------+---------------- 
0 | -2 | -1 | 2 west, 1 north 
1 | -2 | 1 | 2 west, 1 south 
2 | -1 | 2 | 1 west, 2 south 
3 | 1 | 2 | 1 east, 2 south 
4 | 2 | 1 | 2 east, 1 south 
5 | 2 | -1 | 2 east, 1 north 
6 | 1 | -2 | 1 east, 2 north 
7 | -1 | -2 | 1 west, 2 north 

Answer 3

Un piccolo snippet di codice per controllare la quantità di spostamenti possibili in tutte le direzioni, che utilizza gli array definiti.

int di[] = { 1, -1, 0, 0, 1, -1, 1, -1 }; 
int dj[] = { 0, 0, 1, -1, 1, -1, -1, 1 }; 
int movesPossible[8]; 
int move = 0; 
int posx, posy; // position of the figure we are checking 

for (int d=0; d<8; d++) { 
    for (move = 1; board.getElt(posx+di[d]*move, posy+dj[d]*move)==EMPTY; move++) ; 
    movesPossible[d] = move-1; 
}