Détermination de la valeur basée sur des cellules adjacentes dans la matrice

juste un piratage rapide. À l'aide d'un tableau 3x3 et de certains arithmétiques modulo, vous pourriez probablement réduire beaucoup le nombre d'accès à la mémoire, mais cela pourrait sembler moche. AVERTISSEMENT Je ne l'ai pas exécuté à travers un compilateur afin qu'il puisse contenir des fautes de frappe.

wchar_t maze_wall(int** input,int rows, int cols){

   wchar_t** output;
   int i,j;
   int N,E,S,W,NE,SE,NW,SW;

   output = (wchar_t**) malloc(sizeof(wchar_t*)*rows);
   for(i=0;i<cols;i++)
      output[i]= (wchar_t*) malloc(sizeof(wchar_t)*cols);
   for(i=0;i<rows;i++){
      for(j=0;j<cols;j++){
        if(input[i][j] ==1)
           {output[i][j] = '1'; continue;}
        N=E=S=W=NE=SE=NW=SW=0;
        if(i != 0) /*We are not at the top*/
           N = input[i-1][j];
        if(i != rows-1) /* We are not at the bottom*/
          S = input[i+1][j];
        if(j != rows-1) /* We are not at the right side*/
          E = input[i][j+1];
        if(j != 0) /* We are not at the left side*/
          W = input[i][j-1];
      /*Expand this for the corners*/

      if(N+E+S+W+NE+SE+SW+NE+NW == 0)
          {output[i][j] = ' '; continue;}

      /*Fill it in for the other six cases {'└', '┐', '┌', '┘', '-', '|'} */
      } 
   }
   return output; 
}  

inspiré de Doug T. La solution que j'ai écrite moi-même. Fondamentalement, je passe à travers la matrice deux fois (performances médiocres: /). La première fois que je dessinerai des murs autour de chaque 1 code> dans la matrice, je le fais avec des masques bit. La deuxième fois que je nettoie tous les "Points intérieurs" -walls.

Exemple de configuration: p> xxx pré>

la boucle de murs: p> xxx pré>

la boucle de nettoyage: P>

map<unsigned int, wchar_t> p;
p[0] = ' ';
p[N] = '.';
// ...
p[N|S] = L'\u2502'; // │
p[E|W] = L'\u2500'; // ─
// ...
p[N|E|S|W] = L'\u253C'; // ┼

J'ai implémenté cela dans Mon entrée gagnante pour l'ICOCC 2004. Je suis sûr que vous trouverez le code bien documenté et facile à suivre.

Si vous voulez juste la réponse, si je me souviens, l'approche que j'ai prise était de calculer un bitmap de cellules occupées entourant chaque cellule et d'utiliser cela comme un index dans une gamme de caractères muraux (ou de manière équivalente, des glyphes). Si, comme ma solution, vous ne permettez pas de déplacement diagonal, le bitmap est de 4 bits de long, et donc la matrice a 2 ^ 4 = 16 éléments. Si vous autorisez les déplacements en diagonale, vous avez besoin d'un bitmap 8 bits et de 256 entrées.

première exécution via la matrice en ajoutant la matrice de noyau suivante, centrage du 0 code> du noyau sur chaque 1 code> et ajoute les chiffres aux carrés adjacents (c'est-à-dire de faire une représentation binaire de tous les voisins).

s = s_ij  # the sum at the location of interest
if not s & 16:  # never write a symbol over a 1
    if s & 8 and not (s & 128 or s & 2): 
        c = "|"
    elif s ==128:
        c = “┌─┐”
    # etc