C Occorrenze parole in un file

di il
6 risposte

C Occorrenze parole in un file

Salve a tutti, devo realizzare un programma in C che legge un file txt e visualizza per ogni parola letta quante volte è presente e in quali righe.
link del pdf:
Lo sto realizzando in questo modo:
leggo una parola con
 fscanf(in, "%255[^ \f\n\r\t\v]%c", buffer, &c);
la parola contenuta in buffer volevo metterla in una struttura e qui nasce il problema. Non riesco a copiare la variabile buffer in un'altro tipo di variabile.
Volevo creare un array formato da almeno 1000 righe e 2 colonne, e mettere in ogni riga in posizione 0 la parola e in posizione 1 il numero di volte che trovo la parola, ho provato anche ad usare una struttura del tipo
typedef struct
           {
            char* parola;
            usigned short conta;
            }word;
ma non funziona lo stesso..

Questo è il codice che ho creato
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>

#define MAX_CODE 100000

#define IS_FULL(ptr) (!(ptr))

typedef struct{
					int key;
               } elemento;

typedef struct coda *coda_pointer;

typedef struct coda{
							elemento item;
                     coda_pointer link;
						 };

typedef struct
				{
            char* parola;
            usigned short conta;
				}word;

coda_pointer davanti[MAX_CODE],dietro[MAX_CODE];


void analizza ( FILE *in );

int main()
{
FILE *in;

in = fopen("testo.txt", "r");
if (in == NULL)
{
perror("fopen()");
exit(EXIT_FAILURE);
}
analizza(in);
fclose(in);
fflush(stdin);
getchar();
}

void analizza (FILE *in)
{
char c;
int riga = 0;
int dovesono = 0;


int i ;
for  ( i  = 0 ; i < MAX_CODE ; i++ )
	davanti[i] = NULL;

for (;;)
{
	char buffer[256] = {0};
	int result = fscanf(in, "%255[^ \f\n\r\t\v]%c", buffer, &c);

	if (result == EOF)
			break;
	if (result == 2)
	{
		printf("riga: %d parola: %s\n", riga+1, buffer);

      	{
				int k = 0;
            int flag = 0;
					for ( k = 0; k < dovesono ; k++ )
					   	if ( parola [ k ][0] == buffer )
						        {
                          	flag = 1;
                           break;
                          }
			    if ( flag == 0 )  // la parola non e' presente quindi la inserisco in coda


   				{
   	parola[k][0] = buffer ;
      parola[k][1] = 1 ;
		coda_pointer temp = (coda_pointer)malloc(sizeof(coda));  //  creo un elemento di tipo coda

	   if ( IS_FULL (temp) )
	   {
			fprint(stderr, " \n Memoria piena " );
      	exit(1);
	   }

	   temp->item = riga;
   	temp->link = NULL;

	   if ( *davanti )
   		( *dietro )->link = temp;
	   else
   		*davanti = temp;
	   *dietro = temp ;
      *dovesono++;
				}
             else    // parola presente nella struttura


             if ( *davanti < dovesono ) // aggiorno la coda
					{
			   	parola[k][1] += 1;

				coda_pointer temp = (coda_pointer)malloc(sizeof(coda));  //  creo un elemento di tipo coda

	   		if ( IS_FULL (temp) )
			   {
					fprint(stderr, " \n Memoria piena " );
      			exit(1);
			   }

	   		temp->item = riga;
		   	temp->link = NULL;

	   			if ( *davanti )
			   		( *dietro )->link = temp;
				   else
			   		*davanti = temp;
			   *dietro = temp ;
   					}

}

		if (c == '\n')
			++riga;
	}
	else if (result == 0)
	{
		if (fscanf(in, "%c", &c) == 1 && c == '\n')
		{
			printf("riga %d vuota\n", riga+1);
         ++riga;
		}
	}
	else
	{
		puts("Percepisco una turbolenza nella forza...");
      break;
	}
}
}

6 Risposte

  • Re: C Occorrenze parole in un file

    Ciao, l'esercitazione mi ha incuriosito cosi' ho scritto una possibile soluzione.
    Contrariamente a quanto chiede il testo pero' non ho implementato 2 cose:

    1. Non dico a che numero di riga/righe si incontra una parola.
    2. Il mio programma e' case - sensitive (quindi "Che" e' diverso dalla parola "che").
    3. La gestione delle parole non viene fatta in ordine alfabetico.

    questi 3 punti sono dovuti al fatto che mi manca la voglia. Per il resto funziona come dovrebbe (o almeno spero, non ho testato piu' di tanto), quindi lo posto sperando che possa essere utile.

    main.c
    
    /**
      * main.c
      *
      * Descrizione : Generatore Riferimenti Incrociati.
      *               La gestione delle parole NON viene fatta in ordine alfabetico
      *               quindi nemmeno il report finale lo sara'.
      *               Il programma e' case-sensitive.
      * Data 		: 14/08/2010
      */
    #include <stdio.h>
    #include <stdlib.h>
    
    #include "File.h"
    
    
    #define PGM_NAME      (0)
    #define FILE_IN	      (1)
    #define FILE_OUT	  (2)
    
    
    /* Prototipi funzione */
    static void usage (const char *);
    
    
    
    int main(int argc, char** argv) {
        FILE* fdIn;
        FILE* fdOut;
    
    
        if (argc != 3) {
           usage(argv[PGM_NAME]);
           return 0;
        }
    
        /* Apertura file di input & output */
        fdIn  = File_Open(argv[FILE_IN],RD);
        fdOut = File_Open(argv[FILE_OUT],WR);
    
        /* Lettura & memorizzazione in memoria del file di input */
        File_Load(fdIn);
    
        /* Chiusura file di input */
        File_Close(fdIn);
    
        /* Generazione report */
        File_PrepareReport(fdOut);
        File_WriteReport(fdOut);
    
        /* Chiusura file di output */
        File_Close(fdOut);
        return 0;
    }
    
    
    static void usage(const char* pgmname) {
        printf("Sintax: %s <file_in> <file_out>\n", pgmname);
    }
    
    
    File.h
    
    #ifndef FILE_H_
    #define FILE_H_
    
    #ifdef __cplusplus
        extern "C" {
    #endif
    
    typedef enum { RD, WR } ModeFileOpen;
    
    extern FILE* File_Open          (const char *, int);
    extern int   File_Close         (FILE *);
    extern void  File_Load          (FILE *);
    extern void  File_PrepareReport (FILE *);
    extern void  File_WriteReport   (FILE *);
    
    
    #ifdef __cplusplus
        }
    #endif
    #endif /* FILE_H_ */
    
    File.c
    
    /**
     * File.c
     *
     * Descrizione : Gestione fisica del file di testo.
     *               La funzione File_Load non e' stata testata molto quindi
     *+              potrebbe contenere dei bug.
     * Data        : 14/08/2010
     */
    #include <stdio.h>
    #include <stdlib.h>
    #include <string.h>
    #include <sys/types.h>
    #include <sys/stat.h>
    #include <unistd.h>
    #include <ctype.h>
    
    #include "File.h"
    #include "List.h"
    
    
    char* hdrFile[] = {
        "Nro",
        "Parole",
        "Numero di volte",
         NULL
    };
    
    struct _word* words = NULL;
    
    
    
    extern FILE* File_Open(const char* path, int mode) {
        struct stat st;
        FILE*       fd;
        char        s[3];
    
    
        /* Si sta' tentando di scrivere un file gia' esistente ?? */
        if (mode == WR) {
            if (stat(path,&st) != -1) {
              printf("[+] Il file esiste gia'.\n");
              exit(-1);
            }
        }
    
        switch (mode) {
            case RD:
                strcpy(s,"r");
                break;
            case WR:
                strcpy(s,"w");
                break;
        }
    
        if (!(fd = fopen(path,s))) {
            perror("fopen()");
            exit(-1);
        }
    
        return fd;
    }
    
    extern int File_Close(FILE* fd) {
        return fclose(fd);
    }
    
    extern void File_Load(FILE* fd) {
        struct _word* e;
        char          buff[MAX_BUFF];
        char          c;
        unsigned      ichar;
        unsigned      nword;
        unsigned      nrow;
        int           posw;
    
    
        ichar = nword = nrow = 0;
        fseek(fd, 0L, SEEK_SET);
    
        while ((c = fgetc(fd)) != EOF) {
            if (isalpha(c)) buff[ichar++] = c;
            if (c == ' ' || c == '\n') {
                if (c == '\n') ++nrow;
    
                buff[ichar++] = '\0';
                ichar         = 0;
    
                if (!words) {
                    words = List_Alloc(++nword,nrow,buff);
                }
                else {
                    /* La parola e' gia' in memoria ?? */
                    if ((posw = List_wordIsPresent(words,buff)) != WORD_NOTFOUND)
                        List_incWordCounter(words,posw, nrow);
                    else {
                        e = List_Alloc(++nword,nrow,buff);
                        List_Add(words,e);
                    }
                }
            }
        }
    }
    
    extern void File_PrepareReport(FILE* fd) {
        unsigned short i;
    
        for (i = 0; hdrFile[i]; ++i)
            fprintf(fd,"%4s\t\t",hdrFile[i]);
        fprintf(fd,"\n");
    }
    
    extern void File_WriteReport(FILE* fd) {
        struct _word* fly = words;
    
        while (fly) {
            fprintf(fd,"%3d\t\t%s\t\t%5d\n",fly->n,fly->s,fly->nrep);
            fly = fly->nx;
        }
    }
    

    List.h
    
    #ifndef LIST_H_
    #define LIST_H_
    
    #ifdef __cplusplus
        extern "C" {
    #endif
    
    #define MAX_BUFF      (255)
    #define WORD_NOTFOUND (-1)
    
    
    struct _word {
        unsigned      n;
        unsigned      nrep;
        char          s[MAX_BUFF];
        struct _word* nx;
    };
    
    
    
    extern struct _word* List_Alloc          (unsigned, unsigned, const char *);
    extern void          List_Add            (struct _word *, struct _word *);
    extern int           List_wordIsPresent  (struct _word *, const char *);
    extern void          List_incWordCounter (struct _word *, unsigned, unsigned);
    
    #ifdef __cplusplus
        }
    #endif
    #endif /* LIST_H_ */
    
    List.c
    
    /**
     * List.c
     *
     * Descrizione : Gestione file in memoria con una lista linkata aperta [ a coda ].
     * Data        : 14/08/2010
     */
    #include <stdio.h>
    #include <stdlib.h>
    #include <string.h>
    #include <errno.h>
    
    #include "List.h"
    
    
    
    extern struct _word* List_Alloc(unsigned nw, unsigned nr, const char* s) {
        struct _word* e;
    
        if (!(e = malloc(sizeof(struct _word)))) {
            perror("malloc()");
            exit(-1);
        }
    
        e->nx   = NULL;
        e->nrep = 1;
        e->n    = nw;
        strcpy(e->s, s);
        return e;
    }
    
    extern void List_Add(struct _word* t, struct _word* e) {
        struct _word* tmp = t;
    
        while (tmp->nx) tmp = tmp->nx;
        tmp->nx = e;
    }
    
    extern int List_wordIsPresent(struct _word* list, const char *word) {
        struct _word* fly;
        int           found;
    
        fly   = list;
        found = WORD_NOTFOUND;
        while (fly && found == WORD_NOTFOUND) {
            if (!(strcmp(fly->s,word))) found = fly->n;
            fly = fly->nx;
        }
    
        return found;
    }
    
    extern void List_incWordCounter(struct _word* list, unsigned n, unsigned r) {
        struct _word* fly = list;
    
        while (--n) fly = fly->nx;
        ++fly->nrep;
    }
    
    Saluti, netburst.


    [EDIT]
    Nel caso vi occorra il programma NON case-sensitive (quindi "Che" e' uguale alla parola "che") non dovete fare altro che apportare una piccola modifica alla funzione "List_wordIsPresent" presente nel module List.c.
    La modifica da effettuare e' sostituire quella strcmp che ho utilizzato con una vostra funzione per il controllo tra le 2 stringhe, ed in quella funzione considerare i caratteri minuscoli uguali ai maiuscoli, ed il gioco e' fatto.
    [/EDIT]
  • Re: C Occorrenze parole in un file

    Grazie mille dell'aiuto proverò a semplificarlo un pò per far vedere che è fatto da me e anche per capirlo meglio..
  • Re: C Occorrenze parole in un file

    netburst ha scritto:


    Ciao, l'esercitazione mi ha incuriosito cosi' ho scritto una possibile soluzione.
    Contrariamente a quanto chiede il testo pero' non ho implementato 2 cose:

    1. Non dico a che numero di riga/righe si incontra una parola.
    2. Il mio programma e' case - sensitive (quindi "Che" e' diverso dalla parola "che").
    3. La gestione delle parole non viene fatta in ordine alfabetico.
    il mio problema sta proprio nei numeri di riga, ti allego il codice che ho fatto.
    Praticamente non mi funziona la struttura in cui memorizzare i numeri di riga, ogni parola quando viene letta viene trasformata in minuscolo e vengono rimossi i segni di punteggiatura.
    
    # include <stdio.h>
    # include <string.h>
    # include <stdlib.h>
    # include <ctype.h>
    
    # define DIM 200
    # define MAX_CODE 100
    
    typedef struct // struttura per memorizzare le parole e il numero di occorrenze
    					{
    					char t [20];
    					int occ;
    					} parola ;
    
    typedef struct
    					{
                   int key;
                   }elemento;
    
    typedef struct coda *coda_pointer;
    typedef struct coda
    						{
                      elemento item;
                      coda_pointer link;
                      }queue;
    
    coda_pointer davanti[MAX_CODE],dietro[MAX_CODE];
    
    
    void stampa ( parola A[], int n)
    {
    	int i;
    	for (i=0;i<n;i++)
    		printf ("%s %d   %d\n",A[i].t,A[i]. occ);
    }
    
    int ricerca( char s[], parola A[], int n)
    {
    	int i,pos= -1;
    
       int dim=strlen(s);
       for(i=0;i<dim; i++)
        	s[i]=tolower(s[i]); // converte in minuscolo ogni lettera
    
      if( (s[dim-1]=='!') || (s[dim-1]=='?') || (s[dim-1]=='.') || (s[dim-1]==':')
      || ( s[dim-1]==',') || (s[dim-1]==';'))   //l'ultimo carattere è punteggiatura
       {
          s[dim-1]='\0';
       }
    
    	for (i=0;(i<n) && (pos <0);i++)
    	{
    		if ( strcmp (s,A[i].t )==0)
    			pos = i;
    	}
    	return pos;
    }
    
    void inserimento( char s[], parola A[], int *n, int righe)
    {
    	int pos;
    
    	pos = ricerca(s,A ,*n);
    
    	if (pos <0)
    	{
    		A[*n]. occ =1;
          strcpy (A[*n].t,s);
    		(*n)++;
    	}
    	else
    		A[ pos].occ++;
    // creo la coda con i numeri di riga
       inserisci_coda(&davanti[pos],&dietro[pos],righe);
    //
    }
    
    void inserisci_coda (coda_pointer *davanti,coda_pointer *dietro,int item)
    {
    	coda_pointer temp = (coda_pointer)malloc(sizeof(coda));
    
       if (IS_FULL(temp))
       {
       	fprintf(sderr, " MEMORIA PIENA ");
          exit(1);
       }
       temp->item = item;
       temp->link = NULL;
    
       if (*davanti)
       	(*dietro)->link = temp;
       else
       	*davanti = temp;
    
       *dietro = temp;
    }
    
    main ()
    {
    	parola A[DIM];
    	FILE *fp;
    	char s [20];
    	int n =0;
    
    //
       char c;
       int righe = 1;
       int no_coda;
    //
    
    	for ( no_coda = 0; no_coda<MAX_CODE; no_coda++ )  // inizializzo le (MAX_CODE) code a null
       	davanti[no_coda] = NULL;
    
    	fp= fopen("testo.txt","rt");
    
    	if (fp== NULL)
    	{
    		printf (" file non trovato\n");
    		exit ( -1);
    	}
    	while (! feof(fp ))
    	{
    
    //		fscanf (fp ,"%s[^ \f\n\r\t\v]%c",s,&c);     // con s al posto di 255 non riesce a contare le righe!
    		fscanf (fp ,"%255[^ \f\n\r\t\v]%c",s,&c);
    //
    	printf("riga: %d parola:%s  carattere: %c \n",righe,s,c);
       inserimento(s,A ,&n,righe); // passa la parola,l'array e 0 (la prima volta)
    
    	if (c == '\n')
    		righe++;
    	}
    	fclose (fp);
    	stampa (A,n);
    	fflush(stdin);
    	getchar();
    }
    
  • Re: C Occorrenze parole in un file

    Ma la struttura che dovrebbe contenere questi numeri di riga dov'è?
    Io vedo un tipo 'parola' che contiene una stringa ed il numero di occorrenze ('occ').
    Un tipo di nome 'elemento' che contiene un tipo int (a cosa serve questa cosa??) ed infine un tipo
    coda ('queue') che contiene una serie di integer.
    Non va bene se lo gestisci cosi'. La lista delle parole dove ce l'hai?
    Guarda nel mio sorgente (List.h per la precisione) e vedi che la gestione dell'elenco delle parole l'ho fatta utilizzando un tipo '_word':
    
    struct _word {
        unsigned      n;
        unsigned      nrep;
        char          s[MAX_BUFF];
        struct _word* nx;
    };
    
    Se vuoi gestire anche il numero di righe in cui si presentano le parole puoi fare una cosa del tipo:
    
    
    struct _nrow {
       unsigned        n;     // N.ro riga
        struct _nrow* nx;   // Link al prossimo nro di riga
    }
    
    struct _word {
        unsigned      n;
        unsigned      nrep;
        char          s[MAX_BUFF];
        struct _nrow  nrows;             /* In questa lista troverai una lista di integer che indicano i nro di riga in cui la parola (_word) si trova. Esempio: 1 2 3 4 .... */
        struct _word* nx;
    };
    
    Naturalmente quando allochi una nuova _word dovrai fare tutte le modifiche del caso per inizializzare, gestire anche la struttura _nrow.
    Saluti, netburst.
  • Re: C Occorrenze parole in un file

    netburst ha scritto:


    Ma la struttura che dovrebbe contenere questi numeri di riga dov'è?
    è questa:
    typedef struct coda
    {
    elemento item;
    coda_pointer link;
    }queue;

    dove in item (quindi in key ) va la riga e link è il collegamento all'altra parola che è la stessa cosa che hai fatto tu con

    netburst ha scritto:


    struct _nrow {
    unsigned n; // N.ro riga
    struct _nrow* nx; // Link al prossimo nro di riga
    }
    il problema è che unsigned non posso usarlo perchè non mi è mai stato spiegato quindi sarà un int quel n.
    Poi per quanto riguarda le parola vanno bene anche se stanno in un array, no ? tanto poi quando creo la coda se in parola[2] è presente 'ciao' in davanti[2] ci sarà la riga corrispondente di quella parola, o sbaglio ?
    Devi considerare che il mio livello è base e la tua soluzione è troppo avanzata ( cose mai spiegate a lezione quindi non implementabili) per questo sto cercando una soluzione semplice tipo delle code dinamicamente concatenate come in questo esempio:


    Aggiungo anche che i prof sono molto permalosi e vogliono che li studenti usino i loro pezzi di codice ( vedi la struttura per le parole con all'interno un'altra struttura) e non accettano volentieri soluzioni migliori.
    struct _word {
    unsigned n;
    unsigned nrep;
    char s[MAX_BUFF];
    struct _nrow nrows; /* In questa lista troverai una lista di integer che indicano i nro di riga in cui la parola (_word) si trova. Esempio: 1 2 3 4 .... */
    struct _word* nx;
    questa struttura mi piacerebbe usarla però non la so ne creare ne gestire per quello insisto su array + lista concatenata
  • Re: C Occorrenze parole in un file

    Sono riuscita a far funzionare il programma. Ora ho un grosso problema, non riesco a mettere in ordine le parole come posso fare?
    # include <stdio.h>
    # include <string.h>
    # include <stdlib.h>
    # include <ctype.h>
    
    # define DIM 200
    # define MAX_CODE 100
    
    #define IS_FULL(ptr) (!(ptr))
    #define IS_EMPY(ptr) (!(ptr))
    
    typedef struct // struttura per memorizzare le parole e il numero di occorrenze
    					{
    					char t [20];
    					int occ;
    					} parola ;
    
    typedef struct ele {
    						  int key;
                        struct ele*link;
    						 }Ele;
    Ele *davanti[MAX_CODE];
    
    Ele *crea_coda( Ele *davanti, int riga );
    //void crea_coda ( Ele *davanti, int riga );
    void stampa_lista( Ele *inizio);
    
    
    //coda_pointer davanti[MAX_CODE],dietro[MAX_CODE];
    
    void inserimento( char s[], parola A[], int *n, int righe);
    
    void stampa ( parola A[], int n )
    {
    	int i;
      	for (i=0;i<n;i++)
       	{
       	printf ("parola : %s occorrenze: %d ",A[i].t,A[i].occ);
          stampa_lista(davanti[i+1]); // i+1 perchè mettendo solo 1 sbagliava!
    //      printf("\n\n");
          }
    }
    
    void stampa_lista( Ele *inizio)
    {
    	while(inizio)
    	{
       	printf(" riga:  ");
    		printf("%d",inizio->key);
    	   inizio = inizio->link;
     	}
       printf("\n\n");
    /*
    	for (;inizio;inizio = inizio->link)
    	{
    		printf("riga:  ");
    		printf("%d",inizio->key);
       }
       printf("\n\n");
    */
    }
    
    int ricerca( char s[], parola A[], int n)
    {
    	int i,pos= -1;
    
       int dim=strlen(s);
       for(i=0;i<dim; i++)
        	s[i]=tolower(s[i]); // converte in minuscolo ogni lettera
    
      if( (s[dim-1]=='!') || (s[dim-1]=='?') || (s[dim-1]=='.') || (s[dim-1]==':')
      || ( s[dim-1]==',') || (s[dim-1]==';'))   //l'ultimo carattere è punteggiatura
       {
          s[dim-1]='\0';
       }
    
    	for (i=0;(i<n) && (pos <0);i++)
    	{
    		if ( strcmp (s,A[i].t )==0)
    			pos = i;
    	}
    	return pos;
    }
    
    Ele *crea_coda( Ele *davanti, int riga )
    //void crea_coda ( Ele *davanti, int riga )
    {
    Ele *p;
    Ele *aux = NULL;
    p = (Ele*) malloc (sizeof(Ele) );
    p->key = riga;
    p->link = NULL;
    
    //if (!davanti)
      //	return(p);
    //else
    	{
       aux = davanti;
       while ( aux->link && aux->link->key != riga) // per vedere se ho già inserito quel numero di riga aggiungere && aux->key != riga
       	aux = aux->link;
       aux->link = p;
    //   printf("  ------- riga crea_coda  P:  %d  AUX: %d  riga: %d\n",p->key,aux->link->key,riga);
       return (davanti);
       }
    }
    
    
    void inserimento( char s[], parola A[], int *n, int righe)
    {
    	int pos;
    
    	pos = ricerca(s,A ,*n);
    
    	if (pos <0) // la parola non esiste ancora perciò la creo
    	{
    		A[*n]. occ =1;
          strcpy (A[*n].t,s);
    	pos=(*n);  // da togliere serve alla printf
    		(*n)++;
    	}
    	else     // aggiorno il contatore esistente
    		A[pos].occ++;
    
    //   printf("--- ho messo [  %s  ]  in A[  %d  ]  ho passato la riga [  %d  ]\n", s,pos,righe);
    
    // creo la coda con i numeri di riga
      crea_coda(&davanti[pos],righe);
    	//davanti[pos] = crea_coda( &davanti[pos], righe );  da cancellare
    //
    }
    
    int main()
    {
    	parola A[DIM];
    	FILE *fp;
    	char s [20];
    	int n =0; // posizione nel vettore dell'ultima parola inserita
       char c;
       int righe = 1;
    
    
    
    
    int i;
    
    for ( i = 0 ; i < 10 ; i++ )
    	davanti[i] = NULL;
    
     	fp= fopen("testo.txt","rt");
    
    	if (fp== NULL)
    	{
    		printf (" file non trovato\n");
    		exit ( -1);
    	}
    	while (! feof(fp ))
    	{
    
    //		fscanf (fp ,"%s[^ \f\n\r\t\v]%c",s,&c);     // con s al posto di 255 non riesce a contare le righe!
    		fscanf (fp ,"%255[^ \f\n\r\t\v]%c",s,&c);
    //
    //	printf("riga: %d parola:%s  carattere: %c \n",righe,s,c);
       inserimento(s, A, &n, righe); // passa la parola,l'array e 0 (la prima volta)
    
    	if (c == '\n')
    		righe++;
    	}
    	fclose (fp);
       printf("\n\n\n");
    	stampa (A,n);
    // da cancellare
    //  printf("\n\nlista\n\n");
    //   for (i=0;i<=n;i++)
    //	  stampa_lista(davanti[i]);
    	printf ("\n\nfine premi invio per uscire");
    	fflush(stdin);
    	getchar();
    }
Devi accedere o registrarti per scrivere nel forum
6 risposte