/* * MAIN */ int main(int argc, char **argv) { int temp = 0; int countercicli = 0; double tempo_esecuz, inizio; acquisisci(argc, argv); nstampa = 0; fout = fopen(OUTFILE, "w"); fprintf(fout, "**** METODO UNGHERESE **** n\nValori inseriti:\n"); stampa(); inizio = clock(); normalizza(); soluzione_iniziale_duale(); /*finch� ci sono stazioni esposte in partenza*/ while (esistono_a_esposti() != -1) { /* aggiorno soluzione duale (I J + - e delta) finch� non esistono cammini aumentanti */ while (!cammino_aumentante()) aggiorna_soluzione_duale(); /*a questo punto esiste un cammino*/ incrementa_flusso(); } tempo_esecuz = clock() - inizio; /* in CLOCKS_PER_SEC */ stampa(); fprintf(fout, "costo totale %d\nTempo di esecuzione %lf\n", costo_totale(), tempo_esecuz); fclose(fout); printf("Risultato in OUTFILE\n"); /*system("pause");*/ return 0; }
//stampa in profondità void stampa(nodo* radice){ if(radice!=NULL){ printf("\nRadice %d albero DX",radice->dato); stampa(radice->DX); printf("\nRadice %d albero SX",radice->dato); stampa(radice->SX); } };
int main() { int n,i; printf("Inserisci grandezza del vettore:"); scanf("%d",&n); V=(int *)malloc(sizeof(int)*n); srand(time(NULL)); for(i=0;i<n;i++) V[i]=rand()%100; stampa(n); mergesort(0,n-1); stampa(n); }
/** * Creo soluzione iniziale duale con minimi di riga e colonna. Miglioro soluzione rp */ void soluzione_iniziale_duale() { int min, i, j; /*per ogni riga*/ for (i = 0; i < m; i++) { /*cerco il minimo di riga*/ min = MCosti[i][0]; for (j = 1; j < n; j++) if (MCosti[i][j] < min) min = MCosti[i][j]; /*scrivo il minimo nel vettore u^*/ u_duale[i] = min; /*tolgo minimo alla riga*/ for (j = 0; j < n; j++) MCosti[i][j] = MCosti[i][j] - min; } /*per ogni colonna*/ for (j = 0; j < n; j++) { /*cerco il minimo di colonna*/ min = MCosti[0][j]; for (i = 1; i < m; i++) if (MCosti[i][j] < min) min = MCosti[i][j]; /*scrivo il minimo nel vettore v^*/ v_duale[j] = min; /*tolgo minimo alla colonna*/ for (i = 0; i < m; i++) MCosti[i][j] = MCosti[i][j] - min; } fprintf(fout, "RP con costi = Cij-Uij-Vij:\n"); stampa(); stampa_soluz_duale(); /* miglioro soluzione PR */ for (i = 0; i < m; i++) for (j = 0; j < n; j++) if (MCosti[i][j] == 0) { min = minimo(a[i], b[j]); X[i][j] = min; a[i] -= min; b[j] -= min; } fprintf(fout, "Soluzione iniziale di RP"); stampa(); }
int main() { int *v1 = NULL; v1 = malloc(sizeof(int)*NELEMENTI) leggiVett(v1); printf("Prima: "); stampa(v1); checkMerda(v1); printf("Dopo : "); stampa(v1); sleep(5000); // mette in pausa per 5 secondi cosi leggete scemi. free(v1); return 0; }
void stampa(int n) { if (n == 0) return; else { stampa(n - 1); putchar('a' + n - 1); } }
//Stampa ricorsiva di una lista void stampa(struct lista *p) { if(p != NULL) { printf("%c->",p->car); stampa(p->next); } }
int main() { ppiano p = NULL; stampa(p); add(&p, 1.0,3.0); add(&p, 1.0,2.0); add(&p, -1.0, 4.0); add(&p , 0.0, 1.0); stampa(p); printf("\n\nProva di cancellazione"); del(&p, 0.0,0.0, 3); stampa(p); return 0; }
int main(void) { int n; printf("n: "); scanf("%d", &n); stampa(n); printf("\n"); return 0; }
void stampa(char *s) { int main(void) { char stringa[] = "UNIX Programming with POSIX"; /* La memset puo' essere utilizzata, ad esempio, per azzerare un array, tuttavia c'e' una sottile considerazione da porre in essere: se si utilizza il numero 0 la stringa sara' effettivamente azzerata, se invece si utilizza il carattere 0 l'array sara' riempito di tanti zeri. */ int n_zero = 0; char c_zero = '0'; int size = strlen(stringa); /* Azzero l'array */ memset(stringa, c_zero, size); stampa(stringa); /* Inserisco per ogni byte uno zero */ memset(stringa, n_zero, size); stampa(stringa); return(EXIT_SUCCESS); }
void log_replay (int fd, struct hashtable *db) { char key[128], value[128]; int k_len,v_len; while(1) { if (read(fd, &k_len, sizeof(int)) != sizeof(int)) break; if (read(fd, &v_len, sizeof(int)) != sizeof(int)) break; if (read(fd, key, k_len) != k_len) break; if (read(fd, value, v_len) != v_len) break; hashtable_insert(db, key, value, k_len, v_len); printf("replay key\n "); stampa(key, k_len); } }
int main() { char stringa[20]; int i; struct lista *inizio=NULL; printf("Inserisci la stringa: "); scanf("%s",stringa); for(i=0; i < strlen(stringa); i++) inizio = ins_coda(inizio,stringa[i]); printf("h->"); stampa(inizio); printf("NULL\n"); inizio = inverti(inizio); printf("h->"); stampa(inizio); puts("NULL"); return 0; }
int main(void) { int n,l,i; printf("Inserisci lunghezza stringa:"); scanf("%d",&n); V=(int *)malloc(sizeof(int)*n); srand(time(NULL)); for(i=0;i<n;i++) V[i]=rand()%10; stampa(n); l=sottosequenza(n,0); printf("La piu lunga sottosequenza è formata da:%d",l); }
int main(){ //creo l'albero binario nodo* radice = crea_nodo(); printf("\nSi vuole inserire dei figli?"); //non entra nel ciclo ma la funzione decisiione all'infinito while(decisione()){ printf("\nSi procede con l'inserimento di %d\n",n_vet); alloca_figlo(radice); printf("\nContinuare?"); } stampa(radice); return 0; }
int main(int argc, const char * argv[]) { int **m, i, j,n,loop ; int somRiga,somColonna,somDiagonale,magica; magica=0; somRiga=0; somColonna=0; somColonna=0; srand((unsigned)time(NULL)); printf("Inserire la dimensione della matrice: "); scanf("%d", &n); int n_quadrato= pow(n,2); for (loop=0; loop<=1000; loop++) { m=(int **)malloc(sizeof(int *)*n); for(i=0; i<n; i++) m[i]=(int *)malloc(sizeof(int)*n); for(i=0; i<n; i++){ for(j=0; j<n; j++){ m[i][j]=rand() % n_quadrato+1; } } stampa(m, n); somRiga=somma_riga(m, n); somColonna=somma_colonne(m, n); somDiagonale=somma_diagonale(m,n); if (somColonna==somRiga && somDiagonale==somColonna) { printf("matrice magica\n"); magica++; } } printf("le matrici magiche sono:%d\n",magica); printf("la percentuale di successi è: %d %% \n",media(magica)); return 0; }
int main () { int m, n, i; int *a, *b, *c; printf ("Inserisci la lunghezza del primo vettore \n"); scanf ("%d", &m); a = calloc (m, sizeof(int)); printf ("Inserisci la lunghezza del secondo \n"); scanf ("%d", &n); b = calloc (n, sizeof(int)); printf ("Inserisci il primo vettore \n"); for (i = 0; i < m; i++) { printf ("Inserisci l'elemento in posizione %d \n", i); scanf ("%d", &a[i]); if (i != 0) while (a[i] < a[i-1]) { printf ("Errore! Vettore non ordinato, inserisci nuovamentel'elemento"); scanf ("%d", &a[i]); } } printf ("Inserisci il secondo vettore \n"); for (i = 0; i < n; i++) { printf ("Inserisci l'elemento in posizione %d \n", i); scanf ("%d", &b[i]); if (i != 0) while (b[i] < b[i-1]) { printf ("Errore! Vettore non ordinato, inserisci nuovamentel'elemento"); scanf ("%d", &b[i]); } } c = calloc(n + m, sizeof(int)); merge (a, b, c, m, n); stampa(c,n+m); }
int main() { quadri *db=NULL; int n=0,risp; do { printf("-- MENU' --\n1. Inserisci dati\n2. Carica dati\n3. Scrivi dati ordinati\n4. Visualizza dati\n5. Numero totale quadri con altezza e larghezza maggiore\n6. Esci\nRisposta: "); scanf("%d",&risp); switch(risp) { case 1: db=inserisci_dati(db,&n); break; case 2: db=carica_dati(db,&n); break; case 3: db=scrivi_dati(db,n); break; case 4: stampa(db,n); break; case 5: totale(db,n); break; case 6: break; default: printf("Risposta errata!\n"); break; }; }while(risp != 6); free(db); return 0; }
quadri *carica_dati(quadri *db, int *n) { FILE *f; if((f=fopen(nomefile,"rb")) != NULL) { while(!feof(f)) { db=(quadri*)realloc(db,((*n)+1)*sizeof(quadri)); fread((db+(*n)),sizeof(quadri),1,f); (*n)++; }} else { printf("File impossibile da aprire!\n"); exit(1); } db=ordina(db,*n); stampa(db,*n); fclose(f); return db; }
int main() { int *A,num,i; printf("Quanti elementi vuoi inserire ?\nRisposta: "); scanf("%d",&num); A = (int*)malloc(num*sizeof(int)); printf("- Inserisci gli elementi dell'array -\n"); for(i=0; i < num; i++) { printf("Valore %d: ",i); scanf("%d",&A[i]); } stampa(A,num); //Mettiamo num-1 perché così non inizia da num ma da num - 1 dato che un array va da 0 ad n-1 printf("La somma degli elementi del vettore A e': %d\n",somma(A,num-1)); return 0; }
/** * Test per verificare la corretta esecuzione di vari metodi fondamentali. (utilizzo * di stampa come procedura d'appoggio). */ void testValueGetSetOperator(){ cbuffer<int> cb1(5); cbuffer<float> cb2(4,2.2); cbuffer<std::string> cb3(3,"stringa"); std::cout << "test get_size() e get_items(): " << std::endl; std::cout << "cb1 size: " << cb1.get_size() << std::endl; std::cout << "cb2 size: " << cb2.get_size() << std::endl; std::cout << "cb3 size: " << cb3.get_size() << std::endl; std::cout << "cb1 items: " << cb1.get_items() << std::endl; std::cout << "cb2 items: " << cb2.get_items() << std::endl; std::cout << "cb3 items: " << cb3.get_items() << std::endl; std::cout << "test get_cbuffer(size_type) e set_cbuffer(size_type, const &T):" << std::endl; cb2.set_cbuffer(3, 4); std::cout << "cb2[3] set 4 " << std::endl; std::cout << "cb2[3] get: " << cb2.get_cbuffer(3) << std::endl; std::cout << "test T& value(size_type index):" << std::endl; cb3.value(0)="fiorellino"; std::cout << "scrittura cb3.value(0)"<< std::endl; std::cout << "lettura cb3.value(0)= " << cb3.value(0) << std::endl; std::cout << "test operator[]" << std::endl; cb3[2]="alberello"; std::cout << "scrittura cb3[2] " << std::endl; std::cout << "lettra cb3[2] " << cb3[2] << std::endl; std::cout << "stampa(const cbuffer<int>)" << std::endl; cbuffer<int> cb4(6); cb4.insert(1); cb4.insert(2); cb4.insert(3); cb4.insert(4); std::cout << cb4 << std::endl; stampa(cb4); }
int main(void) { Data d1, d2; printf("Inserisci la prima data, formato dd/mm/YYYY: "); scanf("%d / %d / %d", &(d1.giorno), &(d1.mese), &(d1.anno)); fflush(stdin); printf("\nInserisci la seconda data, formato dd/mm/YYYY: "); scanf("%d / %d / %d", &(d2.giorno), &(d2.mese), &(d2.anno)); switch(confronta(d1, d2)) { case 0: printf("La data "); stampa(d1); printf(" e' uguale alla data "); stampa(d2); printf("!\n"); break; case 1: printf("La data "); stampa(d1); printf(" e' antecedente alla data "); stampa(d2); printf("!\n"); break; case -1: printf("La data "); stampa(d1); printf(" e' successiva alla data "); stampa(d2); printf("!\n"); break; } free(test); return 0; }
int main(void) { int numero = leggi(); stampa(numero); return 0; }
/*Legge la mossa del giocatore*/ void leggimossa() { int tasto=0; fflush(stdin); /*Se è attivo il tastierino*/ if(tastierino==1) { do { tasto=0; fflush(stdin); /*2 giocatori*/ if(scelta==2) printf("%-59s%s%s\n", GIALLO, "Fai la tua mossa:", BIANCO); else printf("%58s%s %d\n%-55s%s%s\n", GIALLO, "Gioca il giocatore", giocatore, "", "Fai la tua mossa:",BIANCO); if(os) tasto=mgetchar(); else do { tasto=getch(); } while(kbhit()); switch(tasto) { case 49: { i=2; k=0; break; } case 50: { i=2; k=1; break; } case 51: { i=2; k=2; break; } case 52: { i=1; k=0; break; } case 53: { i=1; k=1; break; } case 54: { i=1; k=2; break; } case 55: { i=0; k=0; break; } case 56: { i=0; k=1; break; } case 57: { i=0; k=2; break; } } if(tabella[i][k]==1 || tabella[i][k]==2 || i<0 || k<0 || i>=M || k>=M) { system(clear); stampa(); printf("%-59s%s%s\n\n", GRASSETTO ROSSO, "Mossa non valida, riprova.", RESET BIANCO); } } while(tabella[i][k]==1 || tabella[i][k]==2 || i<0 || k<0 || i>=M || k>=M); } /*Mossa con coordinate*/ else { do { /*Giocatore singolo*/ if(scelta==2) printf("%-63s%s\n%-40s%s%s %s%s\n", GIALLO, "Tocca a te.", "", "Inserisci coordinate della mossa", ROSSO, "[Riga,colonna]:", BIANCO); /*2 giocatori*/ else printf("%-58s%s %d\n%-40s%s %s%s%s\n", GIALLO, "Gioca il giocatore", giocatore, "", "Inserisci coordinate della mossa", ROSSO, "[Riga,colonna]:", BIANCO); scanf("%d,%d",&i,&k); if(tabella[i][k]==1 || tabella[i][k]==2 || i<0 || k<0 || i>=M || k>=M) { system(clear); stampa(); printf("\n\n%-56s%s%s\n\n\n", GRASSETTO ROSSO, "Coordinate non valide, riprova.", RESET BIANCO); } } while(tabella[i][k]==1 || tabella[i][k]==2 || i<0 || k<0 || i>=M || k>=M); system(clear); } }
/* * step2 algo ungherese. Cerca il cammino aumentante e lo ricostruisce. * * 1=cammino trovato 0 =cammino non trovato */ int cammino_aumentante() { int i, j; elemento_coda_t *elem_coda_temp; int k; int direz; int cammino_trovato = 0; t = -1; reset_etichette(); /*serve ???? */ /*reset coda stazioni*/ reset_coda(&uscita_coda_stazioni, &ingresso_coda_stazioni); /*trovo prima stazione di partenza esposta*/ s = esistono_a_esposti(); ps[s] = 0; metti_in_coda(&uscita_coda_stazioni, &ingresso_coda_stazioni, s, 'o'); fprintf(fout, "\nRicerco cammino...\n"); while (cammino_trovato != 1 && !is_coda_vuota(uscita_coda_stazioni, ingresso_coda_stazioni)) { /* tolgo ultimo elemento dalla coda (primo elemento K da LIST * secondo procedura cam.aument.) */ elem_coda_temp = togli_da_coda(&uscita_coda_stazioni, &ingresso_coda_stazioni); k = elem_coda_temp->indice_k; direz = elem_coda_temp->direzione; /* se k � una origine ... */ if (direz == 'o') { /* per ogni el. della riga*/ for (j = 0; j < n && !cammino_trovato; j++) /* se ha costo nullo, non � stata etichettata ... */ if (MCosti[k][j] == 0 && pd[j] == -1) { /*metto etichetta*/ pd[j] = k + 1; if (b[j] == 0) metti_in_coda(&uscita_coda_stazioni, &ingresso_coda_stazioni, j, 'd'); else { t = j; cammino_trovato = 1; /*TROVATO CAM.AUM. => esco dal ciclo principale*/ } } } else { /* per ogni el. della colonna*/ for (i = 0; i < m; i++) /* se ha costo nullo, non � stata etichettata e c'� un flusso */ if (MCosti[i][k] == 0 && ps[i] == -1 && X[i][k] > 0) { ps[i] = k + 1; metti_in_coda(&uscita_coda_stazioni, &ingresso_coda_stazioni, i, 'o'); } } } stampa(); /* se ho trovato un cammino... */ if (cammino_trovato) { fprintf(fout, "Cammino trovato !\n"); /* cammino trovato (t � stato gi� impostato)*/ return 1; } else { t = 0; fprintf(fout, "Cammino NON trovato, aggiorno la soluzione !\n"); /*cammino non esistente*/ return 0; } }
void client_loop (int cfd) { char buffer[2048]; while (1) { ssize_t rd; if ((rd = read(cfd, buffer, 128)) <= 0) { perror("read()"); break; } if (memcmp(buffer, "scus", 4) == 0) { memcpy(buffer, "figur\n", 6); rd = 6; } else if (memcmp(buffer, "chiudi", 6) == 0) { break; } else if (memcmp(buffer, "put", 3) == 0) { printf("Byte letti %d\n", rd); char *key, *value; int k_len, v_len; key = buffer + 4; printf("key = %p\n",key); value = memchr(buffer + 4, ' ', rd - 4) +1; k_len =(value - key) - 1; v_len = rd - 4 - k_len - 1; printf("Key = "); stampa(key, k_len); printf("Value = "); stampa(value, v_len); /*int i_key; i_key = strtol(key, NULL, 10); printf("integer key = %d\n", i_key);*/ hashtable_insert(&db, key, value,k_len, v_len); log_insert(log_fd, key, value,k_len, v_len); memcpy(buffer, "storato\n", 8); rd = 8; } else if (memcmp(buffer, "get", 3) == 0) { char *g_key, *g_value; int g_key_len, v_len; g_key = buffer + 4; g_key_len = rd - 4; //ig_key = strtol(g_key, NULL, 10); g_value = hashtable_get(&db, g_key, g_key_len, &v_len); memcpy(buffer, g_value, v_len); memcpy(buffer + v_len, "\n", 1); rd = v_len + 1; } else if (memcmp(buffer, "GET", 3) == 0) { char xbuffer[4096]; read(cfd, xbuffer, sizeof(xbuffer)); memcpy(buffer, html, strlen(html)); rd = strlen(html); } else { memcpy(buffer + rd, "culo\n", 5); printf("il buffer %s\n", buffer); rd += 5; } if (write(cfd, buffer, rd) != rd) { perror("write()"); break; } } close(cfd); }
int main() { struct nodo *list=NULL; //puntatore alla lista int scelta=1; for(;;) { printf("\n\nMenu:\n\n"); printf("1. Visualizza lista\n"); printf("2. Aggiungi nodo\n"); printf("3. Svuota lista\n"); printf("4. Cerca elemento\n"); printf("5. Elimina un elemento\n"); printf("6. Esci\n"); printf("Scelta: "); char string[80]; fgets(string, sizeof(string), stdin); scelta = atoi(string); /******************************************************************************/ if(scelta==1) //Visualizzazione della lista { printf("\n\nVisualizzazione della lista:\n\n"); if( vislist(list, stampa)==0 ) printf("Lista vuota: nessun elemento da visualizzare"); else printf("\n\nFine della lista."); } /******************************************************************************/ else if(scelta==2) //Aggiunta di elementi { printf("\n\nAggiunta di elementi nella lista\n\n"); printf("Scegli la modalità di inserimento:\n\n"); printf("1. Ordine crescente per nome\n"); printf("2. Ordine crescente per numero\n"); printf("3. Ordine decrescente per nome\n"); printf("4. Ordine decrescente per numero\n"); printf("5. Inserisci in testa\n"); printf("6. Inserisci in coda\n"); printf("\nScelta: "); int scelta; scanf("%d", &scelta); printf("\n\nCreazione di una nuova persona:\n"); struct persona *tmp; tmp=creapersona(NULL, 3); if(scelta==1) sortadd(tmp, &list, crescnome); else if(scelta==2) sortadd(tmp, &list, crescnum); else if(scelta==3) sortadd(tmp, &list, decrenome); else if(scelta==4) sortadd(tmp, &list, decrenum); else if(scelta==5) tohead(tmp, &list); else if(scelta==6) totail(tmp, &list); printf("Inserimento effettuato!"); } /******************************************************************************/ else if(scelta==3) //Svuota la lista { printf("\n\nSvuotamento della lista\n\n"); if( byelist(&list, libera)==0 ) printf("\n\nLista già vuota. Nulla da fare.\n\n"); else printf("\n\nLista svuotata.\n\n"); } /******************************************************************************/ else if(scelta==4) //Ricerca di un valore { printf("\n\nRicerca di un elemento:\n\n"); printf("Scegli la modalità di ricerca:\n"); printf("1. Per nome\n"); printf("2. Per numero\n"); printf("3. Per nome e numero (verifica l'esistenza)\n"); printf("Scelta: "); int scelta; scanf("%d", &scelta); //setto le variabili necessarie a seconda della modalità indicata dall'utente struct persona *confronto, *trovato; struct nodo *postit; void *funzi; if(scelta==1) //vi è corrispondenza tra i numeri del menù e i numeri che stabiliscono la modalità di funzionamento della funzione creapersona; MA è solo una coincidenza: sviluppi futuri potrebbero perdere questa corrispondenza e utilizzare composizioni delle modalità della funzione stessa (richiamare più volte la funzione con modalità diverse per riempire determinati campi) { confronto = creapersona(NULL, 1); funzi=crescnome; } else if(scelta==2) { confronto = creapersona(NULL, 2); funzi=crescnum; } else if(scelta==3) { confronto = creapersona(NULL, 3); funzi=oggcmp; } //la prima chiamata a cerca() deve essere fatta con un puntatore nullo e si deve verificare che venga restituito un valore non nullo, altrimenti significa che l'oggetto non è stato trovato nella lista postit = NULL; trovato = cerca( confronto, list, &postit, funzi ); //prima chiama: postit è NULL if( trovato==NULL ) printf("\n\nValore non trovato nella lista!\n"); //valore non trovato, trovato==NULL else { printf("\n\nElenco delle voci trovate:\n"); do{ stampa(trovato); //stampa l'oggeto trovato trovato = cerca( confronto, list, &postit, funzi ); //passo successivo nella ricerca }while( trovato!=NULL ); printf("\n\nFine elenco.\n"); } free(confronto); } /******************************************************************************************/ /* else if(scelta==5) //Eliminazione di un nodo { int val; struct nodo *tmp; printf("\n\nEliminazione di un elemento dalla lista\n\n"); printf("Scegli:\n"); printf("1. Elimina un elemento per numero\n"); printf("2. Elimina un elemento dalla testa\n"); printf("3. Elimina un elemento dalla coda\n"); printf("\nScegli: "); int scelta; scanf("%d", &scelta); if(scelta==1) { printf("\n\nEliminazione di un elemento per valore\n\n"); printf("Inserisci il campo: numero\n\n"); scanf("%d", &val); //funzione per l'eliminazione di un determinato elemento } else if(scelta==2) { printf("\n\nEliminazione di un elemento dalla testa...\n\n"); if( tmp=delhead(list)==NULL ) printf("Lista già vuota: nulla da cancellare."); else printf("N } else if(scelta==3) { printf("\n\nEliminazione di un elemento dalla coda...\n\n"); //funzione di un elemento dalla coda } } */ /******************************************************************************************/ else if(scelta==6) //Uscita dal programma { printf("\n\nUscita dal programma\n\n"); exit(0); } else printf("\n\nScelta non valida...\n"); /******************************************************************************************/ } } //FINE MAIN