IdentifiantMot de passe
Loading...
Mot de passe oublié ?Je m'inscris ! (gratuit)
Navigation

Inscrivez-vous gratuitement
pour pouvoir participer, suivre les réponses en temps réel, voter pour les messages, poser vos propres questions et recevoir la newsletter

Algorithmes et structures de données Discussion :

[C++]Génération de grille sudoku


Sujet :

Algorithmes et structures de données

  1. #1
    Futur Membre du Club
    Profil pro
    Inscrit en
    Mai 2007
    Messages
    8
    Détails du profil
    Informations personnelles :
    Localisation : Belgique

    Informations forums :
    Inscription : Mai 2007
    Messages : 8
    Points : 8
    Points
    8
    Par défaut [C++]Génération de grille sudoku
    Bonjour

    Je suis entrain d'essayer de créer un algorithme de génération de grille du sudoku mais je bloque encore un peu.

    Pour l'instant j'ai une boucle infinie et je ne vois pas pourquoi.

    Quelqu'un saurait-il m'aider?

    Voici mon code:
    Code C++ : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
    94
    95
    96
    97
    98
    99
    100
    101
    102
    103
    104
    105
    106
    107
    108
    109
    110
    111
    112
    113
    114
    115
    116
    117
    118
    119
    120
    121
    122
    123
    124
    125
    126
    127
    128
    129
    130
    131
    132
    133
    134
    135
    136
    137
    138
    139
    140
    141
    142
    143
    144
    145
    146
    147
    148
    149
    150
    151
    152
    153
    154
    155
    156
    157
    158
    159
    160
    #include <iostream>
    #include <stdlib.h>
    #include <time.h>
    #include <stdio.h>
     
    using namespace std;
     
    int main(){
     
        //Initialisations
        int grille[9][9];
        int grille_temp[3][9];
        int min = 1, max = 9, ligne = 0;
        bool boucle_ok = true, nombre_ok = false, possibilites[9], carre_ok = true, ligne_ok = true;
     
        //MISES A ZERO
     
        //grille
        for(int i=0; i<9; i++){
            for(int j=0; j<9; j++){
                grille[i][j] = 0;
            }
        }
     
        //grille_temp
        for(int i=0; i<3; i++){
            for(int j=0; j<9; j++){
                grille_temp[i][j] = 0;
            }
        }
     
        //Tableau de bool
        for(int i=0; i<9; i++){
            possibilites[i] = false;
        }
     
        //Initialisation du temps
        srand(time(NULL));
     
        //Remplissage de la grille
        while(boucle_ok){
            //Génération de la première ligne
            for(int i=0; i<9; i++){
                do{
    			nombre_ok = true;
    			grille[ligne][i] = (rand() % (max - min + 1)) + min;
                    for(int k=0; k<9; k++){
                        if (k!=i){
                            if(grille[ligne][k] == grille[ligne][i]){
                                nombre_ok = false;
                            }
                        }
                    }
                }while (!nombre_ok);
            }
            //Fin de génération de la première ligne
            if(ligne == 0 || ligne == 3 || ligne == 6){//Si c'est la première ligne, elle est bonne
                ligne++;
            }
            else{
                for(int t= (ligne - 1); t>=0; t--){
                    for(int w=0; w<9; w++){
                        if(grille[t][w] == grille[ligne][w]){
                            ligne_ok = false;
                        }
                    }
                }
     
                //Si "ligne" vaut toujous 2, les 3 premières lignes sont bonnes, on les passe à la "moulinette du carré"
                if((ligne_ok && ligne == 2) || (ligne_ok && ligne == 5) || (ligne_ok && ligne == 8)){
                    //Premier carré
                    for(int k=(ligne - 2); k<=ligne; k++){
                        for(int l=0; l<3; l++){
                            possibilites[(grille[k][l] - 1)] = true;
                        }
                    }
                    //Vérification
                    for(int m=0; m<9; m++){
                        if(!possibilites[m]){
                            carre_ok = false;
                        }
                    }
     
                    //Remise à zéro de la variable
                    for(int i=0; i<9; i++){
                        possibilites[i] = false;
                    }
                    //Fin du premier carré
     
                    //Après le premier carré, le second, mais seulement si le premier est juste
                    if(carre_ok){
                        for(int k=(ligne - 2); k<=ligne; k++){
                            for(int l=3; l<6; l++){
                                possibilites[(grille_temp[k][l] -1)] = true;
                            }
                        }
                        //Vérification
                        for(int m=0; m<9; m++){
                            if(!possibilites[m]){
                                carre_ok = false;
                            }
                        }
     
                        //Remise à 0 de la variable
                        for(int i=0; i<9; i++){
                            possibilites[i] = false;
                        }
     
                        //Si le deuxième carré est juste, on passe au troisième
                        if(carre_ok){
                            for(int k=(ligne - 2); k<=ligne; k++){
                                for(int l=6; l<9; l++){
                                    possibilites[(grille_temp[k][l] -1)] = true;
                                }
                            }
                            //Vérification
                            for(int m=0; m<9; m++){
                                if(!possibilites[m]){
                                    carre_ok = false;
                                }
                            }
     
                            //Remise à 0 de la variable
                            for(int i=0; i<9; i++){
                                possibilites[i] = false;
                            }
                        }
                    }
                    else{//Si ce n'est pas bon, c'est reparti pour la génération des 2 lignes
                        ligne = ligne -1;
                    }
                }
                else if(ligne_ok){
                    ligne++;
                }
                else{
                    //Si la ligne est fausse, on remet le bool "ligne_ok" à true
                    ligne_ok = true;
                }
            }
     
            //Si on est à la fin de la grille
            if(grille[9][9] != 0){
                boucle_ok = false;
            }
     
        }
     
     
    //Ecriture de la grille générée
     
    for(int v=0; v<9;v++){
    	for(int h=0; h<9; h++){
    		cout << grille[v][h];
    		cout << " ";
    	}
    	cout << "\n";
    }
     
    }

    Merci d'avance pour votre aide.

  2. #2
    Expert éminent
    Avatar de PRomu@ld
    Homme Profil pro
    Ingénieur de Recherche
    Inscrit en
    Avril 2005
    Messages
    4 155
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 38
    Localisation : France, Vienne (Poitou Charente)

    Informations professionnelles :
    Activité : Ingénieur de Recherche
    Secteur : Enseignement

    Informations forums :
    Inscription : Avril 2005
    Messages : 4 155
    Points : 6 486
    Points
    6 486
    Par défaut
    J'ai transformé ton code en code C99 (et pas un mélange C / C++) et chez moi il se termine. Le résultat n'est pas correct mais il se termine . En même temps, j'ai peut-être viré quelque chose .

    Voilà le code transformé :

    Code C++ : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
    94
    95
    96
    97
    98
    99
    100
    101
    102
    103
    104
    105
    106
    107
    108
    109
    110
    111
    112
    113
    114
    115
    116
    117
    118
    119
    120
    121
    122
    123
    124
    125
    126
    127
    128
    129
    130
    131
    132
    133
    134
    135
    136
    137
    138
    139
    140
    141
    142
    143
    144
    145
    146
    147
    148
    149
    150
    151
    152
    153
    154
    155
    156
    157
    158
    159
    160
    161
    162
    163
    164
    165
    166
    167
    168
    169
    170
    171
     
     
    #include <stdio.h>
    #include <stdlib.h>
    #include <time.h>
    #include <stdio.h>
    #include <stdbool.h>
     
    void affiche_grille( const char * const before , int g[9][9] )
    {
      printf( before );
      for( int i = 0 ; i < 9 ; ++i )
        {
          for( int j = 0 ; j < 9 ; ++j )
    	{
    	  printf( "%d " , g[i][j] );
    	}
          printf( "\n");
        }
    }
     
    int main( void )
    {
      //Initialisations
      int grille[9][9];
      int grille_temp[3][9];
      int min = 1, max = 9, ligne = 0;
      bool boucle_ok = true, nombre_ok = false, possibilites[9], carre_ok = true, ligne_ok = true;
     
      //MISES A ZERO
     
      //grille
      for(int i=0; i<9; i++){
        for(int j=0; j<9; j++){
          grille[i][j] = 0;
        }
      }
     
      //grille_temp
      for(int i=0; i<3; i++){
        for(int j=0; j<9; j++)
          {
          grille_temp[i][j] = 0;
          }
      }
     
      affiche_grille( "grille : \n" ,  grille ) ;
      affiche_grille( "grille_temp : \n" , grille_temp );
     
      //Tableau de bool
      for(int i=0; i<9; i++){
        possibilites[i] = false;
      }
     
      //Initialisation du temps
      srand(time(NULL));
     
      //Remplissage de la grille
      while(boucle_ok){
        //Génération de la première ligne
        for(int i=0; i<9; i++){
          do{
    	nombre_ok = true;
    	grille[ligne][i] = (rand() % (max - min + 1)) + min;
    	for(int k=0; k<9; k++){
    	  if (k!=i){
    	    if(grille[ligne][k] == grille[ligne][i]){
    	      nombre_ok = false;
    	    }
    	  }
    	}
          }while (!nombre_ok);
        }
        //Fin de génération de la première ligne
        if(ligne == 0 || ligne == 3 || ligne == 6){//Si c'est la première ligne, elle est bonne
          ligne++;
        }
        else{
          for(int t= (ligne - 1); t>=0; t--){
    	for(int w=0; w<9; w++){
    	  if(grille[t][w] == grille[ligne][w]){
    	    ligne_ok = false;
    	  }
    	}
          }
     
          //Si "ligne" vaut toujous 2, les 3 premières lignes sont bonnes, on les passe à la "moulinette du carré"
          if((ligne_ok && ligne == 2) || (ligne_ok && ligne == 5) || (ligne_ok && ligne == 8)){
    	//Premier carré
    	for(int k=(ligne - 2); k<=ligne; k++){
    	  for(int l=0; l<3; l++){
    	    possibilites[(grille[k][l] - 1)] = true;
    	  }
    	}
    	//Vérification
    	for(int m=0; m<9; m++){
    	  if(!possibilites[m]){
    	    carre_ok = false;
    	  }
    	}
     
    	//Remise à zéro de la variable
    	for(int i=0; i<9; i++){
    	  possibilites[i] = false;
    	}
    	//Fin du premier carré
     
    	//Après le premier carré, le second, mais seulement si le premier est juste
    	if(carre_ok){
    	  for(int k=(ligne - 2); k<=ligne; k++){
    	    for(int l=3; l<6; l++){
    	      possibilites[(grille_temp[k][l] -1)] = true;
    	    }
    	  }
    	  //Vérification
    	  for(int m=0; m<9; m++){
    	    if(!possibilites[m]){
    	      carre_ok = false;
    	    }
    	  }
     
    	  //Remise à 0 de la variable
    	  for(int i=0; i<9; i++){
    	    possibilites[i] = false;
    	  }
     
    	  //Si le deuxième carré est juste, on passe au troisième
    	  if(carre_ok){
    	    for(int k=(ligne - 2); k<=ligne; k++){
    	      for(int l=6; l<9; l++){
    		possibilites[(grille_temp[k][l] -1)] = true;
    	      }
    	    }
    	    //Vérification
    	    for(int m=0; m<9; m++){
    	      if(!possibilites[m]){
    		carre_ok = false;
    	      }
    	    }
     
    	    //Remise à 0 de la variable
    	    for(int i=0; i<9; i++){
    	      possibilites[i] = false;
    	    }
    	  }
    	}
    	else{//Si ce n'est pas bon, c'est reparti pour la génération des 2 lignes
    	  ligne = ligne -1;
    	}
          }
          else if(ligne_ok){
    	ligne++;
          }
          else{
    	//Si la ligne est fausse, on remet le bool "ligne_ok" à true
    	ligne_ok = true;
          }
        }
     
        //Si on est à la fin de la grille
        if(grille[9][9] != 0){
          boucle_ok = false;
        }
     
      }
     
      //Ecriture de la grille générée  
      affiche_grille( "grille en fin :\n " , grille );
     
      return EXIT_SUCCESS ;
    }

    Le résultat de l'exécution est :

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    grille : 
    0 0 0 0 0 0 0 0 0 
    0 0 0 0 0 0 0 0 0 
    0 0 0 0 0 0 0 0 0 
    0 0 0 0 0 0 0 0 0 
    0 0 0 0 0 0 0 0 0 
    0 0 0 0 0 0 0 0 0 
    0 0 0 0 0 0 0 0 0 
    0 0 0 0 0 0 0 0 0 
    0 0 0 0 0 0 0 0 0 
    grille_temp : 
    0 0 0 0 0 0 0 0 0 
    0 0 0 0 0 0 0 0 0 
    0 0 0 0 0 0 0 0 0 
    0 0 0 0 0 0 0 0 0 
    0 0 0 0 0 0 0 0 0 
    0 0 0 0 0 0 0 0 0 
    0 0 0 0 0 0 0 0 0 
    0 0 0 0 0 0 0 0 0 
    0 0 0 0 0 0 0 0 0 
    grille en fin :
     4 9 1 3 6 2 8 7 5 
    0 0 0 0 0 0 0 0 0 
    0 0 0 0 0 0 0 0 0 
    0 0 0 0 0 0 0 0 0 
    0 0 0 0 0 0 0 0 0 
    0 0 0 0 0 0 0 0 0 
    0 0 0 0 0 0 0 0 0 
    0 0 0 0 0 0 0 0 0 
    0 0 0 0 0 0 0 0 0
    Comme tu peux le constater seule la première ligne est correcte.

    Un conseil : effectues une recherche dans le forum, le sujet a déjà été abordé.

  3. #3
    Membre émérite
    Avatar de SpiceGuid
    Homme Profil pro
    Inscrit en
    Juin 2007
    Messages
    1 704
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Loire (Rhône Alpes)

    Informations forums :
    Inscription : Juin 2007
    Messages : 1 704
    Points : 2 990
    Points
    2 990
    Par défaut
    Ma proposition d'algorithme :
    1. commence par 9 lignes 1 2 3 4 5 6 7 8 9, c'est une grille valide
    2. si tu fais une coupe (comme avec un paquet de cartes) d'une grille valide tu obtiens une nouvelle grille valide
    3. fait 9 coupes horizontales et 9 coupes verticales
    4. il ne te reste plus qu'à masquer 9 chiffres
    Du même auteur: mon projet, le dernier article publié, le blog dvp et le jeu vidéo.
    Avant de poser une question je lis les règles du forum.

  4. #4
    Membre du Club
    Profil pro
    Inscrit en
    Décembre 2007
    Messages
    59
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Décembre 2007
    Messages : 59
    Points : 55
    Points
    55
    Par défaut
    je ne pense pas que ta solution fonctionne spiceguid, il y a plus de règle que ça au sudoku, il faut que les chiffres par carré de 3x3 complètent une série de 1 à 9 et pas uniquement les lignes verticales et horizontales

  5. #5
    Membre expérimenté
    Avatar de Rakken
    Homme Profil pro
    Inscrit en
    Août 2006
    Messages
    1 257
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France

    Informations forums :
    Inscription : Août 2006
    Messages : 1 257
    Points : 1 341
    Points
    1 341
    Par défaut
    Un jour de morne ennuis au boulot, avec un collegue on a codé un résolveur de sudoku. Un truc très basique, qui place un chiffre valide (selon les regles basique "pas deux fois le meme chiffre dans un carre, dans une ligne, dans une colone"). D'abord il placait les chiffres sûr, puis après fesait des hypotheses. Et ainsi de suite. Et quand ca foire, il remontait a la derniere hypothese pour en placer un autre (et si rien ne correspondait pour la derniere hypothèse, alors on remonte a l'hypothese précédente et ainsi de suite).
    Le truc était relativement efficace et remplaissait correctement les grilles (bon, dans la premiere version, il avait tendance a modifier des hyptheses de temps en temps ) et on s'est rendu compte qu'en partant d'une grille vide qu'on "résolvait" et en rajoutant un poil d'aléatoire, on avait un générateur tout a fait correct. Et la, il n'y avais plus qu'a supprimer des chiffres au hasard.

    Par contre, pour qu'une grille soit valide, une des règles est que pour une grille, il n'existe qu'une seule et unique solution possible, et ca, on a pas trouvé de solution propre pour le vérifier (genre plus propre que tester toutes les solutions).
    De la même maniere, une fois nos grilles faites, aucune idée du niveau de difficulté de la grille générée. Et ca pour le coup, on a pas trouvé du tout de solution.
    Rakken

    Oneira, un monde imaginaire d'Heroic Fantasy.

    Parce que la présomption d'innocence est un des fondements de notre pays et qu'elle doit le rester, dans tous les domaines : http://www.laquadrature.net/

  6. #6
    Membre émérite
    Avatar de SpiceGuid
    Homme Profil pro
    Inscrit en
    Juin 2007
    Messages
    1 704
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Loire (Rhône Alpes)

    Informations forums :
    Inscription : Juin 2007
    Messages : 1 704
    Points : 2 990
    Points
    2 990
    Par défaut
    je ne pense pas que ta solution fonctionne spiceguid, il y a plus de règle que ça au sudoku, il faut que les chiffres par carré de 3x3 complètent une série de 1 à 9
    Kyaan, du coup ça fait une chouette d'article.
    Du même auteur: mon projet, le dernier article publié, le blog dvp et le jeu vidéo.
    Avant de poser une question je lis les règles du forum.

  7. #7
    Alp
    Alp est déconnecté
    Expert éminent sénior

    Avatar de Alp
    Homme Profil pro
    Inscrit en
    Juin 2005
    Messages
    8 575
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 35
    Localisation : France, Bouches du Rhône (Provence Alpes Côte d'Azur)

    Informations forums :
    Inscription : Juin 2005
    Messages : 8 575
    Points : 11 860
    Points
    11 860
    Par défaut
    Citation Envoyé par SpiceGuid Voir le message
    Kyaan, du coup ça fait une chouette d'article.
    On a déjà un article sur un solveur de sudoku en prolog... en ocaml ça le ferait (m'enfin là il s'agit de générer une grille résoluble je crois)

  8. #8
    Expert éminent
    Avatar de PRomu@ld
    Homme Profil pro
    Ingénieur de Recherche
    Inscrit en
    Avril 2005
    Messages
    4 155
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 38
    Localisation : France, Vienne (Poitou Charente)

    Informations professionnelles :
    Activité : Ingénieur de Recherche
    Secteur : Enseignement

    Informations forums :
    Inscription : Avril 2005
    Messages : 4 155
    Points : 6 486
    Points
    6 486
    Par défaut
    De la même maniere, une fois nos grilles faites, aucune idée du niveau de difficulté de la grille générée. Et ca pour le coup, on a pas trouvé du tout de solution.
    En fait généralement, le niveau de difficulté est lié aux nombres de position de départ que tu fournis, plus tu en donnes plus c'est facile. Il est aussi lié au nombres de suppositions que tu es obligé de faire pour arriver à la solution. Si tout est déterministe (à chaque fois tu trouves directement le nombre qu'il faut mettre dans une case), c'est aussi plus facile.

    (m'enfin là il s'agit de générer une grille résolvable je crois)
    Résoluble

  9. #9
    Alp
    Alp est déconnecté
    Expert éminent sénior

    Avatar de Alp
    Homme Profil pro
    Inscrit en
    Juin 2005
    Messages
    8 575
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 35
    Localisation : France, Bouches du Rhône (Provence Alpes Côte d'Azur)

    Informations forums :
    Inscription : Juin 2005
    Messages : 8 575
    Points : 11 860
    Points
    11 860
    Par défaut
    Citation Envoyé par PRomu@ld Voir le message
    En fait généralement, le niveau de difficulté est lié aux nombres de position de départ que tu fournis, plus tu en donnes plus c'est facile. Il est aussi lié au nombres de suppositions que tu es obligé de faire pour arriver à la solution. Si tout est déterministe (à chaque fois tu trouves directement le nombre qu'il faut mettre dans une case), c'est aussi plus facile.
    C'est tout à fait ça.

    Citation Envoyé par PRomu@ld Voir le message
    Résoluble
    Tu disais ?

  10. #10
    Rédacteur

    Avatar de Matthieu Brucher
    Profil pro
    Développeur HPC
    Inscrit en
    Juillet 2005
    Messages
    9 810
    Détails du profil
    Informations personnelles :
    Âge : 42
    Localisation : France, Pyrénées Atlantiques (Aquitaine)

    Informations professionnelles :
    Activité : Développeur HPC
    Secteur : Industrie

    Informations forums :
    Inscription : Juillet 2005
    Messages : 9 810
    Points : 20 970
    Points
    20 970
    Par défaut
    Citation Envoyé par Rakken Voir le message
    Par contre, pour qu'une grille soit valide, une des règles est que pour une grille, il n'existe qu'une seule et unique solution possible, et ca, on a pas trouvé de solution propre pour le vérifier (genre plus propre que tester toutes les solutions).
    De la même maniere, une fois nos grilles faites, aucune idée du niveau de difficulté de la grille générée. Et ca pour le coup, on a pas trouvé du tout de solution.
    C'est un grand classique.
    Pour savoir s'il n'y a qu'une seule solution, il faut un autre solveur qui ne fait pas de l'essai erreur, mais qui utilise les règles (cf un autre topic).
    Et pour la difficulté, il suffit de prendre ce solveur évolué et de compter combien de fois chaque règle a dû être appliquée.

    Citation Envoyé par PRomu@ld Voir le message
    En fait généralement, le niveau de difficulté est lié aux nombres de position de départ que tu fournis, plus tu en donnes plus c'est facile. Il est aussi lié au nombres de suppositions que tu es obligé de faire pour arriver à la solution. Si tout est déterministe (à chaque fois tu trouves directement le nombre qu'il faut mettre dans une case), c'est aussi plus facile.
    En fait non. Le nombre minimal de positions de départ est 17, mais les grilles difficiles et surtout la plus difficile connue en ont environ 20.
    Ensuite, dans un vrai solveur, il n'y a jamais de devinette. Déjà, toutes les grilles usuelles en France sont en réalité d'un niveau très très très bas (pas de swordfish, rarement de groupes cachés, ...)

  11. #11
    Alp
    Alp est déconnecté
    Expert éminent sénior

    Avatar de Alp
    Homme Profil pro
    Inscrit en
    Juin 2005
    Messages
    8 575
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 35
    Localisation : France, Bouches du Rhône (Provence Alpes Côte d'Azur)

    Informations forums :
    Inscription : Juin 2005
    Messages : 8 575
    Points : 11 860
    Points
    11 860
    Par défaut
    C'est ce qu'il disait je crois. La difficulté à trouver un nouveau nombre dépend notamment des hypothèses supplémentaires à faire pour trouver ce nombre (parfois il faut trouver 5 autres nombres par exemple, même s'il y en a déàj pas mal sur la grille).

  12. #12
    Rédacteur

    Avatar de Matthieu Brucher
    Profil pro
    Développeur HPC
    Inscrit en
    Juillet 2005
    Messages
    9 810
    Détails du profil
    Informations personnelles :
    Âge : 42
    Localisation : France, Pyrénées Atlantiques (Aquitaine)

    Informations professionnelles :
    Activité : Développeur HPC
    Secteur : Industrie

    Informations forums :
    Inscription : Juillet 2005
    Messages : 9 810
    Points : 20 970
    Points
    20 970
    Par défaut
    Citation Envoyé par Alp Voir le message
    C'est ce qu'il disait je crois. La difficulté à trouver un nouveau nombre dépend notamment des hypothèses supplémentaires à faire pour trouver ce nombre (parfois il faut trouver 5 autres nombres par exemple, même s'il y en a déàj pas mal sur la grille).
    Romu a dit que généralement la difficulté dépendait du nombre de positions de départ. Ce n'est pas exact. Déjà, tu prends une grille et tu appliques des permutations, et tu obtiens des grilles très simples ou des grilles super compliquées. Donc ce n'est pas un bon indicateur. Le seul indicateur valable reste le compte des différentes techniques utilisées (les plus classiques sont les une valeur par groupe, seule valeur dans le groupe, les groupes visibles ou les groupes invisibles, puis les techniques avancées comme le Swordfish et ce genre de joyeusetés).

  13. #13
    Alp
    Alp est déconnecté
    Expert éminent sénior

    Avatar de Alp
    Homme Profil pro
    Inscrit en
    Juin 2005
    Messages
    8 575
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 35
    Localisation : France, Bouches du Rhône (Provence Alpes Côte d'Azur)

    Informations forums :
    Inscription : Juin 2005
    Messages : 8 575
    Points : 11 860
    Points
    11 860
    Par défaut
    Il faudra que je regarde ça de plus près, tiens


  14. #14
    Expert éminent
    Avatar de PRomu@ld
    Homme Profil pro
    Ingénieur de Recherche
    Inscrit en
    Avril 2005
    Messages
    4 155
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 38
    Localisation : France, Vienne (Poitou Charente)

    Informations professionnelles :
    Activité : Ingénieur de Recherche
    Secteur : Enseignement

    Informations forums :
    Inscription : Avril 2005
    Messages : 4 155
    Points : 6 486
    Points
    6 486
    Par défaut
    En fait non. Le nombre minimal de positions de départ est 17, mais les grilles difficiles et surtout la plus difficile connue en ont environ 20.
    Merci de la précision, il faudra que je regarde ça de plus près. En fait, comme je n'y joue pas forcément beaucoup, et surtout sur les grilles qu'on peut trouver en France, le nombre de position de départ est déjà assez important et est d'autant plus important que le niveau diminue. Mais comme tu le dis, les grilles françaises ne constituent pas une bonne référence , alors forcément j'ai tendance à raconter n'importe quoi .

  15. #15
    Rédacteur

    Avatar de Matthieu Brucher
    Profil pro
    Développeur HPC
    Inscrit en
    Juillet 2005
    Messages
    9 810
    Détails du profil
    Informations personnelles :
    Âge : 42
    Localisation : France, Pyrénées Atlantiques (Aquitaine)

    Informations professionnelles :
    Activité : Développeur HPC
    Secteur : Industrie

    Informations forums :
    Inscription : Juillet 2005
    Messages : 9 810
    Points : 20 970
    Points
    20 970
    Par défaut
    Citation Envoyé par PRomu@ld Voir le message
    Merci de la précision, il faudra que je regarde ça de plus près. En fait, comme je n'y joue pas forcément beaucoup, et surtout sur les grilles qu'on peut trouver en France, le nombre de position de départ est déjà assez important et est d'autant plus important que le niveau diminue. Mais comme tu le dis, les grilles françaises ne constituent pas une bonne référence , alors forcément j'ai tendance à raconter n'importe quoi .
    A une époque, j'avais fait un solveur qui utilisait pas mal de techniques usuelles et 2-3 avancées. Mais le code est pourri. Je voulais m'en servir pour faire un générateur de grilles, mais jamais eu le temps. Et puis il y a suffisamment de grilles et d'outils d'aide sur le net
    Il y a quelques fora sympa à ce niveau où des spécialistes discutaient de ces problèmes, mais je ne me souviens plus des adresses

Discussions similaires

  1. Sudoku, Génération de grille
    Par theprogrammeur dans le forum C++
    Réponses: 3
    Dernier message: 30/06/2008, 21h38
  2. Génération de grilles de mots
    Par mavina dans le forum API standards et tierces
    Réponses: 1
    Dernier message: 05/02/2008, 19h44
  3. Vérification d'une grille sudoku
    Par ergogirl dans le forum Pascal
    Réponses: 4
    Dernier message: 26/02/2007, 12h52
  4. [Free Pascal] Présentation grille Sudoku
    Par cocofoto dans le forum Free Pascal
    Réponses: 4
    Dernier message: 14/02/2007, 14h37

Partager

Partager
  • Envoyer la discussion sur Viadeo
  • Envoyer la discussion sur Twitter
  • Envoyer la discussion sur Google
  • Envoyer la discussion sur Facebook
  • Envoyer la discussion sur Digg
  • Envoyer la discussion sur Delicious
  • Envoyer la discussion sur MySpace
  • Envoyer la discussion sur Yahoo