Jeu de la Vie (poinçonneuse quotidien 4.2leetcode)

Selon Baidu Encyclopédie, jeu de la vie, appelée la vie, est un mathématicien britannique John Horton Conway automates cellulaires invention 1970.

Compte tenu de a, m × n panneaux de grille, chaque grille peut être considérée comme une cellule. Chaque cellule ayant un état initial: 1 sont les cellules viables (vivantes), soit 0, ou cellules mortes (mortes). Par cellule à ses huit positions voisines (horizontale, verticale, diagonale) sont les quatre droit de survie des cellules suivantes:

 Si le nombre de cellules viables de huit positions autour de moins de deux cellules vivantes, l'emplacement d'une mort cellulaire en direct,
 si huit positions autour de la cellule vivante a deux ou trois cellules vivantes, l'emplacement des cellules vivantes étaient encore en vie,
 si les cellules vivantes il y a plus de huit positions autour des trois cellules vivantes, l'emplacement d'une mort cellulaire en direct,
 il vous arrive d'avoir trois cellules mortes autour de la cellule vivante, la position de la résurrection des cellules mortes;

Selon l'état actuel, une fonction d'écriture pour calculer l'état suivant (après mise à jour) sur toutes les cellules du panneau. L'état suivant est constitué par les règles ci-dessus simultanément appliqués à chaque cellule dans l'état actuel, dans lequel la naissance et la mort des cellules se produit simultanément.

 

exemple:

Entrée:
[
  [0,1,0]
  [0,0,1]
  [1,1,1]
  [0,0,0]
]
Rendement:
[
  [0,0,0],
  [0 , 1],
  [0,1,1]
  [0,1,0]
]

 

Penser: élément traversant autour de chaque élément dans huit directions, est déterminée, la simulation.

Cependant, cette question peut être appris par deux tableau:  int [] = DX new new int [] { 0 , 0 , . 1 , - . 1 , . 1 , - . 1 , - . 1 , . 1 }; et  int [] = Dy nouveau nouvel int [] { 1. , - 1. , 0 , 0 , 1. , 1. , - 1. , - 1. }; et ensuite il y a une boucle à partir d' une direction de déplacement 8 0,  int newX = I + DX [K]; 

,  Int Newy J = Dy + [K]; cette traversée huit directions.

1  vide gameOfLife ( int planche **, int boardSize, int * boardColSize) {
 2      si (boardColSize [ 0 ] == 0 )
 3          retour ;
4      int a [boardSize] [boardColSize [ 0 ]];
5      int dir [ 8 ] [ 2 ] = {{ 1 , 0 }, { 0 , 1 }, {- 1 , 0 }, { 0 , - 1 }, {- 1 , - 1}, { 1 , 1 }, {- 1 , 1 }, { 1 , - 1 }};
6      int i = 0 , j = 0 , z;
7      pour (i = 0 ; i <boardSize; i ++ )
 8      {
 9          pour (j = 0 ; j <boardColSize [ 0 ]; j ++ )
 10          {
 11              a [i] [j] = 0 ;
12          }
 13      }
 14  
15  
16      pour(i = 0 ; i <boardSize; i ++ )
 17      {
 18          pour (j = 0 ; j <boardColSize [i]; j ++ )
 19          {
 20              int k = 0 ;
21              pour (z = 0 ; z < 8 ; z ++ )
 22              {
 23                  int x = i + dir [z] [ 0 ];
24                  int y = j + dir [z] [ 1 ];
25                  si (x < 0 || y < 0 || x> = || boardSize y> = boardColSize [0 ])
 26                  {
 27                      continue ;
28                  }
 29                  si (planche [x] [y] == 1 )
 30                      k ++ ;
31              }
 32              si (k < 2 )
 33                  a [i] [j] = 0 ;
34              si (planche [i] [j] == 1 && k> = 2 && k <= 3 )
 35                  a [i] [j] = 1 ;
36              si (planche [i] [j] == 1&& k> 3 )
 37                  a [i] [j] = 0 ;
38              si (k == 3 )
 39                  a [i] [j] = 1 ;
40          }
 41      }
 42      pour (i = 0 ; i <boardSize; i ++ )
 43      {
 44          pour (j = 0 ; j <boardColSize [ 0 ]; j ++ )
 45          {
 46              planche [i] [j] = a [i] [j];
47          }
 48      }
49 }