Conversion des instructions de commutation en une solution plus élégante

Question

J'ai une matrice 9 x 9. (pensez à suduko).

4 2 1 6 8 1 8 5 8 
    3 1 5 8 1 1 7 5 8 
    1 1 4 0 5 6 7 0 4 
    6 2 5 5 4 4 8 1 2 
    6 8 8 2 8 1 6 3 5 
    8 4 2 6 4 7 4 1 1 
    1 3 5 3 8 8 5 2 2 
    2 6 6 0 8 8 8 0 6 
    8 7 2 3 3 1 1 7 4 

maintenant je veux être en mesure d'obtenir un "quadrant". par exemple (selon mon code) le quadrant 2, 2 renvoie les éléments suivants:

5 4 4 
    2 8 1 
    6 4 7 

Si vous avez remarqué, c'est la matrice du centre du 9 x 9. J'ai divisé tout dans les paires de "3" si vous savez ce que je veux dire. la première « ligne » est de 0 - 3, la seconde 3 à 6, le troisième pour 6 - 9 .. J'espère que cela sens (Je suis ouvert à d'autres moyens d'aller à ce sujet)

de toute façon, voici mon code. Je n'aime pas vraiment ça, même si ça marche. Je veux de la vitesse bien que je fasse un solveur suduko.

//a quadrant returns the mini 3 x 3 
    //row 1 has three quads,"1", "2", 3" 
    //row 2 has three quads "1", "2", "3" etc 
    public int[,] GetQuadrant(int rnum, int qnum) { 
     int[,] returnMatrix = new int[3, 3]; 
     int colBegin, colEnd, rowBegin, rowEnd, row, column; 

     //this is so we can keep track of the new matrix 
     row = 0; 
     column = 0;  
     switch (qnum) { 
      case 1: 
       colBegin = 0; 
       colEnd = 3; 
       break; 
      case 2: 
       colBegin = 3; 
       colEnd = 6; 
       break; 
      case 3: 
       colBegin = 6; 
       colEnd = 9; 
       break; 
      default: 
       colBegin = 0; 
       colEnd = 0; 
       break; 
     } 

     switch (rnum) { 
      case 1: 
       rowBegin = 0; 
       rowEnd = 3; 
       break; 
      case 2: 
       rowBegin = 3; 
       rowEnd = 6; 
       break; 
      case 3: 
       rowBegin = 6; 
       rowEnd = 9; 
       break; 
      default: 
       rowBegin = 0; 
       rowEnd = 0; 
       break; 
     } 
     for (int i = rowBegin ; i < rowEnd; i++) { 
      for (int j = colBegin; j < colEnd; j++) {     
       returnMatrix[row, column] = _matrix[i, j]; 
       column++; 
      } 
      column = 0; 
      row++; 
     } 
     return returnMatrix; 
    } 

Answer 1

À moins que je ne manque quelque chose, pourquoi ne pas faire des maths? Poing de tous, seulement stocker rowBegin et colBegin.

Maintenant, tout simplement question:

rowBegin = (rnum-1)*3 
colBegin = (qnum-1)*3 

Mappe 1 -> 0, 2 -> 3 et 3-> 6.

Maintenant, vous boucle de colBegin à colBegin + 3 et rowBegin à rowBegin + 3. Votre comportement par défaut est-il vraiment nécessaire? Si c'est le cas, cas particulier lorsque rnum < 1 || rnum > 3 et qnum < 1 || qnum > 3

Answer 2

Le modèle commun pour cela en Python est d'utiliser un dict à la carte:

qmap = { 
    1: (0, 3), 
    2: (3, 6), 
    3: (6, 9), 
} 

print qmap.get(qnum, (0, 0)) 

Je suis sûr que C# prend en charge quelque chose de similaire.

Answer 3

Pour une solution générale (c'est-à-dire une grille NxN), j'utiliserais des maths (vous aurez besoin de l'opérateur modulo).

Si vous utilisez toujours une grille de sudoku 9x9, vous pouvez pré-calculer les réponses et les coller dans une carte ou un tableau.

Bien sûr, vous pouvez combiner ces idées et pré-calculer les réponses dans votre fonction init(), puis les stocker dans une carte.