[C/C++]Matrice de pointeur sur struct&malloc

Résolu/Fermé
achoura Messages postés 35 Date d'inscription jeudi 24 janvier 2008 Statut Membre Dernière intervention 5 avril 2010 - 30 mars 2008 à 13:59
Mahmah Messages postés 496 Date d'inscription lundi 17 septembre 2007 Statut Membre Dernière intervention 22 juin 2010 - 5 avril 2008 à 14:29
Bonjour
je suis en train de réaliser un petit jeu de réflexion "Sudoku" en C (avec Boraland C++). j'ai une problème au niveau de l'allocation dynamique
1)---->j'ai commencé par une matrice de pointeur sur structure
typedef int tableau[9];
typedef struct {
               tableau tab;
               int solution;
               }cellule;
typedef cellule* sudoku[9][9];


2)--->çi-dessous je vous donne le code de mon programme (pas complet mais ça pose pas une problème) mais dés que le programme essaye d'accéder au case du structure j'ai une problème, je peut vous affirmer que c'est une problème d'allocation dynamique qui manque et dont je suis hésiter ou je doit mettre ma fonction malloc et avec qu'elle paramétere,,,
svp veuillez compiler mon minuscule prog et m'aider à régler les erreurs que j'ai..merci d'avance pour votre soutient
/**---------------------------------------------**\
|*  Mini-projet: programmation C             	 *|
|*  sujet: Sudoku                             		 *|
|*  Elaboré par: Achraf Noomane		          *|
|*               Med Anis Harrak              		 *|
|*                                              			 *|
\**---------------------------------------------**/


#include<stdio.h>
#include<conio.h>         //définir les bibliothèque
#include<windows.h>
#include<stdlib.h>

#define gauche 18
#define haut 4
#define espace ' '

typedef int tableau[9];
typedef struct {
               tableau tab;
               int solution;
               }cellule;
typedef cellule* sudoku[9][9];   //< je ne suis pas sure la
 
/*-------------------------------------------------------------------------------*/
void write1xy(int x,int y,char c[80])
{

	gotoxy(x,y);
   printf("%s",c);
}

void Sudoku_Board()  //afficher la grille de mon sudoku
{

 write1xy(gauche,haut,   "+---+---+---+---+---+---+---+---+---+ \0");
 write1xy(gauche,haut+1, "|   |   |   I   |   |   I   |   |   | \0");
 write1xy(gauche,haut+2, "+---+---+---+---+---+---+---+---+---+\0");
 write1xy(gauche,haut+3, "|   |   |   I   |   |   I   |   |   |\0");
 write1xy(gauche,haut+4, "+---+---+---+---+---+---+---+---+---+\0");
 write1xy(gauche,haut+5, "|   |   |   I   |   |   I   |   |   |\0");
 write1xy(gauche,haut+6, "+===+===+===+===+===+===+===+===+===+\0");
 write1xy(gauche,haut+7, "|   |   |   I   |   |   I   |   |   |\0");
 write1xy(gauche,haut+8, "+---+---+---+---+---+---+---+---+---+\0");
 write1xy(gauche,haut+9, "|   |   |   I   |   |   I   |   |   |\0");
 write1xy(gauche,haut+10,"+---+---+---+---+---+---+---+---+---+\0");
 write1xy(gauche,haut+11,"|   |   |   I   |   |   I   |   |   |\0");
 write1xy(gauche,haut+12,"+===+===+===+===+===+===+===+===+===+\0");
 write1xy(gauche,haut+13,"|   |   |   I   |   |   I   |   |   |\0");
 write1xy(gauche,haut+14,"+---+---+---+---+---+---+---+---+---+\0");
 write1xy(gauche,haut+15,"|   |   |   I   |   |   I   |   |   |\0");
 write1xy(gauche,haut+16,"+---+---+---+---+---+---+---+---+---+\0");
 write1xy(gauche,haut+17,"|   |   |   I   |   |   I   |   |   |\0");
 write1xy(gauche,haut+18,"+---+---+---+---+---+---+---+---+---+\0");

}
/*------------------------------------------------------------------------*/
void Sudoku_Help_Board()
{
write1xy(2,2,"Resolveur de Sudoku ver Esprit/08/S2/P1\tAchraf Noomane & Anis harrak");
write1xy(2,5,"x=  | y=  |\0");
write1xy(2,7,"choix=\0");
write1xy(2,24,"F1-Aide F2-Enregistrer F3-Charger F5-Resoudre F8-Effacer ESC-Quit\n\0");
}

/*-------------------------------------------------------------------*/
void initialiser_sudoku(cellule *sudoku[9][9])

{	
cellule *grid[9][9]
grid=(liste) malloc(sizeof(cellule));

 for(int i=0;i<9;i++)
   	{
      for(int j=0;j<9;j++)
      	{
         	for(int k=0;k<9;k++)
         	{
            sudoku[i][j]->tab[k]=k+1;  //<--ça marche pas la
            sudoku[i][j]->solution=0;   //<--je pense ici non plus
            }
         }
      }
}

/*--------------------------------------------------------------------*/
void Curseur(int x,int y,cellule *sudoku[9][9])
{
 int xr,yr;
 //écrire les coordonnées d'une case
 gotoxy(5,5); printf("%d",x);
 gotoxy(11,5); printf("%d",y);

 //écrire les choix possibles
 gotoxy(8,7);

 	for(int i=0;i<9;i++)
 		{	if (!sudoku[x][y]->tab[i]) //<---ici non plus
      		printf(" ");
      	else
         	printf("%d",i+1);
      }

//aller à la position sur la grille

xr=gauche+ x*4 -2;
yr=haut + y*2 -2;
gotoxy(xr,yr);
system("color 0c");

if(!sudoku[x][y]->solution)
	printf(" ");
else
	printf("%d",sudoku[x][y]->solution);

gotoxy(xr,yr);

}
/*-----------------------------------------------------------------*/

void vider(cellule *sudoku[9][9])
{
int x_vid,y_vid,i;

for(x_vid=0;x_vid<9;x_vid++)
	{
   	for(y_vid=0;y_vid<9;y_vid++)
    	{for(i=0;i<9;i++)
         {
         sudoku[x_vid][y_vid]->tab[i]=i+1 ;
         sudoku[x_vid][y_vid]->solution=0;
         Curseur(x_vid,y_vid,sudoku);
         }
      }
   }
}
/*---------------------------------------------------------------------*/

/*

fonction pour enregistrer dans une ficher
fonction pour charger depuis une ficher
*/
/*-------------------------------------------------------------------*/






/*---------------------------------------------------------*/
void main()
{

 cellule *grid[9][9];
 initialiser_sudoku(grid);
 int x,y;
 x=1;
 y=1;

Sudoku_Board();
Sudoku_Help_Board();
Curseur(x,y,grid);
 system("PAUSE");
}

14 réponses

Mahmah Messages postés 496 Date d'inscription lundi 17 septembre 2007 Statut Membre Dernière intervention 22 juin 2010 125
30 mars 2008 à 20:01
Salutations,

J'ai jeté un rapide coup d'œil et le code ne compilant pas direct je n'ai pas cherché plus.
(gotoxy et liste non définis)

Je mets en vrac mes commentaires:

1)
typedef int tableau[9];
typedef struct {
               tableau tab;
               int solution;
               }cellule;
typedef cellule* sudoku[9][9];   //< je ne suis pas sure la

C'est correct, on peut maintenant définir une variable de type sudoku.
sudoku grid;

2)
Cependant je ne vois pas la nécessité de faire un référence via des pointeurs sur les cellules.
typedef cellule sudoku_t[9][9];
C'est un avis personnel, je n'en tiendrai plus compte pour la suite.

3)
Je me permettrais également de changer le nom du type avec un _t. Certaines variables du même nom que le type masquent la définition du type. Chose qui vous oblige bien souvent à ne pas utiliser votre type mais à le redéfinir à l'identique pour chaque variable.

4)
void initialiser_sudoku(cellule *sudoku[9][9])
{	
cellule *grid[9][9]
grid=(liste) malloc(sizeof(cellule));

 for(int i=0;i<9;i++)
   	{
      for(int j=0;j<9;j++)
      	{
         	for(int k=0;k<9;k++)
         	{
            sudoku[i][j]->tab[k]=k+1;  //<--ça marche pas la
            sudoku[i][j]->solution=0;   //<--je pense ici non plus
            }
         }
      }
}

Je ferais:
void initialiser_sudoku( sudoku_t sudoku )
{
//   cellule *grid[9][9] // C'est qui lui ?
//   grid=(liste) malloc(sizeof(cellule));
// Vous faites une allocation mémoire dans une variable locale qui ne sert plus par la suite.
// La mémoire est perdue jusqu'à la fin du programme. (Si l'OS vous sauve la mise)

   int i;
   int j;
   int k;

   for ( i = 0 ; i < 9 ; i++ ) // Les déclarations dans le for c'est du C++.
   {
      for ( j = 0 ; j < 9 ; j++ )
      {
         sudoku[i][j] = (cellule_t*) malloc( sizeof( cellule ) ); // Allocation de la mémoire.

         for ( int k = 0 ; k < 9 ; k++ )
         {
            sudoku[i][j]->tab[k]=k+1;  //Quel joli nom, heureusement qu'il y a un commentaire ailleurs
            // Je vous mets un post après pour les valeurs jouables.
         }

         sudoku[i][j]->solution=0; // Lui par contre je ne sais pas à quoi il sert.
         // En tout cas il est sorti de la boucle.
      }
   }
}

Idée pour représenter les Valeurs jouables.


5)
 	for(int i=0;i<9;i++)
 		{	if (!sudoku[x][y]->tab[i]) //<---ici non plus
      		printf(" ");
      	else
         	printf("%d",i+1);
      }

Vous n'aviez jamais allouer de mémoire pour les cellules -> crash.

6)
write1xy(gauche,haut, "+---+---+---+---+---+---+---+---+---+ \0");
C'est moche.
6-a) Le caractère '\0' est déjà en fin de la chaîne car définie avec ".
6-b) Un retour chariot '\n' éviterait les trop nombreux gotoxy.
6-c) Regardez la table ASCII, les caractères 185 à 188 et 200 à 206 sont trop top pour dessiner un tableau.

M.
0
Mahmah Messages postés 496 Date d'inscription lundi 17 septembre 2007 Statut Membre Dernière intervention 22 juin 2010 125
30 mars 2008 à 20:04
Je viens de percuter... possible que le lien sur les valeurs possibles ne t'apprennes rien. ^^

M.
0
achoura Messages postés 35 Date d'inscription jeudi 24 janvier 2008 Statut Membre Dernière intervention 5 avril 2010 1
1 avril 2008 à 10:06
Bonjour,
merci pour votre aide, votre première remarque à propos:
{
2)
Cependant je ne vois pas la nécessité de faire un référence via des pointeurs sur les cellules.
typedef cellule sudoku_t[9][9];
C'est un avis personnel, je n'en tiendrai plus compte pour la suite.
}
----> seulement ça à résolu plein de problème, je vous souhaite le bonheur Mr
et voici une copie version Beta afin de compléter le reste,mais j'espère aussi vos commentaires utiles qui me permet d'optimiser ou d'améliorer le core de mon algorithme.
voici les points importants sur lesquelles je veut incister:
1)au niveau graphique, j'ai trouvé les fameux caractère ASCII pour dessiner un tableau mais je sais l'utiliser sauf comme ça
printf("%c%c",201,203)...etc mais comment pour centrer une grille au milieu du fenetre et faire des boucles pour afficher toute la grille sans utiliser le gotoxy à chaque lingne??
P.S. il faut tenir compte que je doit connaitre la position exacte de chaque cellule dans la grille pour que j'écrit une valeur dedans, regarde ces lignes par exemple:
//aller à la position sur la grille

xr=gauche+ x*4 -2;
yr=haut + y*2 -2;
gotoxy(xr,yr);

j'ai écrit ça en sachant que à chaque x<--x+1 ....... (x*4 -2) avance de 4 case ce qui coïncide avec la position dans la grille.

2)comment faire un coloration juste pour la position au se trouve un curseur(son background), je travaille sur Borland C++ version 5.01 et je connais pas les fonctions pour colorer sauf le system("color xy") et ça colore tout l'écran et ce n'est pas jolie du tout ,,,,,enfin pas du tout ce que je veut (ce que je veut c'est en cliquant par exemple sur les fléches du clavier ,le curseur se déplace dans ma grille en la colorant ,,,ça donne un jolie effet)

3)euuf je parle trop, dsl je ferai un peu d'effort comme même, merci de vouloir accepter de m'aider c sympa de ta part.

-------------------------------------------------------------------------------
/**---------------------------------------------**\
|*  Mini-projet: programmation C             	 *|
|*  sujet: Sudoku                             		 *|
|*  Elaboré par: Achraf Noomane		          *|
|*               Med Anis Harrak              		 *|
|*                                              			 *|
\**---------------------------------------------**/


#include<stdio.h>
#include<conio.h>         //définir les bibliothèque
#include<windows.h>
#include<stdlib.h>

#define gauche 18
#define haut 4
#define espace ' '

typedef int tableau[9];
typedef struct {
               tableau tab;
               int solution;
               }cellule;



/*-------------------------------------------------------------------------------*/
void write1xy(int x,int y,char c[80])
{

	gotoxy(x,y);
   printf("%s",c);
}

void Sudoku_Board()
{

 write1xy(gauche,haut,   "+---+---+---+---+---+---+---+---+---+ \0");
 write1xy(gauche,haut+1, "I   |   |   I   |   |   I   |   |   I \0");
 write1xy(gauche,haut+2, "+---+---+---+---+---+---+---+---+---+\0");
 write1xy(gauche,haut+3, "I   |   |   I   |   |   I   |   |   I\0");
 write1xy(gauche,haut+4, "+---+---+---+---+---+---+---+---+---+\0");
 write1xy(gauche,haut+5, "I   |   |   I   |   |   I   |   |   I\0");
 write1xy(gauche,haut+6, "+===+===+===*===+===+===*===+===+===+\0");
 write1xy(gauche,haut+7, "I   |   |   I   |   |   I   |   |   I\0");
 write1xy(gauche,haut+8, "+---+---+---+---+---+---+---+---+---+\0");
 write1xy(gauche,haut+9, "I   |   |   I   |   |   I   |   |   I\0");
 write1xy(gauche,haut+10,"+---+---+---+---+---+---+---+---+---+\0");
 write1xy(gauche,haut+11,"I   |   |   I   |   |   I   |   |   I\0");
 write1xy(gauche,haut+12,"+===+===+===*===+===+===*===+===+===+\0");
 write1xy(gauche,haut+13,"I   |   |   I   |   |   I   |   |   I\0");
 write1xy(gauche,haut+14,"+---+---+---+---+---+---+---+---+---+\0");
 write1xy(gauche,haut+15,"I   |   |   I   |   |   I   |   |   I\0");
 write1xy(gauche,haut+16,"+---+---+---+---+---+---+---+---+---+\0");
 write1xy(gauche,haut+17,"I   |   |   I   |   |   I   |   |   I\0");
 write1xy(gauche,haut+18,"+---+---+---+---+---+---+---+---+---+\0");

}
/*------------------------------------------------------------------------*/
void Sudoku_Help_Board()
{
write1xy(2,2,"Resolveur de Sudoku ver Esprit/08/S2/P1\tAchraf Noomane & Anis harrak");
write1xy(2,5,"x=  | y=  |\0");
write1xy(2,7,"choix=\0");
write1xy(2,24,"F1-Aide F2-Enregistrer F3-Charger F5-Resoudre F8-Effacer ESC-Quit\n\0");
}

/*-------------------------------------------------------------------*/
void initialiser_sudoku(cellule sudoku[9][9])

{
  for(int i=0;i<9;i++)
   	{
      for(int j=0;j<9;j++)
      	{
         	sudoku[i][j].solution=0;
			for(int k=0;k<9;k++)
         	{
            sudoku[i][j].tab[k]=k+1;
            
            }
         }
      }
}

/*--------------------------------------------------------------------*/
/*cette fontion permet de refraichir les coordonnées x et y, afficher les
choix possibles pour une case tant que le curseur y se trouve et d'écrire
la valeur entrer au clavier dans la grille afficher sur l'écran*/
/*--------------------------------------------------------------------*/
void Curseur(int x,int y,cellule sudoku[9][9])
{
 int xr,yr;
 //écrire les coordonnées d'une case
 gotoxy(5,5); printf("%d",x);
 gotoxy(11,5); printf("%d",y);

 //écrire les choix possibles
 gotoxy(8,7);

 	for(int i=0;i<9;i++)
 		{	if (sudoku[x][y].tab[i]==0)
      		printf(" ");
      	else
         	printf("%d",i+1);
      }

//aller à la position sur la grille

xr=gauche+ x*4 -2;
yr=haut + y*2 -2;
gotoxy(xr,yr);
system("color 0c");

if(!sudoku[x][y].solution)
	printf(" ");
else
	printf("%d",sudoku[x][y].solution);

gotoxy(xr,yr);

}
/*-----------------------------------------------------------------*/
/*cette fonction est semblable à la fonction initialisation
mais elle permet d'initianiliser les curseurs aussi*/
/*--------------------------------------------------------------------*/
void vider(cellule sudoku[9][9])
{
int x_vid,y_vid,i;

for(x_vid=0;x_vid<9;x_vid++)
	{
   	for(y_vid=0;y_vid<9;y_vid++)
    	{for(i=0;i<9;i++)
         {
         sudoku[x_vid][y_vid].tab[i]=i+1 ;
         sudoku[x_vid][y_vid].solution=0;
         Curseur(x_vid,y_vid,sudoku);
         }
      }
   }
}
/*---------------------------------------------------------------------*/

/*

fonction pour enregistrer dans une ficher
fonction pour charger depuis une ficher
*/
/*-------------------------------------------------------------------*/



/*---------------------------------------------------------*/
void main()
{

cellule sudoku_t[9][9];
int x=1;
int y=1;

initialiser_sudoku(sudoku_t);

Sudoku_Board();
Sudoku_Help_Board();

//printf("\n\tcoucou ca arrive ici\n");
//system("PAUSE");
//system("cls");
Curseur(x,y,sudoku_t);
 system("PAUSE");
}
0
achoura Messages postés 35 Date d'inscription jeudi 24 janvier 2008 Statut Membre Dernière intervention 5 avril 2010 1
1 avril 2008 à 11:10
suite,
voila, j'ai trouvé ce code en language Pascal,,,,,c'est exactement ce que je voulais faire mais je connais pas comment trduire ça en C, je connais le boucle et la structure mais je connais pas comment faire le test sur les touches en C aussi j'ai trouvé que les touches F5,F2 par exemple admet deux code ,
puff,,,je ne sais pas,,,si vous voulez m'aider ça sera avec plaisir.

BEGIN
  TextBackGround(COLBG);
  ClrScr;
 
  ViewSudoku;
  ViewHelp;
  Load;
 
  x:=1; y:=1;
 
  repeat
    { move kurzor }
    Kurzor(x,y,COLBG);
 
    { get char from keyb }
    ch:=readkey;
 
    if( ch=#0 )then
        ch:=readkey;
 
    { F1, F2, F3, F5, F8 keys }
    if( ch=#59 ) then Help;
    if( ch=#60 ) then Save;
    if( ch=#61 ) then Load;
    if( ch=#63 ) then while (Resolve) do;
    if( ch=#66 ) then Clear;
 
    { space as zero }
    if( ch=' ' )then ch:='0';
 
    { insert number }
    if( ch in ['0'..'9']) then
      begin
        s[x,y,0]:=ord(ch) - ord('0');
        Kurzor(x,y,COLBG);
        x:=x+1;
      end;
 
    { arrows }
    if( ch=#75 ) then x:=x-1;
    if( ch=#77 ) then x:=x+1;
    if( ch=#72 ) then y:=y-1;
    if( ch=#80 ) then y:=y+1;
 
    { home - end }
    if( ch=#71 ) then x:=1;
    if( ch=#79 ) then x:=9;
 
    { pageup - pagedown }
    if( ch=#73 ) then y:=1;
    if( ch=#81 ) then y:=9;
 
    { check position }
    if( x<1 ) then x:=9;
    if( x>9 ) then begin x:=1; y:=y+1; end;
    if( y<1 ) then y:=9;
    if( y>9 ) then y:=1;
 
  until (ch=#27);	{ ESC }
 
  { for safe }
  Save;
END.
 
0

Vous n’avez pas trouvé la réponse que vous recherchez ?

Posez votre question
Mahmah Messages postés 496 Date d'inscription lundi 17 septembre 2007 Statut Membre Dernière intervention 22 juin 2010 125
1 avril 2008 à 19:44
Rebonjour,

Pour le point 1) j'ai mis une fonction d'affichage d'une grille ici. (A recorriger car le copier-coller insère un '!' dans les lignes qui sont coupées sur le forum -_-) L'idée est toute simple, en C un caractère peut être écrit en ASCII directement via sa valeur en héxadécimal.

char cA = '\x41';
ou dans une chaîne
char *sABC = "A\x42C"

Pour reprendre l'ensemble de la fonction d'affichage. Il me semble qu'il est possible d'éviter de ré-afficher toute la grille alors que seul un nombre ou le curseur change. Le cadre peut être dessiné une seule fois au début de la partie.
Je n'avais pas fait attention au fait que la grille devait être centrée donc effectivement un gotoxy est une solution.

Point numéro 2)
Je n'ai jamais utilisé Borland C++, il faut chercher si il a une fonction pour faire ça. Sinon il faut faire une fonction dédiée au changement de la couleur de fond d'une case et la compiler différemment selon que l'on est sous Windows, Unix/Linux ou Mac. Pour Windows j'ai découvert cela par hasard il n'y a pas longtemps par ici. Par contre je ne suis pas sûr que l'on puisse changer la couleur de fond d'une zone seulement. Pour le curseur, bonne question, si on peut ça ne doit pas être loin des fonctions citées dans mon lien.

Pour attraper des caractères à la volée c'est la fonction getch() qui est dans conio.h.


Pour le code en lui même je ne voir pas de blême. (à part les \0 au bout des chaînes et toujours le gotoxy non défini chez moi, ça doit être Borland ça...)

M.
0
achoura Messages postés 35 Date d'inscription jeudi 24 janvier 2008 Statut Membre Dernière intervention 5 avril 2010 1
1 avril 2008 à 21:48
grand merci Mahmah,,,, mon tableau est vachement plus jolie avec ces caractères \xCA,\xCC,etc.........

tu es un bon gars mais tu me fera vraiment plaisir si tu m'aide un tout petit peut sur mon code actuelle_ver Beta
voila le code:

lorsque mon curseur arrive sur la 9-ème colonne, il y a des chiffres qui s'affiche partout,,,,,j'ai bien cassé la tête en ça mais j'ai rien trouvé,,,,mon dieu,,,donne à Mahmah la force,l'inspiration,et le foie pour m'aider,,,,Amène

/**---------------------------------------------**\
|*  Mini-projet: programmation C             	 *|
|*  sujet: Sudoku                             		 *|
|*  Elaboré par: Achraf Noomane		          *|
|*               Med Anis Harrak              		 *|
|*                                              			 *|
\**---------------------------------------------**/


#include<stdio.h>
#include<conio.h>         //définir les bibliothèque
#include<windows.h>
#include<stdlib.h>

#define gauche 25
#define haut 4
#define espace ' '
#define arrow_gauche 75
#define arrow_droite 77
#define arrow_haut 80
#define arrow_bas 72
typedef int tableau[9];
typedef struct {
               tableau tab;
               int solution;
               }cellule;



/*-------------------------------------------------------------------------------*/
void write1xy(int x,int y,char c[80])
{

	gotoxy(x,y);
   printf("%s",c);
}

void Sudoku_Board()
{

 write1xy(gauche,haut,   "\xC9\xCD\xCD\xCD\xCB\xCD\xCD\xCD\xCB\xCD\xCD\xCD\xCB\xCD\xCD\xCD\xCB\xCD\xCD\xCD\xCB\xCD\xCD\xCD\xCB\xCD\xCD\xCD\xCB\xCD\xCD\xCD\xCB\xCD\xCD\xCD\xBB");
 write1xy(gauche,haut+1, "\xBA   \xBA   \xBA   \xBA   \xBA   \xBA   \xBA   \xBA   \xBA   \xBA");
 write1xy(gauche,haut+2, "\xCC\xCD\xCD\xCD\xCE\xCD\xCD\xCD\xCE\xCD\xCD\xCD\xCE\xCD\xCD\xCD\xCE\xCD\xCD\xCD\xCE\xCD\xCD\xCD\xCE\xCD\xCD\xCD\xCE\xCD\xCD\xCD\xCE\xCD\xCD\xCD\xB9");
 write1xy(gauche,haut+3, "\xBA   \xBA   \xBA   \xBA   \xBA   \xBA   \xBA   \xBA   \xBA   \xBA");
 write1xy(gauche,haut+4, "\xCC\xCD\xCD\xCD\xCE\xCD\xCD\xCD\xCE\xCD\xCD\xCD\xCE\xCD\xCD\xCD\xCE\xCD\xCD\xCD\xCE\xCD\xCD\xCD\xCE\xCD\xCD\xCD\xCE\xCD\xCD\xCD\xCE\xCD\xCD\xCD\xB9");
 write1xy(gauche,haut+5, "\xBA   \xBA   \xBA   \xBA   \xBA   \xBA   \xBA   \xBA   \xBA   \xBA");
 write1xy(gauche,haut+6, "\xCC\xCD\xCD\xCD\xCE\xCD\xCD\xCD\xCE\xCD\xCD\xCD\xCE\xCD\xCD\xCD\xCE\xCD\xCD\xCD\xCE\xCD\xCD\xCD\xCE\xCD\xCD\xCD\xCE\xCD\xCD\xCD\xCE\xCD\xCD\xCD\xB9");
 write1xy(gauche,haut+7, "\xBA   \xBA   \xBA   \xBA   \xBA   \xBA   \xBA   \xBA   \xBA   \xBA");
 write1xy(gauche,haut+8, "\xCC\xCD\xCD\xCD\xCE\xCD\xCD\xCD\xCE\xCD\xCD\xCD\xCE\xCD\xCD\xCD\xCE\xCD\xCD\xCD\xCE\xCD\xCD\xCD\xCE\xCD\xCD\xCD\xCE\xCD\xCD\xCD\xCE\xCD\xCD\xCD\xB9");
 write1xy(gauche,haut+9, "\xBA   \xBA   \xBA   \xBA   \xBA   \xBA   \xBA   \xBA   \xBA   \xBA");
 write1xy(gauche,haut+10,"\xCC\xCD\xCD\xCD\xCE\xCD\xCD\xCD\xCE\xCD\xCD\xCD\xCE\xCD\xCD\xCD\xCE\xCD\xCD\xCD\xCE\xCD\xCD\xCD\xCE\xCD\xCD\xCD\xCE\xCD\xCD\xCD\xCE\xCD\xCD\xCD\xB9");
 write1xy(gauche,haut+11,"\xBA   \xBA   \xBA   \xBA   \xBA   \xBA   \xBA   \xBA   \xBA   \xBA");
 write1xy(gauche,haut+12,"\xCC\xCD\xCD\xCD\xCE\xCD\xCD\xCD\xCE\xCD\xCD\xCD\xCE\xCD\xCD\xCD\xCE\xCD\xCD\xCD\xCE\xCD\xCD\xCD\xCE\xCD\xCD\xCD\xCE\xCD\xCD\xCD\xCE\xCD\xCD\xCD\xB9");
 write1xy(gauche,haut+13,"\xBA   \xBA   \xBA   \xBA   \xBA   \xBA   \xBA   \xBA   \xBA   \xBA");
 write1xy(gauche,haut+14,"\xCC\xCD\xCD\xCD\xCE\xCD\xCD\xCD\xCE\xCD\xCD\xCD\xCE\xCD\xCD\xCD\xCE\xCD\xCD\xCD\xCE\xCD\xCD\xCD\xCE\xCD\xCD\xCD\xCE\xCD\xCD\xCD\xCE\xCD\xCD\xCD\xB9");
 write1xy(gauche,haut+15,"\xBA   \xBA   \xBA   \xBA   \xBA   \xBA   \xBA   \xBA   \xBA   \xBA");
 write1xy(gauche,haut+16,"\xCC\xCD\xCD\xCD\xCE\xCD\xCD\xCD\xCE\xCD\xCD\xCD\xCE\xCD\xCD\xCD\xCE\xCD\xCD\xCD\xCE\xCD\xCD\xCD\xCE\xCD\xCD\xCD\xCE\xCD\xCD\xCD\xCE\xCD\xCD\xCD\xB9");
 write1xy(gauche,haut+17,"\xBA   \xBA   \xBA   \xBA   \xBA   \xBA   \xBA   \xBA   \xBA   \xBA");
 write1xy(gauche,haut+18,"\xC8\xCD\xCD\xCD\xCA\xCD\xCD\xCD\xCA\xCD\xCD\xCD\xCA\xCD\xCD\xCD\xCA\xCD\xCD\xCD\xCA\xCD\xCD\xCD\xCA\xCD\xCD\xCD\xCA\xCD\xCD\xCD\xCA\xCD\xCD\xCD\xBC");

}
/*------------------------------------------------------------------------*/
void Sudoku_Help_Board()
{
write1xy(2,2,"Resolveur de Sudoku ver Esprit/08/S2/P1\tAchraf Noomane & Anis harrak");
write1xy(2,5,"x=  | y=  |");
write1xy(2,7,"choix=");
write1xy(2,24,"F1-Aide F2-Enregistrer F3-Charger F5-Resoudre F8-Effacer Q-Quit\n");
}

/*-------------------------------------------------------------------*/
void initialiser_sudoku(cellule sudoku[9][9])

{
  for(int i=0;i<9;i++)
   	{
      for(int j=0;j<9;j++)
      	{
         	sudoku[i][j].solution=0;
			for(int k=0;k<9;k++)
         	{
            sudoku[i][j].tab[k]=k+1;
            
            }
         }
      }
}

/*--------------------------------------------------------------------*/
/*cette fontion permet de refraichir les coordonnées x et y, afficher les
choix possibles pour une case tant que le curseur y se trouve et d'écrire
la valeur entrer au clavier dans la grille afficher sur l'écran*/
/*--------------------------------------------------------------------*/
void Curseur(int x,int y,cellule sudoku[9][9])
{
 int xr,yr;
 //écrire les coordonnées d'une case
 gotoxy(5,5); printf("%d",x);
 gotoxy(11,5); printf("%d",y);

 //écrire les choix possibles
 gotoxy(8,7);

 	for(int i=0;i<9;i++)
 		{	if (sudoku[x][y].tab[i]==0)
      		printf(" ");
      	else
         	printf("%d",i+1);
      }

//aller à la position sur la grille


xr=gauche+ x*4 -2;
yr=haut+1 + y*2 -2;
gotoxy(xr,yr);


if(!sudoku[x][y].solution)
	printf(" ");
else
	printf("%d",sudoku[x][y].solution);

gotoxy(xr,yr);

}
/*-----------------------------------------------------------------*/
/*cette fonction est semblable à la fonction initialisation
mais elle permet d'initianiliser les curseurs aussi*/
/*--------------------------------------------------------------------*/
void vider(cellule sudoku[9][9])
{
int x_vid,y_vid,i;

for(x_vid=0;x_vid<9;x_vid++)
	{
   	for(y_vid=0;y_vid<9;y_vid++)
    	{for(i=0;i<9;i++)
         {
         sudoku[x_vid][y_vid].tab[i]=i+1 ;
         sudoku[x_vid][y_vid].solution=0;
         Curseur(x_vid,y_vid,sudoku);
         }
      }
   }
}
/*---------------------------------------------------------------------*/

/*

fonction pour enregistrer dans une ficher
fonction pour charger depuis une ficher
*/
/*-------------------------------------------------------------------*/






/*---------------------------------------------------------*/
void main()
{

//cellule sudoku[9][9];
cellule sudoku_t[9][9];
long int x=1;
long int y=1;
char ch;
initialiser_sudoku(sudoku_t);//pour toute les cellules mettre .solution=0 et .tab={1,2,3,4,5,6,7,8,9}

Sudoku_Board();   //afficher le bord du sudoku
Sudoku_Help_Board();  //afficher le help dans la page


do
{
 Curseur(x,y,sudoku_t);
 fflush(stdin);
	ch=getch();
   	if(ch==0 || ch==224)
		{
			ch=getch();

					switch(ch){
								/*1*/case arrow_gauche:        // <--
                        	if(x==1)
                           {x=9;
                            y=y-1;
                           }
                           else
                           x=x-1;
									break;

								/*2*/case arrow_droite:       // -->
									if(x>8)
                           {x=1;
                            y=y+1;
                           }
                           else
                           x=x+1;
									break;
						
								/*3*/case arrow_haut:           // ^
									
                           y=y+1;
									break;

								/*4*/case arrow_bas:        // v

                           y=y-1;
									break;
								
								
							}
		}
		
		else
  
  {
    switch (ch)
     {
      case (49):{
                 sudoku_t[x][y].solution=1;
                 break;
                }
      case (50):{
                 sudoku_t[x][y].solution=2;
                 break;
                }
      case (51):{
                 sudoku_t[x][y].solution=3;
                 break;
                }
      case (52):{
                 sudoku_t[x][y].solution=4;
                 break;
                }
      case (53):{
                 sudoku_t[x][y].solution=5;
                 break;
                }
      case (54):{
                 sudoku_t[x][y].solution=6;
                 break;
                }
      case (55):{
                 sudoku_t[x][y].solution=7;
                 break;
                }
      case (56):{
                 sudoku_t[x][y].solution=8;
                 break;
                }
      case (57):{
                 sudoku_t[x][y].solution=9;
                 break;
                }
      
     }
   }

}
while(ch!=113)  ;  // pour quitter : q=113(ASCII)
gotoxy(2,25);
system("PAUSE");
}
0
Mahmah Messages postés 496 Date d'inscription lundi 17 septembre 2007 Statut Membre Dernière intervention 22 juin 2010 125
2 avril 2008 à 10:49
Je regarde ça se soir.

En attendant :
Faq C, developpez.com
Un certain nombre de sujets peuvent être intéressants.
Notamment:
- Comment vider le buffer clavier ?
- Pourquoi ne faut-il pas utiliser fflush(stdin) pour vider le buffer clavier ?
- (éventuellement) Comment effacer l'écran (portable) ?
- Comment gérer les touches étendues (F1..F12, flèches) ?
- Comment se positionner dans une console (séquence d'échapement ANSI) ? (sous réserve que cela marche :-/)
Et les autres pour la culture. ^^

M.
0
achoura Messages postés 35 Date d'inscription jeudi 24 janvier 2008 Statut Membre Dernière intervention 5 avril 2010 1
2 avril 2008 à 12:54
ok, merci comme même.
puisque vous allez consulter le forum le soir voila le mise à jour de mon travail depuis hier ^ ^
je j'espère que je suis pas trop collant.bye

/**---------------------------------------------**\
|*  Mini-projet: programmation C             	 *|
|*  sujet: Sudoku                             		 *|
|*  Elaboré par: Achraf Noomane		          *|
|*               Med Anis Harrak              		 *|
|*                                              			 *|
\**---------------------------------------------**/


#include<stdio.h>
#include<conio.h>         //les bibliothèques
#include<windows.h>
#include<stdlib.h>

#define gauche 25
#define haut 4             //variable de mise en page & bordure
#define espace ' '

#define arrow_gauche 75
#define arrow_droite 77  //touche directionnelle
#define arrow_haut 80
#define arrow_bas 72

#define F1_help_key
#define F2_save_key
#define F3_load_key   //touche fonction
#define F4_solve_key
#define F5_clear_key

typedef struct {
               int tab[10];
               int solution;
               }cellule;



/*-------------------------------------------------------------------------------*/
void write1xy(int g,long h,char c[90])
{
   Sleep(60);
	gotoxy(g,h);
   printf("%s",c);
}

void Sudoku_Board()
{

 write1xy(gauche,haut,   "\xC9\xCD\xCD\xCD\xCB\xCD\xCD\xCD\xCB\xCD\xCD\xCD\xCB\xCD\xCD\xCD\xCB\xCD\xCD\xCD\xCB\xCD\xCD\xCD\xCB\xCD\xCD\xCD\xCB\xCD\xCD\xCD\xCB\xCD\xCD\xCD\xBB");
 write1xy(gauche,haut+1, "\xBA   \xBA   \xBA   \xBA   \xBA   \xBA   \xBA   \xBA   \xBA   \xBA");
 write1xy(gauche,haut+2, "\xCC\xCD\xCD\xCD\xCE\xCD\xCD\xCD\xCE\xCD\xCD\xCD\xCE\xCD\xCD\xCD\xCE\xCD\xCD\xCD\xCE\xCD\xCD\xCD\xCE\xCD\xCD\xCD\xCE\xCD\xCD\xCD\xCE\xCD\xCD\xCD\xB9");
 write1xy(gauche,haut+3, "\xBA   \xBA   \xBA   \xBA   \xBA   \xBA   \xBA   \xBA   \xBA   \xBA");
 write1xy(gauche,haut+4, "\xCC\xCD\xCD\xCD\xCE\xCD\xCD\xCD\xCE\xCD\xCD\xCD\xCE\xCD\xCD\xCD\xCE\xCD\xCD\xCD\xCE\xCD\xCD\xCD\xCE\xCD\xCD\xCD\xCE\xCD\xCD\xCD\xCE\xCD\xCD\xCD\xB9");
 write1xy(gauche,haut+5, "\xBA   \xBA   \xBA   \xBA   \xBA   \xBA   \xBA   \xBA   \xBA   \xBA");
 write1xy(gauche,haut+6, "\xCC\xCD\xCD\xCD\xCE\xCD\xCD\xCD\xCE\xCD\xCD\xCD\xCE\xCD\xCD\xCD\xCE\xCD\xCD\xCD\xCE\xCD\xCD\xCD\xCE\xCD\xCD\xCD\xCE\xCD\xCD\xCD\xCE\xCD\xCD\xCD\xB9");
 write1xy(gauche,haut+7, "\xBA   \xBA   \xBA   \xBA   \xBA   \xBA   \xBA   \xBA   \xBA   \xBA");
 write1xy(gauche,haut+8, "\xCC\xCD\xCD\xCD\xCE\xCD\xCD\xCD\xCE\xCD\xCD\xCD\xCE\xCD\xCD\xCD\xCE\xCD\xCD\xCD\xCE\xCD\xCD\xCD\xCE\xCD\xCD\xCD\xCE\xCD\xCD\xCD\xCE\xCD\xCD\xCD\xB9");
 write1xy(gauche,haut+9, "\xBA   \xBA   \xBA   \xBA   \xBA   \xBA   \xBA   \xBA   \xBA   \xBA");
 write1xy(gauche,haut+10,"\xCC\xCD\xCD\xCD\xCE\xCD\xCD\xCD\xCE\xCD\xCD\xCD\xCE\xCD\xCD\xCD\xCE\xCD\xCD\xCD\xCE\xCD\xCD\xCD\xCE\xCD\xCD\xCD\xCE\xCD\xCD\xCD\xCE\xCD\xCD\xCD\xB9");
 write1xy(gauche,haut+11,"\xBA   \xBA   \xBA   \xBA   \xBA   \xBA   \xBA   \xBA   \xBA   \xBA");
 write1xy(gauche,haut+12,"\xCC\xCD\xCD\xCD\xCE\xCD\xCD\xCD\xCE\xCD\xCD\xCD\xCE\xCD\xCD\xCD\xCE\xCD\xCD\xCD\xCE\xCD\xCD\xCD\xCE\xCD\xCD\xCD\xCE\xCD\xCD\xCD\xCE\xCD\xCD\xCD\xB9");
 write1xy(gauche,haut+13,"\xBA   \xBA   \xBA   \xBA   \xBA   \xBA   \xBA   \xBA   \xBA   \xBA");
 write1xy(gauche,haut+14,"\xCC\xCD\xCD\xCD\xCE\xCD\xCD\xCD\xCE\xCD\xCD\xCD\xCE\xCD\xCD\xCD\xCE\xCD\xCD\xCD\xCE\xCD\xCD\xCD\xCE\xCD\xCD\xCD\xCE\xCD\xCD\xCD\xCE\xCD\xCD\xCD\xB9");
 write1xy(gauche,haut+15,"\xBA   \xBA   \xBA   \xBA   \xBA   \xBA   \xBA   \xBA   \xBA   \xBA");
 write1xy(gauche,haut+16,"\xCC\xCD\xCD\xCD\xCE\xCD\xCD\xCD\xCE\xCD\xCD\xCD\xCE\xCD\xCD\xCD\xCE\xCD\xCD\xCD\xCE\xCD\xCD\xCD\xCE\xCD\xCD\xCD\xCE\xCD\xCD\xCD\xCE\xCD\xCD\xCD\xB9");
 write1xy(gauche,haut+17,"\xBA   \xBA   \xBA   \xBA   \xBA   \xBA   \xBA   \xBA   \xBA   \xBA");
 write1xy(gauche,haut+18,"\xC8\xCD\xCD\xCD\xCA\xCD\xCD\xCD\xCA\xCD\xCD\xCD\xCA\xCD\xCD\xCD\xCA\xCD\xCD\xCD\xCA\xCD\xCD\xCD\xCA\xCD\xCD\xCD\xCA\xCD\xCD\xCD\xCA\xCD\xCD\xCD\xBC");

}
/*------------------------------------------------------------------------*/
void Sudoku_Help_Board()
{
write1xy(2,2,"Resolveur de Sudoku ver Esprit/08/S2/P1\tAchraf Noomane & Anis harrak");
write1xy(2,5,"x=  | y=  |");
write1xy(2,7,"choix=");
write1xy(2,24,"F1-Aide F2-Enregistrer F3-Charger F4-Resoudre F5-Effacer Q-Quit\n");
}

/*---------------------------------------------------------*/
void sudoku_limite(int *a,int *b)
{
if((*a==0) && (*b==1)) //coin sup gauche
	{
	*a=9;
	*b=9;
	}
if((*a==10) && (*b=9)) //coin inf droite
	{
	*a=1;
	*b=1;
	}
if((*a==0) && (*b!=1)) //bord gauche
	{
	*a=9;
	*b=*b-1;
	}
if((*a==10) && (*b!=9)) //bord droite
	{
	*a=1;
	*b=*b+1;
	}

if(*b==0) //bord sup
	*b=9;

if(*b==10) //bord inf
	*b=1;


}

/*-------------------------------------------------------------------*/
/*cette fonction permet d'initialiser la grille de sudoku */
/*-------------------------------------------------------------------*/
void initialiser_sudoku(cellule sudoku[9][9])

{
  for(int i=0;i<9;i++)
   	{
      for(int j=0;j<9;j++)
      	{
         	sudoku[i][j].solution=0;
			for(int k=0;k<9;k++)
         	{
            sudoku[i][j].tab[k]=k+1;
                }
         }
      }
}

/*--------------------------------------------------------------------*/
/*cette fontion permet de refraichir les coordonnées x et y, afficher les
choix possibles pour une case tant que le curseur y se trouve et d'écrire
la valeur entrer au clavier dans la grille afficher sur l'écran*/
/*--------------------------------------------------------------------*/
void Curseur(int *x,int *y,cellule sudoku[9][9])
{
 int xr,yr;
 //écrire les coordonnées d'une case
 sudoku_limite(x,y);
 gotoxy(5,5); printf("%d",*x);
 gotoxy(11,5); printf("%d",*y);

 //écrire les choix possibles
 gotoxy(8,7);

 	for(int i=0;i<9;i++)
 		{	if (sudoku[*x][*y].tab[i]==0)
      		printf(" ");
      	else
         	printf("%d",i+1);
      }

//aller à la position sur la grille


xr=gauche + (*x*4) -2;
yr=haut+(*y*2) -1;
gotoxy(xr,yr);

 textcolor(YELLOW);
 //textbackground(RED);

if(!sudoku[*x][*y].solution)
	cprintf(" ");
else
	cprintf("%d",sudoku[*x][*y].solution);

gotoxy(xr,yr);

}
/*--------------------------------------------------------------------*/
/*cette fonction est semblable à la fonction initialisation
mais elle permet d'initianiliser les curseurs aussi*/
/*--------------------------------------------------------------------*/
void vider(cellule sudoku[9][9])
{
int x_vid,y_vid,i;

for(x_vid=0;x_vid<9;x_vid++)
	{
   	for(y_vid=0;y_vid<9;y_vid++)
    	{for(i=0;i<9;i++)
         {
         sudoku[x_vid][y_vid].tab[i]=i+1 ;
         sudoku[x_vid][y_vid].solution=0;
         Curseur(&x_vid,&y_vid,sudoku);
         }
      }
   }
}
/*---------------------------------------------------------------------*/

/*

fonction pour enregistrer dans une ficher
fonction pour charger depuis une ficher
*/
/*-------------------------------------------------------------------*/









void main()
{

cellule sudoku_t[9][9];
int x_t=1;
int y_t=1;
char ch;
initialiser_sudoku(sudoku_t);//pour toute les cellules mettre .solution=0 et .tab={1,2,3,4,5,6,7,8,9}

Sudoku_Board();   //afficher le bord du sudoku
Sudoku_Help_Board();  //afficher le help dans la page


do
{
 Curseur(&x_t,&y_t,sudoku_t);
 fflush(stdin);


	ch=getch();
   	if(ch==0 || ch==224)
		{
			ch=getch();

					switch(ch){
								/*1*/case arrow_gauche:        // <--

                           x_t=x_t-1;
									break;

								/*2*/case arrow_droite:       // -->

                           x_t=x_t+1;
									break;

								/*3*/case arrow_haut:           // ^

                           y_t=y_t+1;
									break;

								/*4*/case arrow_bas:        // v

                           y_t=y_t-1;
									break;

               /*---------- Fonction Key ---------------*/

               			//case F1_help_key:

                        	//..;
                          // break;

                        //case F2_save_key:

                        	//..;
                           //break;

                        //case F3_load_key:

                        	//..;
                           //break;

                        //case F4_solve_key:

                        	//..;
                           //break;

                        //case F5_clear_key:

                        	//..;
                          // break;


							}
		}

		else

  {
    switch (ch)
     {
      case (49):{
                 sudoku_t[x_t][y_t].solution=1;
                 break;
                }
      case (50):{
                 sudoku_t[x_t][y_t].solution=2;
                 break;
                }
      case (51):{
                 sudoku_t[x_t][y_t].solution=3;
                 break;
                }
      case (52):{
                 sudoku_t[x_t][y_t].solution=4;
                 break;
                }
      case (53):{
                 sudoku_t[x_t][y_t].solution=5;
                 break;
                }
      case (54):{
                 sudoku_t[x_t][y_t].solution=6;
                 break;
                }
      case (55):{
                 sudoku_t[x_t][y_t].solution=7;
                 break;
                }
      case (56):{
                 sudoku_t[x_t][y_t].solution=8;
                 break;
                }
      case (57):{
                 sudoku_t[x_t][y_t].solution=9;
                 break;
                }

     }
   }

}
while(ch!=113)  ;  // pour quitter : q=113(ASCII)
gotoxy(2,25);
system("PAUSE");
}




/*my_note_book :: to use after

while ((ch = getchar()) != '\n' && ch != EOF); (vider le buffer clavier



*/
0
Mahmah Messages postés 496 Date d'inscription lundi 17 septembre 2007 Statut Membre Dernière intervention 22 juin 2010 125
2 avril 2008 à 22:17
J'en ai moins cette fois ou alors c'est plus des broutilles.

1).
if((*a==10) && (*b=9)) //coin inf droite
Hmm *Tousse Tousse*, oui, bon...

2).
if(ch==0 || ch==224)
224 ça peut paraître un peu grand pour des caractères qui ne vont que de -128 à +127.
Quand je fais flèche droite j'ai par exemple -32 puis 77.
Une constante serait également plus parlante qu'un '224' (Je suis chiant hein ?)

3).
switch (ch)
case (49):
...
case (50):
....
J'aimerais une version en 4 lignes avec en prime la possibilité d'effacer la valeur sans forcément en mettre une autre à la place... C'est possible ?

4).
void Sudoku_Board()
4-1).
Tout en double-traits ça fait lourd comme présentation. (à mon goût) Je ne mettrais que les séparations tous les trois nombres (comme sur les sudoku dans les magazines) ou alors avec un simple trait pour les délimitations qui ne sont pas celles des 9 zones principales. (Caractères ASCII B3, B6, D1, D7 etc) Ceci dit c'est une vraiment une broutille qui peut être laissée pour la fin.
4-2).
Il faudra bien préciser qu'il faut un processeur à 3.8 GHz pour avoir un affichage qui prend moins de une seconde...
Y a mieux. ^^

5).
Moi j'aime bien les petites fonctions toutes simples qui ne font rien. Je trouve ça plus lisible que les gros pavés...


M.
0
achoura Messages postés 35 Date d'inscription jeudi 24 janvier 2008 Statut Membre Dernière intervention 5 avril 2010 1
2 avril 2008 à 22:41
Bonjour,
je suis un peu triste Mahmah,,,car je pense que tu n'a pas vu ma question dans le poste qui vient avant, enfaite j'avais un problème dans le 9-ème colonne dans ma grille sudoku et il y a des affichages aléatoires des nombres.
je n'est pas trouvé la source de ce bug dans mon code. enfin, j'espère que tu m'aide à ce point la.
Sincerely Achraf
0
Mahmah Messages postés 496 Date d'inscription lundi 17 septembre 2007 Statut Membre Dernière intervention 22 juin 2010 125
2 avril 2008 à 23:24
A vrai dire chez moi le déplacement du curseur ne marche pas. Lorsque j'appuie sur une flèche le premier test échoue et il n'y a pas de deuxième lecture d'un caractère. J'ai modifié le test et je regarde ça, de prime abord, il n'y a pas de problème à part des cellules bizarrement initialisées.

Quel est le scénario qui produit l'erreur et quelle erreur est-ce exactement ?

(D'ailleurs dans le point 1), en plus de l'erreur, pourquoi l'un à 10 et l'autre à 9, le tableau est carré non ?)

M.
0
achoura Messages postés 35 Date d'inscription jeudi 24 janvier 2008 Statut Membre Dernière intervention 5 avril 2010 1
2 avril 2008 à 23:40
reslaut,,
voila une ficher .exe du programme afin de voir le résultat directent sans les interventions des compilateurs,,, le navigation du curseur marche bien chez moi sauf dans la 9ème colonne.

[url]http://uploading.com/files/Q8CJHA58/final_suite.exe.html[/url]
merci pour votre coopération
0
Mahmah Messages postés 496 Date d'inscription lundi 17 septembre 2007 Statut Membre Dernière intervention 22 juin 2010 125
3 avril 2008 à 00:06
Hrrmm *tousse tousse* En fait elle est trop louche la fonction sudoku_limite. Vu la fonction je n'avais pas trop chercher à la comprendre.

J'ai constaté un problème sur la dixième ligne (oui oui) et en regardant la fonction il y en a aussi sur les colonnes...

Je vais faire le grand retour de Super-tatasse mais "a" et "b" j'ai connu plus explicite comme nom de paramètres.
x et y... certes... (Moi qui ait toujours fait mes tableaux façon matrices anglaises :-/ )

Elle est à revoir et si elle est correcte elle est à commenter...

Je regarde ton exe...

M.
0
Mahmah Messages postés 496 Date d'inscription lundi 17 septembre 2007 Statut Membre Dernière intervention 22 juin 2010 125
3 avril 2008 à 00:19
Du fait que la fonction gotoxy n'est pas trouvée chez moi l'affichage est différent.

Le problème est constaté dans la dernière colonne.

Lorsque je fais droite dans la dernière colonne le curseur retourne systématiquement en première ligne, première colonne. Je soupçonne encore la fonction limite.

Allez hop, muselière !
#include "assert.h"


...

void sudoku_limite(int *a,int *b)
{
   ...

   assert( *a >= 0 );
   assert( *a < 9 );
   assert( *b >= 0 );
   assert( *b < 9 );
}


A mettre à la fin de ta fonction. (Ca peut être "cassert.h" des fois ou la fonction _assert ou des macro, il faut aller voir sa déclaration si elle n'est pas trouvée)

M.
0
achoura Messages postés 35 Date d'inscription jeudi 24 janvier 2008 Statut Membre Dernière intervention 5 avril 2010 1
3 avril 2008 à 19:33
salut Mahmah,,
merci de votre patience et ton courage avec moi

j'ai bien implémenter le code dont tu ma offert aussi bien la bibliothèque assert.h mais j'ai du les mettres en commentaires car elle est un peu méchante. elle force le programme a quitter dés qu'il passe la barrière à droite ou a gauche!!!!!!!!!! j'aime pas ça,,,,, même mon encadreur na pas trouvé le problème et il a envisagé de le voir un autre jour.

svp mahmah essay avec moi de resoudre ça ,,,, imagine que c'est votre code et vous avez cette problème,,,je pense pas qu'un médiocre erreur puisse vous etre difficile.
svp je tiens à votre aide.merci
0
Mahmah Messages postés 496 Date d'inscription lundi 17 septembre 2007 Statut Membre Dernière intervention 22 juin 2010 125
3 avril 2008 à 19:50
Le but de la macro assert est de planter si une condition est fausse. Elle est très pratique car on sait normalement où ça a planté exactement et donc quelle condition n'a pas été vérifiée. Son autre aspect est que si la macro NDEBUG est définie, assert ne fait plus rien. Elle ne produit même plus de code du tout; pratique donc pour debugguer et désactiver lorsque le logiciel est fini pour éviter de planter gentiment à la tête du client ^^.

Si assert n'a pas pu vérifier une des conditions c'est que tu es sorti des bornes de ton tableau car c'est ça exactement que je vérifiait.

Les indices du tableaux doivent être bornés à l'intervalle [0;8] tous les deux. (Ce qui fait bien 9 valeurs)

M.
0
achoura Messages postés 35 Date d'inscription jeudi 24 janvier 2008 Statut Membre Dernière intervention 5 avril 2010 1
5 avril 2008 à 01:28
Bonjour,
enfin, grâce a votre aide j'ai bien localiser la faute et c y é,,,,, ça marche !!!!!!!!!!!! youuuuuuuuuuuupi
l'erreur était un décalage au niveau de ma grille,,,,dans les boucles for je commence int i=0, ou int j=0 alors que mes coordonnés x et y commence int x=1 et y=1,,,,
ce que j'ai changé c'est de mettre un (-1) au coordonnée pour que je reste dans ma matrice....

j'ai ajouté aussi deux fonctions save et load qui permettent d'enregistrer vers une fichers ou de charger une grille.

mon travail avance!!
0
Mahmah Messages postés 496 Date d'inscription lundi 17 septembre 2007 Statut Membre Dernière intervention 22 juin 2010 125
5 avril 2008 à 14:29
Effectivement, un tableau de 9 cases est indicé de 0 à 8 donc par rapport à l'affichage et saisie des numéros de lignes et colonnes il y a un décalage à faire pour rester plus logique aux yeux de l'utilisateur pour qui la première colonne n'est pas la 0 mais la 1.

M.
0