Questo sito utilizza cookies, anche di terze parti, per mostrare pubblicità e servizi in linea con il tuo account. Leggi l'informativa sui cookies.
Username: Password: oppure
C/C++ - Problema con un progetto che utilizza array bidimensionali
Forum - C/C++ - Problema con un progetto che utilizza array bidimensionali

Avatar
andread (Normal User)
Newbie


Messaggi: 4
Iscritto: 09/11/2010

Segnala al moderatore
Postato alle 20:42
Martedì, 09/11/2010
Ciao a tutti ho un problema con questo progetto.
Inizio con spiegarvi cosa devo fare:
Bisogna costruire un "mosaico" su un pavimento XxY (n° dispari) delimitato da "pareti". Ogni pezzo,contenuto in una scatola, del mosaico ha 4 bordi (preticamente un quadrato: lato nord,sud,ovest ed est) dentati che vanno posizionati sul pavimento in questo ordine:
1)Prima il primo pezzo della scatola
2)Pezzo con il < mismatch con i pezzi già presenti nel mosaico
Per mismatch si intende:
Avendo due pezzi A e B con 3 denti per lato:
    +1  +3  -3          +5 -2 +3
+3               +9   +1            +1
-2       A       +2   +3     B      0
+3               -1    -1            +3
    +1  0    0            +3 -5 -4
E ponendo che A sia già posizionato nel mosaico, allora B sarà posizoinato secondo questa formula: (N=nord, S=sud, O=ovest, E=est)
(NA1+SB1)^2+(NA2+SB2)^2+(NA3+SB3)^2
Cioè nel nostro caso:
- A Nord B Sud: (+1 + +3)^2+ (+3 + -5)^2+ (-3 + -4)^2  = 46
- A Est B Ovest: (+9 + +1)^2+ (+2 + +3)^2+ (-1 + -1)^2 = 129
- A Ovest B Est: (+3 + +1)^2+ (-2 + 0)^2+ (+3 + +3)^2  =  56
- A Sud B Nord: (+1 + +5)^2+ (0 + -5)^2+ (0 + -4)^2      = 77
Quindi posizioniamo B a nord di A inquanto il mismatch è 46.

Dopo aver posto un tassello, si controlla se il pavimento presenta delle zone completamente delimitate da tasselli già incollati: queste zone vengono subito riempite con la malta a presa rapida. Per "zona completamente delimitata" si intende un qualunque sottoinsieme di caselle vuote ciascuna delle quali sia
adiacente lato a lato solo ad altre caselle di questo sottoinsieme oppure a tasselli già incollati (ma non alle pareti che delimitano la stanza). La malta viene versata nella zona (o le zone) fino a riempirla, dopodichè si indurisce. Le caselle piene di malta indurita non possono più accogliere alcun tassello.

Allora io ho pensato di fare così:
Codice sorgente - presumibilmente C++

  1. int righe = 9;  
  2.   int colonne = 7;
  3.  
  4.   int mosaico[righe][colonne];   // righe x; colonne y;
  5.  
  6.   int n_tasseli = 8;
  7.   int n_denti = 4;
  8.  
  9.   typedef struct tassello
  10.    {
  11.     int nord[n_denti];
  12.     int est[n_denti];
  13.     int sud[n_denti];
  14.     int ovest[n_denti];
  15.    } TASSELLO;
  16.  
  17.   TASSELLO scatola[n_tasseli];
  18.  
  19.   for(i=0;i<n_tasseli;i++){
  20.    for(j=0;j<n_denti;j++){
  21.     scatola[i].nord[j]=10;
  22.     scatola[i].est[j]=1;
  23.     scatola[i].sud[j]=3;
  24.     scatola[i].ovest[j]=0;



E così creo il "mosaico" e lo riempio di "tasselli".
Il centro lo calcolo così:
Codice sorgente - presumibilmente C/C++

  1. int centrox = (righe/2);
  2.   int centroy = (colonne/2);
  3.  
  4.   printf("colonna: %d, riga: %d\n",centrox,centroy);
  5.  
  6.   mosaico[centrox][centroy]=1;



Ora inserito il primo tassello vanno inseriti gli altri secondo il mismatch
Per tenere traccia dei tasselli inseriti e quindi non scorrere tutto l'array bidimensionale creo una lista con inserimento in testa dove salvo i tasselli inseriti, e cancello solo se hanno tutti i bordi (nord,sud,ovest,est) cirocndati da tasselli.
Codice sorgente - presumibilmente C++

  1. struct list_el {
  2.    int x;                        // righe
  3.    int y;                        / colonne
  4.    struct list_el * next;
  5. };
  6.  
  7. typedef struct list_el item;
  8.  
  9. //nel main
  10.   item *curr, *head;
  11.   head = NULL;
  12.  
  13. //quando inserisco un pezzo
  14.   curr = (item *)malloc(sizeof(item));
  15.   curr->x = 2;
  16.   curr->y = 2;
  17.   curr->next = head;
  18.   head = curr;
  19.  
  20. //per leggerlo
  21.   curr = head;
  22.  
  23.    while(curr) {
  24.       printf("%d,%d\n", curr->x,curr->y);
  25.       curr = curr->next ;
  26.    }



Ancoro non l'ho fatto ma teoricamente basta leggere la lista e i bordi dei tasselli presenti e applicare la formula per il mismatch con ogni tassello nella scatola.
----------------------------------------------------------------------------------
Ora inizia il mio problema:
Come fare a determinare dove mettere la malta?
L'area da considerare deve essere delimitata da tasselli e non deve comprendere i bordi.
Allora io ho pensato di "nominare" le "caselle" dell'array bidimensionale in questo modo:
# b=bordo eventualmente bn(bordo neutro) bp e bc
# n=neutra
# p=pezzo
# c=confine

In modo da ottenere: con un pavimento da 5x5 con pezzo in centro
    b b b b b
    b n c n b
    b c p c b
    b n c n b
    b b b b b

Però non mi viene in mente niente per poter determinare se è presente un'area chiusa da riempire con malta.
Per esempio se ho:

b b b b b b b b b                       b b b b b b b b b
b n n n n p p p b                       b p p p p p p p b
b n n n n p    p b                       b p    p         p b
b n n n p p    p b                       b p p p p p p p b
b n n n p       p b      oppure       b n n p         p b
b p p p p    p p b                       b n n p         p b
b p            p n b                       b n n p          p b
b p p p p p p n b                       b n n p p p p p b
b b b b b b b b b                       b b b b b b b b b

Il vuoto rappresenta la malta.

Cosa posso fare?
Secondo voi devo cambiare strutture dati?

Ultima modifica effettuata da andread il 09/11/2010 alle 20:45
PM
Avatar
Il Totem (Admin)
Guru^2


Messaggi: 3635
Iscritto: 24/01/2006

Up
1
Down
V
Segnala al moderatore
Postato alle 12:09
Mercoledì, 10/11/2010
Allora, posto che è mezzogiorno e sono quasi in calo di zuccheri, la mia proposta è questa.
Usa un algoritmo "a propagazione". Ammettendo che tu abbia una matrice piena di b, c, p e ' ' opportunamente costruita sulla base di tutti gli altri dati, puoi scorrerla normalmente con due for. Prima ti serve anche una lista concatenata che come elementi abbia delle strutture contenti una posizione (x,y) e un bit di controllo (0 o 1).
Quando nel for incontri una casella contenente uno spazio (ossia niente) la aggiungi alla lista inserendo la sua posizione e impostando il bit di controllo a 1. Quindi inizi a propagare la malta in questo modo, scorrendo la lista e iniziando dalla cella appena incontrata, eventualmente usando qualche thread: se ai lati o sulle diagonali della cella corrente c'è una cella vuota, allora aggiungi la cella vuota alla lista SE NON esiste già, inserendo posizione (x,y) e un bit di controllo impostato a 0. Poi ti sposti al successivo elemento della lista e, se il bit di controllo è 0, ripeti lo stesso procedimento (ossia controlli le celle vicine ed eventualmente le aggiungi). Al termine dell'algoritmo avrai una lista di celle adiacenti e vuote che ora riempirai con malta in questo modo: iteri sulla lista dall'inizio alla fine, leggi per ogni elemento il campo posizione e nella matrice iniziale metti una "m" (malta), poi deallochi l'ultima cella letta (tanto non ti serve più). Finito anche questo, sarai nella situazione seguente: sei ancora dentro ai due for iniziali, ma tutte le celle vuote connesse da altre celle vuote alla prima cella vuota incontrata sono state riempite, quindi verranno ignorate alle prossime iterazioni.

Al termine del for, avrai riempito tutti i sottoinsiemi connessi con della malta.


"Infelici sono quelli che hanno tanto cervello da vedere la loro stupidità."
(Fligende Blatter)

"Dubitare di se stessi è il primo segno d'intelligenza."
(Ugo Ojetti)
PM
Avatar
andread (Normal User)
Newbie


Messaggi: 4
Iscritto: 09/11/2010

Up
0
Down
V
Segnala al moderatore
Postato alle 3:57
Giovedì, 11/11/2010
Grazie mille per la risposta, ho provato a farlo ma non esce. Allora:

1) LISTA CONCATENATA:
Codice sorgente - presumibilmente C/C++

  1. struct stack
  2.  {
  3.    int x;                                                                       // righe
  4.    int y;                                                                       // colonne
  5.    int controllo;                                                                  
  6.    struct stack * next;
  7.  };
  8. typedef struct stack nodo;
  9.     nodo *testa=NULL;



2)PUSH & POP:
Codice sorgente - presumibilmente C++

  1. void push(int x, int y,int controllo, nodo *currN)
  2. {
  3.   int pres=0;
  4.   nodo *pos;
  5.  
  6.   pos=testa;
  7.   while(pos){
  8.    if((pos->x == x) && (pos->y == y)) pres=1;
  9.    pos = pos->next;
  10.   }
  11.   if(pres != 1){
  12.    currN = (nodo *)malloc(sizeof(nodo));
  13.    currN->x = x;
  14.    currN->y = y;
  15.    currN->controllo = controllo;
  16.    currN->next = testa;
  17.    testa = currN;
  18.    printf("%d",testa);
  19.     printf(" --> %d\n",currN->next);
  20.   }else printf("ELEMENTO GIA' INSERITO\n");
  21. }
  22.  
  23. void pop()
  24. {
  25.   nodo *pos;
  26.   pos = testa;
  27.  
  28.   testa = pos->next;
  29.   free(pos);
  30. }


3)CONTROLLO LE "n" SE DEVONO DIVENTARE MALTA (" ")
Codice sorgente - presumibilmente C/C++

  1. for(i=1;i<righe;i++){
  2.      for(j=1;j<colonne;j++){
  3.       if(mosaico[i][j] == 'n'){
  4.        if((mosaico[i][j-1] == 'b') || (mosaico[i][j+1] == 'b') || (mosaico[i-1][j] == 'b') || (mosaico[i+1][j] == 'b'))
  5.         printf("NON INSERITO\n");
  6.        else push(i,j,1,currN);
  7.       }
  8.      }
  9.     }



Ora ho uno stack che contiene tutte le "n" presenti nella matrice.
Ok, ma adesso come tiro fuori le "n" che devono diventare malta (" ") da quelle che non lo devono?
Cioè per fare sì che una zona sia riempita di malta allora bisogna fare in modo che sia delimitata da "p" ma una casella contente "n" può essere riempita anche se è circondata da "n" che a loro volta sono cirocndate da "p" e così via....
Come da esempi (forse mi sono spiegato male):
-Avendo
b b b b b b b b b                       b b b b b b b b b
b n n n n p p p b                       b p p p p p p p b
b n n n n p n p b                       b p n p n n n p b
b n n n p p n p b                       b p p p p p p p b
b n n n p n n p b      oppure       b n n p n n n p b
b p p p p n p p b                       b n n p n n n p b
b p n n n n p n b                       b n n p n n n p b
b p p p p p p n b                       b n n p p p p p b
b b b b b b b b b                       b b b b b b b b b

-Come ottengo (lascio il vuoto perchè si nota meglio ma andrebbe "m"):
b b b b b b b b b                       b b b b b b b b b
b n n n n p p p b                       b p p p p p p p b
b n n n n p    p b                       b p    p         p b
b n n n p p    p b                       b p p p p p p p b
b n n n p       p b      oppure       b n n p         p b
b p p p p    p p b                       b n n p         p b
b p            p n b                       b n n p          p b
b p p p p p p n b                       b n n p p p p p b
b b b b b b b b b                       b b b b b b b b b

Allora finchè una casella è delimitata da "p" basterebbe:
Codice sorgente - presumibilmente C++

  1. int n,s,o,e;
  2.      currN = testa;
  3.      i = currN->x;
  4.      j = currN->y;
  5.      if (mosaico[i-1][j] == 'p') n=1;//printf("p a NORD\n");
  6.      if (mosaico[i+1][j] == 'p') s=1;//printf("p a SUD\n");
  7.      if (mosaico[i][j-1] == 'p') o=1;//printf("p a OVEST\n");
  8.      if (mosaico[i][j+1] == 'p') e=1;//printf("p a EST\n");
  9.      
  10.      if((n == 1) && (s == 1) && (o == 1) && (e == 1)) mosaico[i][j]='m';



Ma per sapere se una casella circondata o con adiacente una "n" possa essere riempita perchè le caselle attorno sono in qualche modo cirocndate da "p" come si può fare? Idee?

Ps.: scusate per le parti in maiuscolo ma era per staccare il testo.

PM
Avatar
Il Totem (Admin)
Guru^2


Messaggi: 3635
Iscritto: 24/01/2006

Up
0
Down
V
Segnala al moderatore
Postato alle 17:08
Giovedì, 11/11/2010
Per prima cosa, il tuo algoritmo non è quello che intendevo io. Tu hai semplicemente aggiunto alla lista dinamica tutte le piastrelle n non vicine a piastrelle b, e questo è abbastanza inutile.
Il tuo push è un po' strano. Di solito il push restituisce l'indirizzo della nuova testa. Tu invece passi un parametro che deve essere vuoto e che viene allocato solo dentro la funzione. Per di più testa è globale (invece dovrebbe essere un parametro della funzione). Di currN poi non te ne fai nulla perché coincide con testa. Inoltre push DEVE aggiungere gli elementi in coda e non in testa, è strettamente necessario perché l'algoritmo funzioni.
Ridefinisci push con questa signature:
Codice sorgente - presumibilmente C/C++

  1. nodo* push(nodo* head, int x, int y, int ctrl)



Ora, io intendevo fare una cosa del genere:
Codice sorgente - presumibilmente C/C++

  1. nodo* tmp;
  2. /* ... */
  3. for(i=1; i < righe; i++)
  4.    for(j=1; j < colonne; j++)
  5.       if (mosaico[i][j] == 'n')
  6.       {
  7.          testa = push(testa, i, j, 0);
  8.          for(tmp = testa; tmp; tmp = tmp->next)
  9.          {
  10.             if (mosaico[i + 1][j] == 'n') testa = push(testa, i + 1, j, 0);
  11.             if (mosaico[i][j + 1] == 'n') testa = push(testa, i, j + 1, 0);
  12.             /* eccetera */
  13.          }
  14.          /* Ora la lista contiene un insieme connesso di n */
  15.          /* Qui controlli che sia coerente, poi svuoti la lista */
  16.          /* N.B.: se l'insieme non è coerente, sostituisci tutte le n nella lista con o */
  17.       }



Alcune considerazioni:
1) La lista viene creata tante volte quante sono gli insiemi connessi di n, quindi si riempie e si svuota più volte durante i due for;
2) Il for(tmp = testa...) itera su tutti gli elementi della lista e man mano ne aggiunge di nuovi. All'inizio ce ne sarà solo uno. Se questo ha delle n adiacenti le aggiunge, quindi la lista cresce mentre viene enumerata.
3) Alla fine di questo for, la lista contiene le piastrelle n connesse tra loro, ma questo insieme non è necessariamente coerente, ossia può essere vicino al bordo. L'unica condizione perché n sia coerente è che nessuna piastrelle della lista sia adiacente a un bordo b. Basta un semplice for per controllare questa condizione. Oppure, ancora meglio, puoi controllarla direttamente quando scorri la lista! Se incontri un b, stoppi il for con un break e usi una variabile di controllo per sapere l'esito.
4) Una volta verificata la coerenza, ci sono due possibilità: o l'insieme è coerente, nel qual caso lo riempi di malta, oppure non lo è. Se non lo è, abbi cura di sostituire tutte le n che sono presenti sia nella lista che nella matrice con un'altra lettera, ad esempio "o", ad indicare che quell'insieme di piastrelle non può essere riempito (ciò evita altri controlli da parte della coppia di for iniziali).
5) Ricordati di svuotare la lista.

Ultima modifica effettuata da Il Totem il 11/11/2010 alle 17:12


"Infelici sono quelli che hanno tanto cervello da vedere la loro stupidità."
(Fligende Blatter)

"Dubitare di se stessi è il primo segno d'intelligenza."
(Ugo Ojetti)
PM
Avatar
andread (Normal User)
Newbie


Messaggi: 4
Iscritto: 09/11/2010

Up
0
Down
V
Segnala al moderatore
Postato alle 0:32
Martedì, 16/11/2010
Niente entra in loop infinito e non và avanti.... non riesco a capire perchè
Codice sorgente - presumibilmente C++

  1. typedef struct info{
  2.     int x;
  3.     int y;
  4.     int ctrl;
  5. }TipoElemInfo;
  6.  
  7. typedef struct nodolista{
  8.     TipoElemInfo info;
  9.     struct nodolista *next;
  10. }NodoListaInfo;
  11.  
  12. typedef NodoListaInfo *TipoListaInfo;
  13.  
  14.  
  15. TipoListaInfo RicercaData(TipoListaInfo lis,TipoElemInfo elem){
  16.     printf("Ricerco\n");
  17.     while(lis!=NULL){
  18.         if((lis->info.x == elem.x) && (lis->info.y == elem.y))
  19.          {printf("Trovato %d %d && %d %d\n",lis->info.x,elem.x,lis->info.y,elem.y);
  20.           printf("Ritorno %d\n",lis);
  21.           return(lis);}
  22.             lis=lis->next;
  23.         }
  24.         printf("Fine ricerche ritorno cmq %d\n",lis);
  25.         return(lis);
  26. }
  27.  
  28. void InserisciInTestaDataAccesso(TipoListaInfo *lis,TipoElemInfo elem){
  29.     TipoListaInfo aux;
  30.  
  31.     printf("Inserisco in testa %d %d %d\n",elem.x,elem.y,elem.ctrl);
  32.     aux=(TipoListaInfo)malloc(sizeof(NodoListaInfo));
  33.     aux->info=elem;
  34.     aux->next=*lis;
  35.     printf("%d\t",*lis);
  36.     *lis=aux;
  37.     printf("%d\n",*lis);
  38.     printf("fine inserimneto in testa\n");
  39. }
  40.  
  41. void InserisciInLista(TipoListaInfo *lis,TipoElemInfo elem1){
  42.     TipoListaInfo paux;
  43.     printf("Ho inserito elem1: %d %d %d\n",elem1.x,elem1.y,elem1.ctrl);
  44.    
  45.     printf("Ricerco %d,elem1\n",*lis);
  46.     paux=RicercaData(*lis,elem1);
  47.     if(paux!=NULL){
  48.      printf("%d != null\n",paux);
  49.      if(paux->info.ctrl == 1){
  50.       printf("%d != null &&  %d == 1\n",paux,paux->info.ctrl);
  51.       paux->info.ctrl = elem1.ctrl;
  52.      }else if (paux->info.ctrl == 0){
  53.        printf("%d != null && %d == 0\n",paux,paux->info.ctrl);
  54.        printf("Elemento già inserito\n");
  55.      }
  56.     }else{
  57.       printf("Inserisco in testa dato acceso\n");
  58.       InserisciInTestaDataAccesso(lis,elem1);
  59.      }
  60. }
  61.  
  62. void Leggi(TipoListaInfo *lis, int x, int y, int ctrl){
  63.     TipoElemInfo elem1;
  64.     elem1.x=x;
  65.     elem1.y=y;
  66.     elem1.ctrl=ctrl;
  67.     InserisciInLista(lis,elem1);
  68.     printf("Inserimento Completato Con Successo!\n");
  69. }
  70.  
  71. void StampaSuVideo(TipoListaInfo lis){
  72.     while(lis!=NULL){
  73.         printf("Data Accesso: X: %d Y:%d CTRL: %d\n", lis->info.x,lis->info.y,lis->info.ctrl);
  74.         lis=lis->next;
  75.     }
  76. }
  77.  
  78. void freeLista(TipoListaInfo *lis){
  79.     TipoListaInfo paux = *lis;
  80.     while(paux!=NULL){
  81.         paux = paux->next;
  82.         free(paux);
  83.    }
  84.  *lis = NULL;
  85. }
  86.  
  87. void elimina(TipoListaInfo *lis,int x,int y){
  88.    TipoElemInfo elem1;
  89.    elem1.x=x;
  90.    elem1.y=y;
  91.    printf("Ricerco elem1: %d %d %d\n",elem1.x,elem1.y);
  92.    
  93.    TipoListaInfo paux = RicercaData(*lis,elem1);
  94.    if(paux!=NULL){
  95.     printf("*lis: %d       paux: %d          paux->next: %d\n",*lis,paux,paux->next);
  96.     *lis = paux->next;
  97.     free(paux);
  98.    }
  99. }
  100.  
  101. TipoListaInfo topArchivio(TipoListaInfo *lis){
  102.  printf("\n\n\nTOP: %d\n\n\n",*lis);
  103.  return *lis;
  104. }


Codice sorgente - presumibilmente C/C++

  1. // nel main
  2. TipoListaInfo archivio = NULL;
  3.  
  4. if((mosaico[i][j] == 'n') && (mosaico[i+1][j] != 'b') && (mosaico[i-1][j] != 'b') && (mosaico[i][j+1] != 'b') && (mosaico[i][j-1] != 'b'))
  5.  Leggi(&archivio,i,j,1);
  6.  
  7.   while(archivio){
  8.    if(archivio->info.ctrl == 1){
  9.     Leggi(&archivio,tempx,tempy,0);
  10.  
  11.     if(mosaico[tempx][tempy + 1] == 'n') Leggi(&archivio,tempx,tempy + 1,1);
  12.      else if(mosaico[tempx][tempy + 1] == 'b') break;
  13.     if(mosaico[tempx][tempy - 1] == 'n') Leggi(&archivio,tempx,tempy - 1,1);
  14.      else if(mosaico[tempx][tempy - 1] == 'b') break;
  15.     if(mosaico[tempx + 1][tempy] == 'n') Leggi(&archivio,tempx + 1,tempy,1);
  16.      else if(mosaico[tempx + 1][tempy] == 'b') break;
  17.     if(mosaico[tempx - 1][tempy] == 'n') Leggi(&archivio,tempx - 1,tempy,1);
  18.      else if(mosaico[tempx - 1][tempy] == 'b') break;
  19.    }else{
  20.     printf("---------------------------------------------------------------------\n");
  21.  
  22.     printf("X: %d  Y: %d   CTRL: %d\n", archivio->info.x,archivio->info.y,archivio->info.ctrl);
  23.  
  24. printf("---------------------------------------------------------------------\n");
  25.    }
  26.   archivio = archivio->next;
  27.   }
  28.  }



cosa c'è di sbagliato? è tre giocrni che provo e riprovo ma non funziona mai và sempre in loop :grr:

Ultima modifica effettuata da andread il 16/11/2010 alle 0:34
PM
Avatar
Il Totem (Admin)
Guru^2


Messaggi: 3635
Iscritto: 24/01/2006

Up
0
Down
V
Segnala al moderatore
Postato alle 12:08
Martedì, 16/11/2010
Devi aggiungere elementi in coda e non in testa, te l'avevo già detto.
Lascia stare il bit di controllo, a guardar bene non serve.
Se negli if controlli che la piastrella non sia un bordo, devi impostare un qualche flag che ti dica questo, poiché se arrivi alla fine del while non sai se sei uscito perché hai finito di contare le piastrelle n vicino o perché una era vicina al bordo.

Perché la funzione che aggiunge elementi si chiama Leggi? Un po' di coerenza di vuole.


"Infelici sono quelli che hanno tanto cervello da vedere la loro stupidità."
(Fligende Blatter)

"Dubitare di se stessi è il primo segno d'intelligenza."
(Ugo Ojetti)
PM
Avatar
andread (Normal User)
Newbie


Messaggi: 4
Iscritto: 09/11/2010

Up
0
Down
V
Segnala al moderatore
Postato alle 13:58
Martedì, 16/11/2010
L'avevo chiamata Leggi perchè fondamentalmente legge la matrice comunque anche inserendo in coda succede sempre la stessa cosa loop infinito...
Codice sorgente - presumibilmente C#

  1. // inserisce un elemento in coda alla lista
  2. void InserisciCoda(LISTA **Head, int x,int y,int ctrl)
  3. {
  4.     LISTA *Temp,*Tail, *tmpHead = *Head;
  5.     int presente = 0;
  6.    
  7.     while(tmpHead!=NULL) {
  8.      if((tmpHead->x == x) && (tmpHead->y == y) && (tmpHead->ctrl == 1))
  9.       {
  10.        tmpHead->ctrl=ctrl;
  11.        presente = 1;
  12.        printf("METTO IL BIT A 0\n");
  13.       }else if((tmpHead->x == x) && (tmpHead->y == y) && (tmpHead->ctrl == 0))
  14.        {
  15.        presente = 1;
  16.        }
  17.          tmpHead = tmpHead->Next;
  18.         }
  19.    
  20.    if(presente != 1){
  21.     Temp=(LISTA *)malloc(sizeof(LISTA));
  22.     Temp->x=x;
  23.     Temp->y=y;
  24.     Temp->ctrl=ctrl;
  25.     Temp->Next=NULL;
  26.     if (*Head==NULL) {
  27.         *Head=Temp;
  28.     }
  29.     else {
  30.         Tail=*Head;
  31.         while (Tail->Next) {
  32.             Tail=Tail->Next;
  33.         }
  34.         Tail->Next=Temp;
  35.     }
  36.    }else printf("GIA' INSERITO\n");
  37. }



Codice sorgente - presumibilmente C++

  1. i=1;j=1;
  2. if((mosaico[i][j] == 'n') && (mosaico[i+1][j] != 'b') && (mosaico[i-1][j] != 'b') && (mosaico[i][j+1] != 'b') && (mosaico[i][j-1] != 'b')){
  3.  InserisciCoda(&Head,i,j,1);
  4.  int tempx=i,tempy=j,tempctrl;
  5.  
  6.  while(Head!=NULL){
  7.   if(Head->ctrl == 1){
  8.    InserisciCoda(&Head,i,j,0);
  9.    if(mosaico[tempx][tempy + 1] == 'n') InserisciCoda(&Head,tempx,tempy + 1,1);
  10.     else if(mosaico[tempx][tempy + 1] == 'b') Dealloca(&Head);
  11.    if(mosaico[tempx][tempy - 1] == 'n') InserisciCoda(&Head,tempx,tempy - 1,1);
  12.     else if(mosaico[tempx][tempy - 1] == 'b') Dealloca(&Head);
  13.    if(mosaico[tempx + 1][tempy] == 'n') InserisciCoda(&Head,tempx + 1,tempy,1);
  14.     else if(mosaico[tempx + 1][tempy] == 'b') Dealloca(&Head);
  15.    if(mosaico[tempx - 1][tempy] == 'n') InserisciCoda(&Head,tempx - 1,tempy,1);
  16.     else if(mosaico[tempx - 1][tempy] == 'b') Dealloca(&Head);
  17.   }
  18.   Head=Head->Next;  
  19.   }
  20.  }


PM
Avatar
Il Totem (Admin)
Guru^2


Messaggi: 3635
Iscritto: 24/01/2006

Up
0
Down
V
Segnala al moderatore
Postato alle 19:17
Mercoledì, 17/11/2010
Ti ho detto ti togliere il bit di controllo, perché non serve. Infatti tu aggiungi un nuovo elemento alla lista con il bit a 1. Poi, mentre scorri, se il bit è 1, lo aggiungi di nuovo. Risulta che aggiungi infiniti elementi tutti uguali senza mai uscire dal ciclo.

Per piacere, usa l'indentazione e le parentesi in maniera corretta, e soprattutto decidi come metterle.
Codice sorgente - presumibilmente C/C++

  1. while(tmpHead!=NULL)
  2. {
  3.    if((tmpHead->x == x) && (tmpHead->y == y) && (tmpHead->ctrl == 1))
  4.    {
  5.       tmpHead->ctrl = ctrl;
  6.       presente = 1;
  7.       printf("METTO IL BIT A 0\n");
  8.    } else if((tmpHead->x == x) && (tmpHead->y == y) && (tmpHead->ctrl == 0))
  9.    {
  10.       presente = 1;
  11.    }
  12.    tmpHead = tmpHead->Next;
  13. }


Questo è solo un esempio, il codice sarebbe da riscrivere senza quei controlli ridondanti sul bit ctrl.


"Infelici sono quelli che hanno tanto cervello da vedere la loro stupidità."
(Fligende Blatter)

"Dubitare di se stessi è il primo segno d'intelligenza."
(Ugo Ojetti)
PM