SUDOKU C++

di il
22 risposte

SUDOKU C++

Ciao a tutti sto facendo un progetto all'universita' e mi hanno chiesto di progettare un sudoku.
devo essere in grado di generare sudoku OGNI VOLTA DIVERSI 3x3 4x4 e 5x5 di grandezza (anche se penso che l'algoritmo sia lo stesso per tutte le dimensioni).
ho completato la parte grafica ma e' diversi giorni che lavoro sull'algoritmo che crea lo schema vero e proprio e non ne esco fuori.
so che forse potrei usare il backtracking ma non ho idea di come fare.
potrebbe essermi d'aiuto anche solo il procedimento logico che fareste voi......!

GRAZIE IN ANTICIPO

22 Risposte

  • Re: SUDOKU C++

    Bene dunque è un algoritmo che si basa su un array bidimensionale,posso dirti come lo svilupperei io anche se mi troverei in difficoltà ma in logica:carico una matrice di A spazio di memoria di righe e di colonne tale che la prima riga vengano caricati numeri random da 1 a 9 tale che i numeri N caricati negli spazi devono rispettare la seguente condizione N<A;passando alla seconda riga,si controlla che nelle A colonne e A righe il numero non si ripeta,e si presegue con lo stesso principio di prima N<A numeri un modo casuale IN POSIZIONE casuale della 2° riga in questo caso,e via dicendo.
    la logica è questa più o meno,bisogna vedere come implementarlo poi.
    spero ti possa essere stato utile,facci sapere!
  • Re: SUDOKU C++

    Grazie il problema e' che facendo cosi non e' detto che la graglia venga venga completata del tutto perche potrebbe trovarsi ad inserire il valore in una cella dove e' possibile inserire solo quelvalore che pero' non e'corretto.....bisognerebbe tronare indietro in qualche punto e rifare ma nono so dove???
  • Re: SUDOKU C++

    Qualche anno fa ho scritto un progetto del sudoku opensource. Cerca in rete 'xsudoky' e guarda il modulo sudobacktrack.c

    Saluti,
    Max
  • Re: SUDOKU C++

    Ok grazie max ora ci do' un'occhiata e provero' a capirci qualcosa....

    grazie
  • Re: SUDOKU C++

    Si hai ragione,mi sono dimenticato la seconda parte un controllo in coda fondamentale che deve ..allora cominciamo a precisare che le posizioni dei numeri inseriti in modo random e in posizione random va salvata in delle variabili P,X,Z..ect. adesso controlliamo in coda dell'algoritmo SE riempendo l'intera matrice di valori 1/9 estremi compresi sono diversi dalle variabili P,X,Z situate nella posizione P,X,Z.. allora la matrice è pronta e la fai stampare,se invece non si verifica fai ricarice da capo la matrice (DO,WHILE).

    in questo modo lui genera un dei numeri casuali in posizione casuale della matrice come abbiamo detto prima;
    controlla che questi numeri non abbiano ripetizione;
    dopo aver controllato prova a riemprire l'intera matrice di altri numeri tranne nelle posizioni (p,s,x,y,etc);
    controlla che i valori che sono stati riempiti non si ripetano nella posizioni p,s,x,y.. (praticamente risolve il sudoko e vede se è corretto);
    dopo aver controllato se il sudoku funziona correttamente allora la matrice è pronta per essere stampata.
  • Re: SUDOKU C++

    Nel sudoku quando un numero non è certo vi sono dei possibili 'candidati'.
    Ogni cella deve tener traccia sia del numero (sia fisso che inserito) e dei contendenti.
    Il tutto può stare in un INT da 16 bit:
    
    
            FEDCBA9876543210
            +--+|||+-------+  cell's numbers (bits 0..8)
              | ||+---------  not used
              | |+----------  Is Candidate   (bit 10)
              | +-----------  Is Fixed       (bit 11)
              +-------------  not used
    
    Nella creazione o nello svolgimento (sono identiche) bisogna creare livelli della matrice (81 x il classico 9X9)
    e verificare le 3 regole del gioco: blocco, verticale e orizzontale.
    L'algoritmo è presto fatto:
    
      1) inizializzazione (vuoto o con qualche numero o quello che ti pare)
      2) trovo il primo candidato libero, lo cancello
      3) duplico matrice
      4) setto il candidato cancellato come numero
      5) il sudoku è valido?
      6)    se NO cancello matrice duplicata, livello--. Punto 2
      7) il sudoku è terminato?
      8)    se NO Punto 2
      9) FINE --- Pulire tutte i livelli 
    
    Ecco il giro su xsudoky:
    
    int solver (Puzzle *puzzle_in, Puzzle *puzzle_out)
    {
        int lev=0;
        int end=0;
        int found_candidate,not_good,found_solutions;
        int y,x;
    
        Puzzle *puzzle[81+1];
    
        found_solutions=0;
    
        if ((puzzle[lev]=malloc (sizeof(Puzzle)))==NULL)
            return (1);
    
        memcpy(puzzle[lev], puzzle_in, sizeof(Puzzle));
    
        while (!end)
        {
            found_candidate=search (puzzle[lev],&y,&x);
            if (found_candidate)
            {
                RemoveCandidato (&puzzle[lev]->cell[y][x], found_candidate);
    
                lev++;
                if ((puzzle[lev]=malloc (sizeof(Puzzle)))==NULL)
                    return (1);
    
                memcpy(puzzle[lev], puzzle[lev-1], sizeof(Puzzle));
    
                puzzle[lev]->cell[y][x]=0;
                add_number (puzzle[lev], y, x, found_candidate);
                
                not_good=verify(puzzle[lev],y,x);
                if (not_good)
                {
                    RemoveCandidato (&puzzle[lev-1]->cell[y][x], found_candidate);
                
                    free (puzzle[lev]);
                    lev--;
                }
            }
            else
            {
                if (puzzle[lev]->cell[y][x]==0x400)
                {
                    free (puzzle[lev]);
                    lev--;
                }
                else
                {
                    found_solutions++;
    
                    memcpy (puzzle_out,puzzle[lev],sizeof(Puzzle));
    
                    while (lev >= 0) free (puzzle[lev--]);
                    break;
                }
            }
        }
        return (0);
    }
    
    

    Saluti,
    Max
  • Re: SUDOKU C++

    Ok scusa max ma sono ancora alle prime armi e non riesco ancora a capire del tutto il procedimento.
    nel mio codice ho generato una matrice 9x9 16x16 o 25x25(a seconda della scelta dell'utente) e nella prima riga imposto numeri random e la completo.
    ecco il codice:
    
    int creasudokusemplice (table<char>& t)
    {
    	int x=t.rows();
    	int y;
    	char h;
    	int j,i,jj,ii; //indici
    	
    	for (j=0; j<x; j++)
    	{
    		for (i=0; i<x; i++)
    		{
    			t.at(j,i)=' ';    //riempo matrice " "
    		}
    	}
    	j=0;
    	for (i=0; i<x; i++)
    	{
    		again:
    		if (x==9) y=rand()%9+1;
    		if (x==16) y=rand()%16+1;
    		if (x==25) y=rand()%25+1;
    		h=inttochar(y);
    		for(ii=0; ii<x; ii++)
    		{
    			if (h==t.at(j,ii)) goto again; 
    		}
    		t.at(j,i)=h;
    	}
    	stampatre(t);
    	return(0);	
    }
    
    quante matrici devo creare dopo per poter tornare indietro in caso di errore?
    non mi sono ben chiari i passaggi 2) e 3)......!!!!!
    e x numeri candidati intendi i numeri che posso stare in una determinata posizione?
    e infine come faccio per ogni cella a sapere quali numeri posso o non possono andare bene?
  • Re: SUDOKU C++


    I candidati sono contendenti all'assegnamento del numero ufficiale.
    quante matrici devo creare dopo per poter tornare indietro in caso di errore?
    non mi sono ben chiari i passaggi 2) e 3)......!!!!!
    Un livello di matrice per ogni tentativo di risoluzione. Il livello massimo per un sudoku vuoto è il quadrato della base.

    Trovare il primo candidato libero significa scorrere il puzzle alla ricerca della cella con i valori proposti
    e restituirne uno cancellandolo dalla lista. Quest'ultimo andrà inserito COME NUMERO (stiamo provando) nella copia della
    matrice di livello successivo... e così avanti o indietro fino alla risoluzione.

    Ovviamente un algoritmo efficente deve eliminare gli aspiranti candidati su riga, colonna o blocco in fase
    di inserimento del digit.

    Una curiosità: la comunità debian/ubuntu proprio su questo modulo mi respinse il progetto per conflitto di licenze.
    Questo pezzetto è stato ritrascritto interamente passando da una "Common Public Licence" ad una "General Public Licence"
    ed ha fatto il giro del mondo.
    http://ixamit.blogspot.com/2009/10/xsudoky-e-libwx11.html
  • Re: SUDOKU C++

    Scusa ancora una cosa MAX ma come faccio a creare vari livelli di matrice.
    Nel tuo programma usavi : puzzle[lev] e incrementavi o decrementavi lev a seconda, in c++ come faccio a dichiarare un array di quel tipo(devo usare "new" credo ma in che modo?)?
    Nel mio caso uso la classe table, dove table e' un array di array (9x9 ad esempio).

    Grazie
  • Re: SUDOKU C++

    Ciao a tutti!! scrivo qua per non aprire un'altro topic visto che anch'io devo fare sto maledetto SUDOKU per l'università. Al momento il mio programma è ancora incompleto e ho finito da poco la funzione adibita ai controlli, sulla riga, sulla colonna e nei quadrati latini... I numeri da inserire nella tabella per il momento lo faccio tramte input, ma appena cerco di inserirne uno, a qualunque indirizzo della tabella decida di metterlo, mi viene fuori un "range error" e il programma termina prematuramente.
    PS: utilizzo una classe table fornita dal professore basata sui vector... se volete la posto per darci un'occhiata...

    HEADER FILE con la classe sudoku:
    #include "tab.h"
    #include "std_lib_facilities.h"
    
    enum Error {OK, FAIL, RIGA, COL, QUAD}; //codici di errore
    
    class Sudoku{
    	  
    	table<int>gametable(3); //crea tabella nxn
    	
    	
    public:
    	Sudoku();
    	Error game_start(int);
    	Error ctrl_game(int, int, int);
    	void filler();
    	void print_table();
    	~Sudoku();
    };
    File.cpp con le funzioni:
    #include "sudoku.h"
    #define Q1 sqrt(gametable.rows())	//
    #define Q2 sqrt(gametable.rows())*2     //
    #define Q3 sqrt(gametable.rows())*3     //Servono per delimitare i quadrati latini della tabella
    #define Q4 sqrt(gametable.rows())*4     //
    #define Q5 sqrt(gametable.rows())*5     //
    
    
    Sudoku::Sudoku(){ table<int> gametable(3);}
    
    Sudoku::~Sudoku(){gametable.resize(0,0);}
    /**********************************FUNZIONI*********************************/
    
    
    Error Sudoku::game_start(int dim){
    	int n;
    	switch(dim){
    	case '1': {n=9; gametable.resize(n,n);};
    	case '2': {n=16; gametable.resize(n,n);};
    	case '3': {n=25; gametable.resize(n,n);};
    	}               
    	filler();
    return OK;
    }
    
    /***************************************************************************/
    
    void Sudoku::print_table(){
    	cout<<"  0    1    2    3    4    5    6    7    8\n";
    	for(int y=0; y<gametable.cols(); y++){
    		for(int x=0; x<gametable.rows(); x++){
    			cout<<"| "<<gametable.at(x,y)<<" |";
    		}
    	cout<<" "<<y<<endl;
    	}
    	return;
    }
    
    /***************************************************************************/
    
    Error Sudoku:: ctrl_game(int a, int cx, int cy){
    //controllo colonna
    for (int y=0 ; y<gametable.cols(); y++){
    	if (y!=cy) if(gametable.at(cx,y)==a) return COL;
    }
    
    //controllo riga
    for (int x=0; x<gametable.rows(); x++){
    	if (x!=cx) if(gametable.at(x,cy)) return RIGA;
    }
    
    //controlli quadrati latini...
    if (cy>=0 && cy<Q1){ 
    	if (cx>=0 && cx<Q1){
    		for (int x=0; x<Q1; x++){
    		for (int y=0; y<Q1; y++){
    			if(x!=cx && y!=cy){ if(gametable.at(x,y)==a) return QUAD;}	
    		}
    	}
    	}
    	else if (cx>=Q1 && cx<Q2){
    		for (int x=Q1; x<Q2; x++){
    		for (int y=0; y<Q1; y++){
    			if(x!=cx && y!=cy){ if(gametable.at(x,y)==a) return QUAD;}	
    		}
    		}
    	}
    	else if (cx>=Q2 && cx<Q3){
    		for (int x=Q2; x<Q3; x++){
    		for (int y=0; y<Q1; y++){
    			if(x!=cx && y!=cy){ if(gametable.at(x,y)==a) return QUAD;}	
    		}
    		}
    	}
    	if(gametable.rows()>9){ 
    	if (cx>=Q3 && cx<Q4){	
    		for (int x=Q3; x<Q4; x++){
    		for (int y=0; y<Q1; y++){
    			if(x!=cx && y!=cy){ if(gametable.at(x,y)==a) return QUAD;}	
    		}
    		}
    	}
    	}
    	
    	if(gametable.rows()==25){
    	if (cx>=Q4 && cx<Q5){
    		for (int x=Q2; x<Q3; x++){
    		for (int y=0; y<Q1; y++){
    			if(x!=cx && y!=cy){ if(gametable.at(x,y)==a) return QUAD;}	
    		}
    		}
    	}
    }
    }
    
    else if (cy>=Q1 && cy<Q2){
    	if (cx>=0 && cx<Q1){
    		for (int x=0; x<Q1; x++){
    		for (int y=Q1; y<Q2; y++){
    			if(x!=cx && y!=cy){ if(gametable.at(x,y)==a) return QUAD;}	
    		}
    	}
    	}
    	else if (cx>=Q1 && cx<Q2){
    		for (int x=Q1; x<Q2; x++){
    		for (int y=Q1; y<Q2; y++){
    			if(x!=cx && y!=cy){ if(gametable.at(x,y)==a) return QUAD;}	
    		}
    		}
    	}
    	else if (cx>=Q2 && cx<Q3){
    		for (int x=Q2; x<Q3; x++){
    		for (int y=Q1; y<Q2; y++){
    			if(x!=cx && y!=cy){ if(gametable.at(x,y)==a) return QUAD;}	
    		}
    		}
    	}
    	if(gametable.rows()>9){ 
    	if (cx>=Q3 && cx<Q4){	
    	for (int x=Q3; x<Q4; x++){
    		for (int y=Q1; y<Q2; y++){
    			if(x!=cx && y!=cy){ if(gametable.at(x,y)==a) return QUAD;}	
    		}
    		}
    	}
    	}
    	
    	if(gametable.rows()==25){
    	if (cx>=Q4 && cx<Q5){
    		for (int x=Q4; x<Q5; x++){
    		for (int y=Q1; y<Q2; y++){
    			if(x!=cx && y!=cy){ if(gametable.at(x,y)==a) return QUAD;}	
    		}
    		}
    	}
    }
    }	
    else if (cy>=Q2 && cy<Q3){
    	if (cx>=0 && cx<Q1){
    		for (int x=0; x<Q1; x++){
    		for (int y=Q2; y<Q3; y++){
    			if(x!=cx && y!=cy){ if(gametable.at(x,y)==a) return QUAD;}	
    		}
    	}
    	}
    	else if (cx>=Q1 && cx<Q2){
    		for (int x=Q1; x<Q2; x++){
    		for (int y=Q2; y<Q3; y++){
    			if(x!=cx && y!=cy){ if(gametable.at(x,y)==a) return QUAD;}	
    		}
    		}
    	}
    	else if (cx>=Q2 && cx<Q3){
    		for (int x=Q2; x<Q3; x++){
    		for (int y=Q2; y<Q3; y++){
    			if(x!=cx && y!=cy){ if(gametable.at(x,y)==a) return QUAD;}	
    		}
    		}
    	}
    	if(gametable.rows()>9){ 
    	if (cx>=Q3 && cx<Q4){	
    	for (int x=Q3; x<Q4; x++){
    		for (int y=Q2; y<Q3; y++){
    			if(x!=cx && y!=cy){ if(gametable.at(x,y)==a) return QUAD;}	
    		}
    		}
    	}
    	}
    	
    	if(gametable.rows()==25){
    	if (cx>=Q4 && cx<Q5){
    		for (int x=Q4; x<Q5; x++){
    		for (int y=Q2; y<Q3; y++){
    			if(x!=cx && y!=cy){ if(gametable.at(x,y)==a) return QUAD;}	
    		}
    		}
    	}
    }
    }
    if(gametable.rows()>9){
    if (cy>=Q3 && cy<Q4){	
    	if (cx>=0 && cx<Q1){
    		for (int x=0; x<Q1; x++){
    		for (int y=Q3; y<Q4; y++){
    			if(x!=cx && y!=cy){ if(gametable.at(x,y)==a) return QUAD;}	
    		}
    	}
    	}
    	else if (cx>=Q1 && cx<Q2){
    		for (int x=Q1; x<Q2; x++){
    		for (int y=Q3; y<Q4; y++){
    			if(x!=cx && y!=cy){ if(gametable.at(x,y)==a) return QUAD;}	
    		}
    		}
    	}
    	else if (cx>=Q2 && cx<Q3){
    		for (int x=Q2; x<Q3; x++){
    		for (int y=Q3; y<Q4; y++){
    			if(x!=cx && y!=cy){ if(gametable.at(x,y)==a) return QUAD;}	
    		}
    		}
    	}
    	if(gametable.rows()>9){ 
    	if (cx>=Q3 && cx<Q4){	
    		for (int x=Q3; x<Q4; x++){
    		for (int y=Q3; y<Q4; y++){
    			if(x!=cx && y!=cy){ if(gametable.at(x,y)==a) return QUAD;}	
    		}
    		}
    	}
    	}
    	
    	if(gametable.rows()==25){
    	if (cx>=Q4 && cx<Q5){
    		for (int x=Q4; x<Q5; x++){
    		for (int y=Q3; y<Q4; y++){
    			if(x!=cx && y!=cy){ if(gametable.at(x,y)==a) return QUAD;}	
    		}
    		}
    	}
    }
    }
    }		
    if(gametable.rows()==25){
    	if (cy>=Q4 && cy<Q5){
    	if (cx>=0 && cx<Q1){
    		for (int x=0; x<Q1; x++){
    		for (int y=Q3; y<Q4; y++){
    			if(x!=cx && y!=cy){ if(gametable.at(x,y)==a) return QUAD;}	
    		}
    	}
    	}
    	else if (cx>=Q1 && cx<Q2){
    		for (int x=Q1; x<Q2; x++){
    		for (int y=Q3; y<Q4; y++){
    			if(x!=cx && y!=cy){ if(gametable.at(x,y)==a) return QUAD;}	
    		}
    		}
    	}
    	else if (cx>=Q2 && cx<Q3){
    		for (int x=Q2; x<Q3; x++){
    		for (int y=Q3; y<Q4; y++){
    			if(x!=cx && y!=cy){ if(gametable.at(x,y)==a) return QUAD;}	
    		}
    		}
    	}
    	else if (cx>=Q3 && cx<Q4){	
    		for (int x=Q3; x<Q4; x++){
    		for (int y=Q3; y<Q4; y++){
    			if(x!=cx && y!=cy){ if(gametable.at(x,y)==a) return QUAD;}	
    		}
    		}
    	}
    	}
    	else if (cx>=Q4 && cx<Q5){
    		for (int x=Q4; x<Q5; x++){
    		for (int y=Q3; y<Q4; y++){
    			if(x!=cx && y!=cy){ if(gametable.at(x,y)==a) return QUAD;}	
    		}
    		}
    	}
    }
    return OK;
    }
    
    /***************************************************************************/
    
    void Sudoku:: filler(){
    	Error err;
    	int a;
    	int x; int y;
    	while (true){
    	cout<<"Inserire valore ";
    	cin>>a;
    	cout<<" alle coordinate ";
    	cin>>x; cin>>y;
    	cout<<endl;
    	err= ctrl_game(a,x,y);
    	if (err==RIGA) cout<<" Inserito numero non valido nella riga\n";
    	else if(err==COL) cout<<" Inserito numero non valido nella colonna\n";
    	else if(err==QUAD) cout<<" Inserito numero non valido nel quadrato latino\n";
    	else if(err==OK) {cout<<"Valore inserito correttamente"; gametable.at(x,y)=a;}
    	print_table();
    //devo ancora decidere come e quando porre fine a questo ciclo.
    	}
    }
    Spero non vi venga la nausea guardando la funzione dei controlli...
  • Re: SUDOKU C++

    @DashKappei
    Posta anche la classe perchè possa esser d'aiuto a Dave

    ~Max
  • Re: SUDOKU C++

    Eccola!!
    TAB.h:
    #ifndef TAB_H
    #define TAB_H
    #include "std_lib_facilities.h"
    using namespace std;
    
    // Class Tab - generic for dynamic 2D tables of elements
    
    // Interface template class Tab
    // Warning: will not compile for T = bool (because of vector<bool> spacialization)
        template<class T> class table{
            vector<vector<T> > t;   // container
                                    // number of rows = t.size()
            int c;                  // number of columns
        public:
            class Tab_err {};       // type for reporting errors
    
            table();                // create an empty table
            table(int);             // create a nxn table
            table(int, int);        // create a nxm table
            table(const table<T>&); // copy constructor
    
            T& operator()(int, int);  //return (ref to) elem t[i][j]
            T& at(int, int);          //return (ref to) elem t[i][j]
            int rows() const;         //return number of rows in table
            int cols() const;         //return number of columns in table
    
            void push_back_row(const vector<T>&);   //add a row
            void push_back_col(const vector<T>&);   //add a column
            void resize_rows(int);      //change the number of rows
            void resize_cols(int);      //change the number of columms
            void resize(int, int);      //change size of the table
        };    // end interface template class Tab
    
    // Implementation template class Tab
    
        // explicit default constructor is needed to reset c;
        // t is automtically set to an empty vector
        template <class T> table<T>::table() : c(0) {}
    
        template <class T> table<T>::table(int n) : c(n)
        {
            t.resize(n);
            for (int i=0;i<n;i++) t[i].resize(c);
        }
    
        template <class T> table<T>::table(int n, int m) : c(m)
        {
            t.resize(n);
            for (int i=0;i<n;i++) t[i].resize(c);
        }
    
        template <class T> table<T>::table(const table<T>& t1) : c(t1.c), t(t1.t) {}
    
        template <class T> T& table<T>::operator()(int rr, int cc)
        {
            return t[rr][cc];
        }
    
        template <class T> T& table<T>::at(int i, int j)
        {
            return t[i][j];
        }
    
        template <class T> int table<T>::rows() const {return t.size();}
    
        template <class T> int table<T>::cols() const {return c;}
    
        template <class T> void table<T>::push_back_row(const vector<T>& v)
        {
            if (v.size()<c) throw Tab_err();  // error - new row too short
            t.push_back(v);
            t[t.size()-1].resize(c);    // make sure new row has the same number of cols
        }
    
        template <class T> void table<T>::push_back_col(const vector<T>& v)
        {
            if (v.size()<t.size()) throw Tab_err();  // error - new column too short
            c++;
            for (int i=0;i<t.size();i++)
            {
                t[i].resize(c);
                t[i][c-1]=v[i];
            }
        }
    
        template <class T> void table<T>::resize_rows(int n)
        {
            int rr = t.size();
            t.resize(n);
            for (int i=rr;i<n;i++) t[i].resize(c);
        }
    
        template <class T> void table<T>::resize_cols(int m)
        {
            c = m;
            for (int i=0;i<t.size();i++) t[i].resize(c);
        }
    
        template <class T> void table<T>::resize(int n, int m)
        {
            c = m;
            t.resize(n);
            for (int i=0;i<n;i++) t[i].resize(c);
        }
    
    // end implementation template class Tab
    
    
    #endif // TAB_H
    
    qualche idea sulla natura del mio errore?
    EDIT: PROBLEMA RISOLTO!!!

    Ora devo pensare a farlo riempire a random e ho due domande a tal proposito:
    1) come posso fare, una volta che il generatore ha finito di disporre lo schema, a impedire all'utente di sovrascrivere i valori nelle celle che costituiscono indizio, ovvero quelle già riempite dal generatore? Così facendo posso permettere all'utente di correggere suoi eventuali errori, dovuti dalla questione "mossa lecita ma non conveniente".
    2) Cosa distingue un sudoku facile con uno difficile??
  • Re: SUDOKU C++

    1)Devi flaggarle, trova tu il modo.
    2)Dipende da come intendi risolverlo:
    a) brute-force - dal numero di celle vuote/piene.
    b) logico - dalla complessità della tecnica di risoluzione.

    ~Max
  • Re: SUDOKU C++

    Scusa ancora una cosa MAX ma come faccio a creare vari livelli di matrice.
    Nel tuo programma usavi : puzzle[lev] e incrementavi o decrementavi lev a seconda, in c++ come faccio a dichiarare un array di quel tipo(devo usare "new" credo ma in che modo?)?
    Nel mio caso uso la classe table, dove table e' un array di array (9x9 ad esempio).
Devi accedere o registrarti per scrivere nel forum
22 risposte