Sempre Tombola, generazione delle tabelle

di il
54 risposte

54 Risposte - Pagina 2

  • Re: Sempre Tombola, generazione delle tabelle

    Ti ringrazio infinitamente! Però mi duole dirti due cose.. xD
    1. Non ho ben capito la tua teoria iniziale
    2. Quei codici sono troppo complessi per quello che devo fare io (sono limitato a poter usare solo cose che ho imparato al corso, anche perchè altrimenti mi metterebbe in difficoltà durante l'esame orale).
  • Re: Sempre Tombola, generazione delle tabelle

    Io mi sono limitato a modificare il codice in base al suo metodo di programmazione ( molto discutibile ) in modo tale che riuscisse a capire cosa fa il programma.
    Comunque il problema della matrice 3x5 è che non puoi verificare delle regole della costruzione della cartella quali:

    1) In una riga ci devono essere massimo 5 numeri
    2) In una colonna ci devono essere massimo 2 numeri ( ciò significa non ci possono essere 3 valori da 10 a 19 o da 20 a 29 o da 0 a 9 ec.... )

    Nel mio ci sono tutte le condizioni però ripeto non l' ho compilato non so se c'è qualcosa di sbagliato ma il concetto è che è meglio creare tante funzioni quante sono le condizioni :

    1) una funzione che indica se esiste già il numero
    2) una funzione che indica se ci sono già due numeri nella colonna
    3) una funzione che indica se ci sono già 5 numeri nella riga
    4) La stampa risulta essere sbagliata in quanto nella prima colonna ci devono essere numeri da 0 a 9 , nella seconda da 10 a 19 ec...

    Joy se ci sono altri errori me li fai vedere e al limite vedo con un editor
  • Re: Sempre Tombola, generazione delle tabelle

    Joysurrender scusami non avevo letto il post allora i problemi sono:
    Ovviamente prima di fare l' insermento dei valori devi inserire il valore 0 a tutte le posizioni della matrice CB ( si dice inizializzare la matrice a 0 )
    Non te l' ho detto per sfizio questa cosa , ora ti spiego con le variabili ma il concetto è lo stesso per qualsiasi tipo di variabili.
    
    int x;
    
    la variabile x così com'è contiene un valore sconosciuto il quale non è per forza 0 ma qualsiasi . Ora quando dichiari la matrice CB
    
    int CB[4][9];
    
    Nella matrice , nelle singole posizioni , ci possono essere qualsiasi valori e questo è sbagliato perchè ,nelle funzioni che abbiamo utilizzato per controllare se in quella posizione della matrice c'è o meno un numero,abbiamo utilizzato la condizione if ( CB[j] == 0 ) . Ok ? quindi prima di generare la cartella , devi assegnare ogni singola posiziona a 0 :
    
    for ( i = 0 , i < 4 ; i ++ ) 
       for ( j = 0 ; j < 9 ; j++ ) 
              CB[i][j] = 0 ;
    
    Ti sto facendo il programma nella tua metodologia ma spero che almeno lo stai capendo ^^

    Altra cosa , le funzioni int come tu hai ben fatto devono restituire un intero , quindi perchè hai utilizzato per la funzione stampa una funzione int ? infatti non hai restituito niente . Penso che ti sia sbaglaito . Vabbe' comunque cambia il tipo della funzione stampa da int a void . Vedi un pò altrimenti compilo e vedo un pò il problema
  • Re: Sempre Tombola, generazione delle tabelle

    Mi fa piacere che ti sia stato d'aiuto . Comunque Joy, rispondendo alle tue domande:
    1) La mia teoria si basa sul fatto che, come stesso tu hai specificato precedentemente, ogni cartella contiene 15 valori, inoltre stesso tu hai supposto l'utilizzo di una possibile matrice 3 x 5 al posto di quella 3 x 9 , solo che poi avevi difficoltà con la ricerca della colonna dove inserire il numero generato dato che , se ho capito bene, utilizzi il quoziente della divisione per 10 per trovare l'indice di colonna (ad esempio, se esce 35 tu fai 35/10= 3, quindi il numero va nella colonna di indice 3).
    Ora dato che nella tombola i numeri sono 90, essendo le colonne 5, ad ogni colonna è dedicato un range di valori pari a 90/5 = 18 numeri, ed ogni colonna non potrà mai contenere un numero che può essere presente in un'altra colonna.
    Ora, dato che sappiamo già dal principio quante righe e quante colonne contiene una cartella, e dato che abbiamo suddiviso i numeri generati in base alla colonna, l'idea è venuta subito su quella di definire un tipo Colonna che contiene 3 elementi, e poi definire il tipo Cartella che contiene 5 Colonne.
    2) A dire il vero non ho usato del codice così complesso, infatti non faccio uso di puntatori o allocazione dinamica, ma solo di costanti, array e cicli. A questo punto dimmi cosa hai fatto durante il corso così possiamo trovare una soluzione ottimale
  • Re: Sempre Tombola, generazione delle tabelle

    Scusate il ritardo nella risposta, non mi ero accorto che la board cambiasse pagina non automaticamente xD

    @Alessandro: Gli array li ho svuotati già xD Sapevo quella cosa, non sono nuovo in programmazione ma nuovo in C... il programma, così come l'hai scritto tu (ho solo fatto pochissime modifiche ma non all'algoritmo in se), funziona perfettamente. Ho aggiunto la printf dell'array e me lo stampa a video correttamente. Il problema è che non compaiono 15 numeri ma un numero minore (addirittura mi è capitato di contarne 10) e infatti, conseguenza logica, una o due colonne contengono solo zeri.
    Ti prego di provare l'ultimo codice che ho incollato (se vuoi te lo re-incollo) con il tuo ambiente di sviluppo per vedere con i tuoi stessi occhi, così magari puoi darmi un'ultima mano ^^ (Sei già stato molto utile e ti ringrazio infinitamente adesso e anche dopo xD).

    @Vins: Continuo a non capire, anche se mi sembri abbastanza chiaro XD Sarà la stanchezza, ci sto lavorando da stamattina ed è parecchio che non programmo, quando arriva la sera mi stanco e non capisco più niente. Rileggerò la tua spiegazione domani mattina, con calma, a mente fresca.
    Comunque per il punto 2... le cose che trovo difficili nel tuo codice (anche se magari le posso capire non le potrei comunque usare, visto che nel corso non le ho fatte) sono, ad esempio, il fatto che usi
    GeneraCartella(Cartella& cartella)
    ,
    const int base[]={1,19,37,55,73};
    non capisco da dove escono quei numeri.. perchè proprio quelli insomma?
    cout<<"\nCartella generata!\n";
    Pensavo si usasse solo in C++
    Sostanzialmente questo, poi son cose che magari si ripetono. Anche il printf("%4d",cartella[j]); non l'ho capito.. serve per lo spazio, giusto?
    Comunque nel corso ho fatto: variabili, array, puntatori (che tuttavia preferisco non usare perchè se mi imbroglio così, nella semplicità, figuriamoci con i puntatori xD), function.. printf, scanf... numeri pseudocasuali.. costrutti di controllo e costrutti di ripetizione e... e basta credo xD Tutto qui..
    Ma a prescindere, capisco che non ti piace il mio metodo di programmazione, però cerca di capire... xD Mi sono tuffato nella programmazione "seria" in C da pochi giorni, cose più banali (dal corso appunto) tipo semplici esercizietti singoli (calcolatrice, stampa di un array già inizializzato..) da qualche mese... e vengo da Visual Basic e GML, decisamente più semplici, rapidi e meno legati alla macchina, rispetto al C. xD
  • Re: Sempre Tombola, generazione delle tabelle

    Ok Joy, un pò di riposo farebbe bene anche a noi , soprattutto a chi è sveglio da più di 18 ore! Comunque non ho mai detto che il tuo metodo di programamzione non mi piace, anzi dato che vieni dal VisualBasic e GML (chi di noi non ha provato almeno una volta VB ) non penso che hai grossi problemi sulla programamzione. Comunque per i tuoi dubbi, mi spiego:
    
    void GeneraCartella(Cartella& cartella)
    
    con questa funzione non faccio altro che generare i numeri casuali in una variabile di tipo Cartella (definita con i typedef di prima ). tale variabile la passo 'per riferimento', cioé quando inserisco una variabile nei parametri di una funzione, non viene creata una nuova copia di quella variabile, ma viene creato appunto un 'riferimento' alla variabile passata, così che qualunque modifica che avviene nella funzione chiamata si riflette sulla variabile passata, un esempio:
    
    //.... del codice scritto
    int N=2;  //dichiaro una variabile di nome N e la inizializzo a 2
    Quadrato(N); //passo la variabile N alla funzione che mi calcola il suo Quadrato
    printf("%d",N);  // stampo a video N che adesso vale 4;
    //.... altro codice scritto
    //
    void Quadrato(int& num){
        num= num*num;
    }
    
    Il 'passaggio per riferimento' avviene ponendo la '&' davanti al nome della variabile, senza di essa la variabile viene passata 'per valore' , cioè viene creata una 'copia' della variabile che verrà poi usata dalla funzione. Prendendo l'esempio precedente, senza la '&' la funzione avrebbe lavorato su una copia di N, quindi al ritorno N continuava a valere 2.
    - Per quanto riguarda invece:
    
    const int base[]={1,19,37,55,73};
    
    Questo non è altro che un array costante, che contiene i valori all'interno delle parentesi graffe. In questo caso non metti la dimensione (con []) , ma avendola 'inizializzata' con valori determinati a priori , il compilatore è capace di dargliene una. Per me risulta utile dichiarare così gli array quando si ha bisogno di valori 'noti e certi' fin dal tempo di compilazione .
    Per quanto riguarda quei specifici valori, ripensa a ciò che ho scritto precedenemente. Se la tombola ha 90 numeri, e avendo supposto 5 colonne per cartella, allora ogni colonna della cartella contiene un range di valori, in questo caso 90/5 = 18. Ogni colonna quindi può avere un valore minimo che è uguale a '(i*18)+1', con 'i' il numero di colonna (da 0 a 4). Se noti il numero casuale da aggiungere nel codice che ho postato viene calcolato semplicemente aggiungendo al numero minimo possibile per quella determinata colonna ( la 'i-esima') il modulo 18 della rand() (dato che ogni colonna può contenere, sempre in base a ciò che è stato detto prima, 18 possibili valori).
    Però dato che calcolare ogni volta '(i*18)+1' può risultare oneroso, ho definito a priori i valori minimi che ogni colonna può contenere, semplificando così alcune operazioni (infatti la colonna 0 ha come valore minimo 1, la colonna 1 ha come valore minimo 19, la colonna 2 ha come valore minimo 37, e così via).
    per il 'cout' hai ragione, è C++! comunque puoi sostituirla facilmente con la printf().
  • Re: Sempre Tombola, generazione delle tabelle

    
    #include <stdio.h>
    #include <stdlib.h>
    #include <time.h>
    
        int rnd , CB[4][9],pos_riga;
    
        int massimo_per_riga() {  // funzione che controlla se nella riga ci sono 5 valori , in caso positivo restituisce true , altrimenti false
               int i , cont=0;
               for ( i = 0 ; i < 9 ; i++ ) {
                      if ( CB[pos_riga][i] != 0 ) cont++;
               }
               if ( cont == 5 ) return 1;
               else return 0;
        }
    
        int pieno(int appoggio) {     // Se ci sono due valori diversi da 0 nella colonna appoggio allora restituisce true alrimenti false
              int i, cont=0;
              for (i = 0; i<3; i++) {
                        if ( CB[i][appoggio] != 0 ) cont++;
              }
              if ( cont == 2 ) return 1;
              else return 0;
        }
    
        int inserisci (int appoggio) {
             int i;
             int continuo=1;
             if (pieno(appoggio))  // se nella colonna ci sono già due valori allora false diretto
                          return 0;
             else {
                 for ( i = 0 ; i < 3 ; i ++ ) {    // controllo se esiste il valore nella colonna indicata da appoggio
                        if ( CB[i][appoggio] == rnd )
                                          return 0;
                  }   // se finisce il for significa che non esiste il valore rnd nella colonna appoggio
                  while (continuo) {   // va a prendere la posizione della riga in cui non c'è già un valore nella colonna
                           pos_riga = rand()%3;   // la riga deve essere casuale , almeno così è dall' immagine che mi hai dato
                           if ( CB[pos_riga][appoggio] == 0 ); // se non c'è il valore abbiamo trovato la riga
                                        break;
                   }
                   if ( !massimo_per_riga() ) return 1;
                   else return 0;
        }}
    
    
    
        int main () {
            int i , j , appoggio;
            for ( i = 0 ; i < 4 ; i ++ )    <-------------------------------------------------------
                    for ( j = 0 ; j < 9 ; j++ ) 
                             CB[i][j]=0;
            srand(time(NULL));
            for ( i = 0 ; i < 15 ; i ++ )  {  // 15 sta per quanti numeri devono essere inseriti nella matrice
                      rnd = 1+rand()%90;   // genera da 1 a 90
                      appoggio = rnd/10;  // indicherà la colonna
                      if ( appoggio == 9 ) appoggio = 8 ; // se il numero è 90 deve stare nella colonna 8
                      if ( !inserisci( appoggio) ) i--;  // se non è stato inserito ripeti il ciclo
                      else CB[pos_riga][appoggio] = rnd;
            }
          stampa();
          getch();
            return 0 ;
        }
    
    
     void stampa()
    {
        int i,j;
        printf("\nCartella base:\n");
        for (i=0; i<=2; i++)
        {
            printf("\n");
            for (j=0; j<=8; j++)
            {
                printf("%d\t",CB[i][j]);
            }
        }
          }
    

    nel programma che mi hai incollato non hai inizializzato la matrice , ti ho messo il segno" <------------------------------ " dove ho aggiunto l' inizializzazione e poi ti ho cambiato il tipo della funzione della stampa da int a void sempre segnalato con il simbolo <--------------------

    Mi hai fatto venire il dubbio, l' ho compilato e funziona correttamente o.O
  • Re: Sempre Tombola, generazione delle tabelle

    Ok, adesso questo è il mio codice:
    #include <stdio.h>
    #include <stdlib.h>
    #include <time.h>
    
        int rnd , CB[4][9],pos_riga;
    
        int massimo_per_riga() {  // funzione che controlla se nella riga ci sono 5 valori , in caso positivo restituisce true , altrimenti false
               int i , cont=0;
               for ( i = 0 ; i < 9 ; i++ ) {
                      if ( CB[pos_riga][i] != 0 ) cont++;
               }
               if ( cont == 5 ) return 1;
               else return 0;
        }
    
        int pieno(int appoggio) {     // Se ci sono due valori diversi da 0 nella colonna appoggio allora restituisce true alrimenti false
              int i, cont=0;
              for (i = 0; i<3; i++) {
                        if ( CB[i][appoggio] != 0 ) cont++;
              }
              if ( cont == 2 ) return 1;
              else return 0;
        }
    
        int inserisci (int appoggio) {
             int i;
             int continuo=1;
             if (pieno(appoggio))  // se nella colonna ci sono già due valori allora false diretto
                          return 0;
             else {
                 for ( i = 0 ; i < 3 ; i ++ ) {    // controllo se esiste il valore nella colonna indicata da appoggio
                        if ( CB[i][appoggio] == rnd )
                                          return 0;
                  }   // se finisce il for significa che non esiste il valore rnd nella colonna appoggio
                  while (continuo) {   // va a prendere la posizione della riga in cui non c'è già un valore nella colonna
                           pos_riga = rand()%3;   // la riga deve essere casuale , almeno così è dall' immagine che mi hai dato
                           if ( CB[pos_riga][appoggio] == 0 ); // se non c'è il valore abbiamo trovato la riga
                                        break;
                   }
                   if ( !massimo_per_riga() ) return 1;
                   else return 0;
        }}
    
    
    
        int main () {
            int i , j , appoggio;
            for ( i = 0 ; i < 4 ; i ++ )
                    for ( j = 0 ; j < 9 ; j++ )
                             CB[i][j]=0;
            srand(time(NULL));
            for ( i = 0 ; i < 15 ; i ++ )  {  // 15 sta per quanti numeri devono essere inseriti nella matrice
                      rnd = 1+rand()%90;   // genera da 1 a 90
                      appoggio = rnd/10;  // indicherà la colonna
                      if ( appoggio == 9 ) appoggio = 8 ; // se il numero è 90 deve stare nella colonna 8
                      if ( !inserisci( appoggio) ) i--;  // se non è stato inserito ripeti il ciclo
                      else CB[pos_riga][appoggio] = rnd;
            }
          stampa();
          getch();
            return 0 ;
        }
    
    		void stampa()
    {
        int i,j;
        printf("\nCartella base:\n");
        for (i=0; i<=2; i++)
        {
            printf("\n\n");
            for (j=0; j<=8; j++)
            {
                if (CB[i][j] == 0) printf("\t");
                else printf("%d\t",CB[i][j]);
            }
        }
    		}
    
    (In altre parole, oltre alle modifiche che hai fatto tu, ho aggiunto un controllo per non fare stampare gli zero)

    Ma questo è il mio risultato:



    Non ho mai avuto il piacere di contare 15 numeri ma non capisco perchè, il codice sembra corretto o.o
    Nell'immagine addirittura se ne contano solo 12.

    PS: Vins, comunque io dicevo di fare la matrice da 3x9 (addirittura 3x10, così nell'ultima colonna controllo quanti numeri sono usciti per quella riga, così posso dire se è ambo, terno, ecc..), con quella 3x5 non potrei fare niente perchè quando poi faccio 34/10 (tanto per fare un esempio) mi risulta la colonna 3 e lo metto lì.. e va bene... ma se mi esce 80? colonna 8 che non esiste?
    Comunque lasciamo perdere dai, non ci perdiamo la testa XD Il codice attuale sembra funzionare bene, bisogna solo risolvere quel piccolo problemino
  • Re: Sempre Tombola, generazione delle tabelle

    Metti la stampa normale di tutti i numeri della matrice compreso i 0 e dimmi se ti da lo stesso risultato
  • Re: Sempre Tombola, generazione delle tabelle

    Si si è identico.
  • Re: Sempre Tombola, generazione delle tabelle

    No, hai ragione. però la 3 x 5 la puoi fare comunque. Infatti tu fai num/10 perché con la 3 x 9 in ogni colonna metti un range di 10 valori (1-10 , 11-20 , 21-30 , e così via) , con la 3 x 5 fai lo stesso, ma invece di dividere per 10 dividi per 18 (1-18 , 19-36 , 37-54 , 55-72 , 73-90 , i numeri in rosso sono appunto quei valori dell'array base). Dato che poi l'intera cartella verrà riempita , e quindi tutti e 15 valori della matrice 3 x 5 saranno validi, non ci sarà bisogno di sapere quanti elementi sono presenti in una riga o colonna, al massimo bisognerà sapere se un valore nella cartella è uscito o no. questo può essere fatto facilmente definendo un tipo 'struttura' di nome Numero, che contiene 2 campi: il primo rappresenta il valore, il secondo rappresenta la sua estrazione, ad esempio:
    
    typedef struct{
        int valore;
        bool estratto;
    }Numero;
    
    e poi usre questo nuovo tipo strutturato come elemento per la tua matrice:
    
    // come semplice matrice
    typedef Numero Cartella[5][3];
    
    //come tipo Cartella
    typedef Numero Colonna[3];
    typedef Colonna Cartella[5];
    
    Ora per accedere ad un numero specifico non devi fare altro che accedervi come una normale matrice:
    
    Cartella cartella;  //dichiaro una variabile di tipo Cartella
    Numero cart[5][3];  //questa variabile è una matrice identica a 'cartella'
    printf("%4d",cartella[3][1].valore);  //stampo a video il 'valore' del Numero in 4° colonna e 2° riga.
    
    Così è anche più facile verificare i numeri estratti, infatti bisognerà solo vedere se 'estratto' di un numero risulta 'true'
    
    if(cartella[2][0].estratto==true)printf("\nIl numero è stato estratto");  //verifico semplicemente il valore di 'estratto' del Numero posto nella 3° colonna e 1° riga
    else printf("\nIl numero non è stato estratto");
    
    Il codice risulta semplificato anche per la generazione dei numeri e per la pulizia della cartella.
    Per tenere traccia invece di tutti i numeri estratti, puoi semplicemente utilizzare un array di 90 elementi booleani che ti indicano se il numero è stato estratto o no, ad esempio:
    
    typedef bool Banco[90]  //definisco un array di 90 elementi booleani che tiene conto i numeri estratti
    
    //Ora posso dichiarare una variabile che rappresenta il mio banco
    Banco banco;  //dichiaro la variabile che rappresenterà le mie estrazioni
    bool banco[90];  //fa la stessa cosa della riga sopra
    
    Ora, la funzione che 'svuota' il banco può essere implementata semplicemente ponendo a 'false' tutti gli elementi dell'array passato alla funzione:
    
    void PulisciBanco(Banco &banco){
        for(int i=0;i<90;i++)
            banco[i]=false;
    }
    
    void PulisciBanco(bool banco[90]){  //Fa la stessa e identica cosa della funzione sopra
        for(int i=0;i<90;i++)
            banco[i]=false;
    }
    
    Per le cartelle invece possono essere 'pulite' semplicemente ponendo a 'false' il valore di 'estratto' per ogni Numero:
    
    void PulisciCartella(Carella &cartella){
        for(int i=0;i<5;i++){
            for(int j=0;j<3;j++)
                cartella[i][j].estratto=false;
        }
    }
    
    void PulisciCartella(Numero cartella[5][3]){  //fa la stessa cosa della funzione sopra
        for(int i=0;i<5;i++){
            for(int j=0;j<3;j++)
                cartella[i][j].estratto=false;
        }
    }
    
    Per quanto riguarda la generazione di una cartella, invece che generare il numero da 1 a 90 e poi scegliere la colonna giusta in base al numero, puoi generare il numero in base alla colonna in cui ti trovi, così che il numero sia solo un valore compreso tra '[(i*18)+1] + (rand() % 18)' , con 'i' indice di colonna. In questo modo eviti un sacco di controlli su quanti numeri una colonna possiede validi, in quanto con questo metodo non passi alla colonna successiva fintanto ché non sarà riempita per intero . Ed è quello che la funzione 'GeneraCartella' del mio codice precedente fa. Lo stesso vale per la funzione 'NumeroEsistente'.
    Io penso sempre che prima di cominciare a scrivere del codice sia meglio valutare tutte le possibili soluzioni,in base alle risorse che abbiamo a disposizione, per poi scegliere quella che risulta 'ottimale' oppure un giusto compromesso tra velocità di esecuzione (molto importante) e spazio occupato in memoria (anch'esso importante). Poi è logico che nei vari 'casi di test' si può accendere la lampadina ( o molto spesso lo si sogna la notte e ci si sveglia con l'idea in testa ) con il codice 'perfetto' per così dire , questo però raramente accade!
    Comunque non voglio costringerti a cambiare la tua logica sul funzionamento del programma, per cui se vuoi continuare in base al tuo codice, allora ti aiuterò su quello
  • Re: Sempre Tombola, generazione delle tabelle

    Ah ecco ora ho capito quello che dici!
    Si, è anche giusta l'ultima cosa che hai detto, però purtroppo io mi baso appunto sugli strumenti che ho a disposizione.
    Senza dubbio il tuo codice è molto performante, però quello che stiamo analizzando io e Alessandro è più alla nostra portata (nostra = studenti del corso xD).
    Anche perchè è già tutto pronto, bisogna solo vedere per quale strano motivo stampa un range di numeri da 10 a 14 (invece che 15 fisso, come sempre)
  • Re: Sempre Tombola, generazione delle tabelle

    A questo punto potresti ripostare il tuo codice com'è ora? ci do un'occhiata e poi troviamo una soluzione!
  • Re: Sempre Tombola, generazione delle tabelle

    E' successo l'assurdo D: Mi sono usciti addirittura 9 numeri D:
    Comunque ecco il codice attuale:
    #include <stdio.h>
    #include <stdlib.h>
    #include <time.h>
    
        int rnd , CB[4][9],pos_riga;
    
        int massimo_per_riga() {  // funzione che controlla se nella riga ci sono 5 valori , in caso positivo restituisce true , altrimenti false
               int i , cont=0;
               for ( i = 0 ; i < 9 ; i++ ) {
                      if ( CB[pos_riga][i] != 0 ) cont++;
               }
               if ( cont == 5 ) return 1;
               else return 0;
        }
    
        int pieno(int appoggio) {     // Se ci sono due valori diversi da 0 nella colonna appoggio allora restituisce true alrimenti false
              int i, cont=0;
              for (i = 0; i<3; i++) {
                        if ( CB[i][appoggio] != 0 ) cont++;
              }
              if ( cont == 2 ) return 1;
              else return 0;
        }
    
        int inserisci (int appoggio) {
             int i;
             int continuo=1;
             if (pieno(appoggio))  // se nella colonna ci sono già due valori allora false diretto
                          return 0;
             else {
                 for ( i = 0 ; i < 3 ; i ++ ) {    // controllo se esiste il valore nella colonna indicata da appoggio
                        if ( CB[i][appoggio] == rnd )
                                          return 0;
                  }   // se finisce il for significa che non esiste il valore rnd nella colonna appoggio
                  while (continuo) {   // va a prendere la posizione della riga in cui non c'è già un valore nella colonna
                           pos_riga = rand()%3;   // la riga deve essere casuale , almeno così è dall' immagine che mi hai dato
                           if ( CB[pos_riga][appoggio] == 0 ); // se non c'è il valore abbiamo trovato la riga
                                        break;
                   }
                   if ( !massimo_per_riga() ) return 1;
                   else return 0;
        }}
    
    
    
        int main () {
            int i , j , appoggio;
            for ( i = 0 ; i < 4 ; i ++ )
                    for ( j = 0 ; j < 9 ; j++ )
                             CB[i][j]=0;
            srand(time(NULL));
            for ( i = 0 ; i < 15 ; i ++ )  {  // 15 sta per quanti numeri devono essere inseriti nella matrice
                      rnd = 1+rand()%90;   // genera da 1 a 90
                      appoggio = rnd/10;  // indicherà la colonna
                      if ( appoggio == 9 ) appoggio = 8 ; // se il numero è 90 deve stare nella colonna 8
                      if ( !inserisci( appoggio) ) i--;  // se non è stato inserito ripeti il ciclo
                      else CB[pos_riga][appoggio] = rnd;
            }
          stampa();
          getch();
            return 0 ;
        }
    
    
    		void stampa()
    {
        int i,j;
        printf("\nCartella base:\n");
        for (i=0; i<=2; i++)
        {
            printf("\n\n");
            for (j=0; j<=8; j++)
            {
               if (CB[i][j] == 0) printf("\t");
               else printf("%d\t",CB[i][j]);
            }
        }
    		}
    
  • Re: Sempre Tombola, generazione delle tabelle

    
         if ( CB[pos_riga][appoggio] == 0 ); // se non c'è il valore abbiamo trovato la riga
                                        break;
                   }
    
    dopo l' if non ci vuole il ";" il ciclo while finisce solo se entra nell' if quindi
    
         if ( CB[pos_riga][appoggio] == 0 ) // se non c'è il valore abbiamo trovato la riga
                                        break;
                   }
    
    questa parte del codice si trova in Inserisci
Devi accedere o registrarti per scrivere nel forum
54 risposte