Untitled
unknown
plain_text
7 days ago
30 kB
2
Indexable
Never
#include <stdio.h> #include <stdlib.h> #include <string.h> #include <stdbool.h> #include <time.h> #define BUFFER_SIZE 10000 #define SIZE_TABELLA_INIZIALE 1024 struct lotto { int quantita; int scadenza; struct lotto *next; }; struct ingrediente { char *nome_ingrediente; struct lotto *lotto_ingrediente; int quantita_totale_lotti; // quantita in grammi dei lotti di quel determinato ingrediente struct ingrediente * next; }; struct ingrediente_in_ricetta { char * nome_ingrediente; struct ingrediente *ingrediente_associato; int quantita; struct ingrediente_in_ricetta *next; }; struct ricetta { char *nome_ricetta; struct ingrediente_in_ricetta * ingredienti_ricetta; int peso_ricetta; // peso_ricetta = quantita di ogni ingrediente in grammi, lo calcolo quando aggiungo una ricetta struct ricetta *next; }; struct ordine { char * nome_ordine; int quantita; int istante_di_tempo; struct ricetta *ricetta_ordine; // ogni ordine ha un puntatore alla sua ricetta int peso_ordine; struct ordine *next; } order; struct tabella_ricette { struct ricetta ** ricetta_in_tabella; int numero_elementi; int size; }; struct tabella_ingredienti { struct ingrediente **ingredienti_in_tabella; int numero_elementi; int size; }; struct ordine * ordini_pronti = NULL; struct ordine * coda_pronti = NULL; struct ordine * ordini_attesa = NULL; struct ordine * coda_attesa = NULL; struct ordine * camioncino = NULL; struct tabella_ricette * crea_ricettario(){ struct tabella_ricette * ricettario = malloc(sizeof(struct tabella_ricette)); ricettario->numero_elementi = 0; ricettario->ricetta_in_tabella = (struct ricetta **)calloc(SIZE_TABELLA_INIZIALE, sizeof(struct ricetta *)); ricettario->size = SIZE_TABELLA_INIZIALE; return ricettario; }; struct tabella_ingredienti * crea_magazzino(){ struct tabella_ingredienti * magazzino = malloc(sizeof(struct tabella_ingredienti)); magazzino->numero_elementi = 0; magazzino->ingredienti_in_tabella = calloc(SIZE_TABELLA_INIZIALE, sizeof(struct tabella_ingredienti *)); magazzino->size = SIZE_TABELLA_INIZIALE; return magazzino; }; unsigned long funzione_hash(const char *chiave, int size) // funzione hash sdbm { unsigned long hash = 0; int c; while ((c = *chiave++)) { hash = ((hash << 5) + hash) + c; } return hash % size; } void resize_tabella_ricette(struct tabella_ricette * ricettario) { int new_size = ricettario->size * 2; struct ricetta **copia_ricette = calloc(new_size, sizeof(struct ricetta *)); for (int i = 0; i < ricettario->size; i++) { struct ricetta * nodo = ricettario->ricetta_in_tabella[i]; while (nodo != NULL) { struct ricetta * nodo_successivo = nodo->next; unsigned long hash = funzione_hash(nodo->nome_ricetta, new_size); nodo->next = copia_ricette[hash]; copia_ricette[hash] = nodo; nodo = nodo_successivo; } } free(ricettario->ricetta_in_tabella); ricettario->ricetta_in_tabella = copia_ricette; ricettario->size = new_size; } void resize_tabella_ingredienti(struct tabella_ingredienti * magazzino) { int new_size = magazzino->size * 2; struct ingrediente **copia_ingredienti = calloc(new_size, sizeof(struct ingrdiente *)); for (int i = 0; i < magazzino->size; i++) { struct ingrediente * nodo = magazzino->ingredienti_in_tabella[i]; while (nodo != NULL) { struct ingrediente * nodo_successivo = nodo->next; unsigned long hash = funzione_hash(nodo->nome_ingrediente, new_size); nodo->next = copia_ingredienti[hash]; copia_ingredienti[hash] = nodo; nodo = nodo_successivo; } } free(magazzino->ingredienti_in_tabella); magazzino->ingredienti_in_tabella = copia_ingredienti; magazzino->size = new_size; } struct ingrediente *crea_ingrediente(char *nome) { struct ingrediente *nuovo_ingrediente = malloc(sizeof(struct ingrediente)); nuovo_ingrediente->nome_ingrediente = strdup(nome); nuovo_ingrediente->lotto_ingrediente = NULL; nuovo_ingrediente->next = NULL; nuovo_ingrediente->quantita_totale_lotti = 0; return nuovo_ingrediente; } struct ingrediente_in_ricetta *crea_ingrediente_in_ricetta(struct ingrediente * ingrediente_ricetta, int quantita_ingrediente) { struct ingrediente_in_ricetta * ingr_ricetta = malloc(sizeof(struct ingrediente_in_ricetta)); ingr_ricetta->ingrediente_associato = ingrediente_ricetta; ingr_ricetta->quantita = quantita_ingrediente; return ingr_ricetta; } struct ricetta * crea_ricetta(const char *name) { struct ricetta * nuova_ricetta = malloc(sizeof(struct ricetta)); nuova_ricetta->nome_ricetta = strdup(name); nuova_ricetta->ingredienti_ricetta = NULL; nuova_ricetta->peso_ricetta = 0; nuova_ricetta->next = NULL; return nuova_ricetta; } struct lotto * crea_lotto(int quantita_lotto, int scadenza_lotto) { struct lotto * nuovo_lotto = malloc(sizeof(struct lotto)); nuovo_lotto->quantita = quantita_lotto; nuovo_lotto->scadenza = scadenza_lotto; nuovo_lotto->next = NULL; return nuovo_lotto; } struct ordine * crea_ordine(char * nome_ordine, int quantita_ordine, int tempo, struct ricetta * ricetta_ordine){ struct ordine * nuovo_ordine = malloc(sizeof(struct ordine)); nuovo_ordine->nome_ordine = strdup(nome_ordine); nuovo_ordine->quantita = quantita_ordine; nuovo_ordine->istante_di_tempo = tempo; nuovo_ordine->next = NULL; nuovo_ordine->ricetta_ordine = ricetta_ordine; nuovo_ordine->peso_ordine = ricetta_ordine->peso_ricetta * quantita_ordine; return nuovo_ordine; } struct ricetta * inserisci_ricetta(char *nome_ricetta, struct tabella_ricette *ricettario) { /* controllo se la ricetta è presente in tabella, in quel caso stampo ignorato e ritorno NULL altrimenti aggiungo la ricetta in testa alla lista */ if (ricettario->numero_elementi >= ricettario->size * 2 ) { resize_tabella_ricette(ricettario); } int index_hash = funzione_hash(nome_ricetta, ricettario->size); struct ricetta * ricetta_in_lista = ricettario->ricetta_in_tabella[index_hash]; int ricetta_presente = 0; while (ricetta_in_lista != NULL) { if (strcmp(ricetta_in_lista->nome_ricetta, nome_ricetta) == 0) { ricetta_presente = 1; } ricetta_in_lista = ricetta_in_lista->next; } if (ricetta_presente == 0) { // Se la ricetta non è presente la aggiungo struct ricetta * ricetta_nuova = crea_ricetta(nome_ricetta); ricetta_nuova->next = ricettario->ricetta_in_tabella[index_hash]; ricettario->ricetta_in_tabella[index_hash] = ricetta_nuova; ricettario->numero_elementi++; printf("aggiunta\n"); return ricetta_nuova; } else{ // se non è presente ritorno NULL printf("ignorato\n"); return NULL; } } void aggiungi_ingrediente(char *nome_ingrediente,int quantita_ingrediente, struct tabella_ingredienti * magazzino, struct ricetta * ricetta_associata) { /* calcolo il hash con il nome dell'ingrediente trovo l'ingrediente nel magazzino se non è presente lo aggiungo */ if (magazzino->numero_elementi >= magazzino->size * 2) { resize_tabella_ingredienti(magazzino); } int index_hash = funzione_hash(nome_ingrediente, magazzino->size); struct ingrediente * ingrediente_in_lista = magazzino->ingredienti_in_tabella[index_hash]; int uscita = 0; while (ingrediente_in_lista != NULL && uscita == 0) { if (strcmp(ingrediente_in_lista->nome_ingrediente, nome_ingrediente) == 0) { struct ingrediente_in_ricetta * ingrediente_in_ricetta = crea_ingrediente_in_ricetta(ingrediente_in_lista, quantita_ingrediente); ingrediente_in_ricetta->next = ricetta_associata->ingredienti_ricetta; ricetta_associata->ingredienti_ricetta = ingrediente_in_ricetta; ricetta_associata->peso_ricetta += quantita_ingrediente; uscita = 1; } else{ ingrediente_in_lista = ingrediente_in_lista->next; } } if (uscita == 0) { struct ingrediente * nuovo_ingrediente = crea_ingrediente(nome_ingrediente); nuovo_ingrediente->next = magazzino->ingredienti_in_tabella[index_hash]; magazzino->ingredienti_in_tabella[index_hash] = nuovo_ingrediente; magazzino->numero_elementi++; struct ingrediente_in_ricetta * i = crea_ingrediente_in_ricetta(nuovo_ingrediente, quantita_ingrediente); i->next = ricetta_associata->ingredienti_ricetta; ricetta_associata->ingredienti_ricetta = i; ricetta_associata->peso_ricetta += quantita_ingrediente; } } int controlla_ordini(char * nome){ struct ordine * l = ordini_pronti; while (l != NULL) { if (strcmp(l->nome_ordine, nome) == 0) { return 1; } l = l->next; } struct ordine * a = ordini_attesa; while (a != NULL) { if (strcmp(a->nome_ordine, nome) == 0) { return 1; } a = a->next; } return 0; } void elimina_ricetta(char *nome_ricetta, struct tabella_ricette *ricettario) { if (controlla_ordini(nome_ricetta) == 1) { printf("ordini in sospeso\n"); return; } unsigned long hash = funzione_hash(nome_ricetta, ricettario->size); struct ricetta * t = ricettario->ricetta_in_tabella[hash]; struct ricetta * prec = NULL; while (t != NULL) { if (strcmp(t->nome_ricetta, nome_ricetta) == 0) { if (prec == NULL) { ricettario->ricetta_in_tabella[hash] = t->next; } else { prec->next = t->next; } printf("rimossa\n"); ricettario->numero_elementi--; free(t->nome_ricetta); free(t); return; } prec = t; t = t->next; } printf("non presente\n"); return; } void elimina_lotti_utilizzati(struct ordine * ordine_ingrediente, int quantita_ordine) { /* controllo ogni ingrediente della ricetta associata all'ordine elimino i lotti utilizzati di ogni ingrediente aggiorno la quantita totale del lotto */ int quantita_parziale = 0; int quantita_utilizzata = 0; struct ingrediente_in_ricetta * i = ordine_ingrediente->ricetta_ordine->ingredienti_ricetta; while (i != NULL) { struct lotto * lotto_ingrediente = i->ingrediente_associato->lotto_ingrediente; quantita_parziale = lotto_ingrediente->quantita; quantita_utilizzata = i->quantita * quantita_ordine; while (quantita_parziale < quantita_utilizzata) { struct lotto * lotto_del = lotto_ingrediente; // aggiorno la lista di lotti i->ingrediente_associato->lotto_ingrediente = lotto_ingrediente->next; free(lotto_del); // la lista di lotti punta al successivo lotto_ingrediente = i->ingrediente_associato->lotto_ingrediente; quantita_parziale += lotto_ingrediente->quantita; } // l'ultimo lotto usato non l'ho elimino perchè può essere usato solo parzialmente lotto_ingrediente->quantita = quantita_parziale - quantita_utilizzata; // aggiorno quantita totale dei lotti sottraendo quelli utilizzati i->ingrediente_associato->quantita_totale_lotti -= quantita_utilizzata; // vado all'INGREDIENTE successivo i = i->next; } } /* void controlla_scadenze(struct ingrediente_in_ricetta ** ingrediente_r, int tempo){ struct lotto * l = (*ingrediente_r)->ingrediente_associato->lotto_ingrediente; while (l != NULL && l->scadenza <= tempo) { struct lotto * lotto_del = l; (*ingrediente_r)->ingrediente_associato->quantita_totale_lotti -= l->quantita; (*ingrediente_r)->ingrediente_associato->lotto_ingrediente = l->next; free(lotto_del); l = (*ingrediente_r)->ingrediente_associato->lotto_ingrediente; } } */ void scambio_ordini(struct ordine * ordine_da_scambiare){ /* aggiungo l'ordine proveniente dall'attesa nella lista dei pronti aggiungo in ordine di tempo d'inserimento */ struct ordine * p = ordini_pronti; struct ordine * precedente = NULL; if (ordini_pronti == NULL) { ordini_pronti = ordine_da_scambiare; coda_pronti = ordine_da_scambiare; } else{ while (p != NULL && p->istante_di_tempo < ordine_da_scambiare->istante_di_tempo) { precedente = p; p = p->next; } if (precedente == NULL) { ordine_da_scambiare->next = ordini_pronti; ordini_pronti = ordine_da_scambiare; } else{ // nel caso in cui l'ordine viene aggiunto alla coda aggiorno la coda della lista if (precedente->next == NULL) { coda_pronti = ordine_da_scambiare; } ordine_da_scambiare->next = precedente->next; precedente->next = ordine_da_scambiare; } } } void controlla_ordini_attesa(int istante_tempo) { struct ordine * a = ordini_attesa; struct ordine * prec = NULL; while (a != NULL) { struct ingrediente_in_ricetta * ingrediente_r = a->ricetta_ordine->ingredienti_ricetta; int scambio = 1; while (ingrediente_r != NULL && scambio == 1) { /* struct ingrediente_in_ricetta ** ingrediente_chek = malloc(sizeof(struct ingrediente_in_ricetta *)); *ingrediente_chek = ingrediente_r; struct lotto * l = ingrediente_r->ingrediente_associato->lotto_ingrediente; controlla_scadenze(ingrediente_chek, istante_tempo); */ struct lotto * lotto_ingrediente = ingrediente_r->ingrediente_associato->lotto_ingrediente; int ferma_scansione = 0; while (lotto_ingrediente != NULL && ferma_scansione == 0) { if (lotto_ingrediente->scadenza <= istante_tempo) { struct lotto * lotto_da_eliminare = lotto_ingrediente; // la lista dei lotti punta all'elemento successivo ingrediente_r->ingrediente_associato->lotto_ingrediente = lotto_ingrediente->next; // aggiorno la quantita totale dei lotti salvata nell'ingrediente in tabella ingrediente_r->ingrediente_associato->quantita_totale_lotti -= lotto_ingrediente->quantita; free(lotto_da_eliminare); //il lotto punta di nuovo a inizio della lista lotti associata all'ingrediente lotto_ingrediente = ingrediente_r->ingrediente_associato->lotto_ingrediente; } else{ // mi fermo appena trovo un lotto non scaduto (la lista dei lotti è in ordine di scadenza) ferma_scansione = 1; } } int quantita_necessarria = ingrediente_r->quantita * a->quantita; int quantita_totale_lotti = ingrediente_r->ingrediente_associato->quantita_totale_lotti; /* printf("%d", quantita_totale_lotti); printf(" necessaria : ") printf("%d", quantita_necessarria); printf("\n"); */ // se la quantita totale dei lotti è maggiore della quantità necessaria aggiorno if ( quantita_totale_lotti < quantita_necessarria) { // se non posso fare lo scambio mi fermo, mancano i lotti per un ingrediente scambio = 0; } else { // se i lotti per quel inigrediente sono sufficienti controllo i successivi ingrediente_r = ingrediente_r->next; } } if (scambio == 1) { elimina_lotti_utilizzati(a, a->quantita); if (prec == NULL) { ordini_attesa = a->next; a->next = NULL; scambio_ordini(a); a = ordini_attesa; } else { if (a->next == NULL) // se a è l'ultimo oggetto aggiorno la coda dell'attesa { coda_attesa = prec; } prec->next = a->next; struct ordine *successivo = a->next; // mi serve salvare l'elemento successivo per continuare lo scan a->next = NULL; scambio_ordini(a); a = successivo; } } else { // in questo caso vado avanti normalmente prec = a; a = a->next; } } } void aggiungi_lotto(char * nome_lotto, int quantita_lotto, int scadenza_lotto, struct tabella_ingredienti * magazzino) { if (magazzino->numero_elementi >= magazzino->size * 2) { resize_tabella_ingredienti(magazzino); } struct lotto * nuovo_lotto = crea_lotto(quantita_lotto, scadenza_lotto); int index_hash = funzione_hash(nome_lotto, magazzino->size); struct ingrediente *i = magazzino->ingredienti_in_tabella[index_hash]; while (i != NULL) { if (strcmp(i->nome_ingrediente, nome_lotto) == 0) { struct lotto * lotto_temp = i->lotto_ingrediente; struct lotto *prec = NULL; while (lotto_temp != NULL && lotto_temp->scadenza < scadenza_lotto) // possibile modifica { prec = lotto_temp; lotto_temp = lotto_temp->next; } if (prec == NULL) { nuovo_lotto->next = lotto_temp; i->lotto_ingrediente = nuovo_lotto; } else { nuovo_lotto->next = lotto_temp; prec->next = nuovo_lotto; } i->quantita_totale_lotti += quantita_lotto; return; } i = i->next; } // se viene effettuato un rifornimento di un ingrediente non ancora preseente in nessuna ricetta // lo aggiungo in testa alla lista struct ingrediente * nuovo_ingrediente_da_rifornimento = crea_ingrediente(nome_lotto); nuovo_ingrediente_da_rifornimento->lotto_ingrediente = nuovo_lotto; nuovo_ingrediente_da_rifornimento->next = magazzino->ingredienti_in_tabella[index_hash]; magazzino->ingredienti_in_tabella[index_hash] = nuovo_ingrediente_da_rifornimento; magazzino->numero_elementi++; } void gestione_ordine(char *nome_ordine, int quantita_ordine, int tempo, struct tabella_ricette * ricettario) { int index_hash = funzione_hash(nome_ordine, ricettario->size); int ingrediente_trovato = 0; struct ricetta * r = ricettario->ricetta_in_tabella[index_hash]; while (r != NULL && ingrediente_trovato == 0) { if (strcmp(r->nome_ricetta, nome_ordine) == 0) { ingrediente_trovato = 1; struct ordine * nuovo_ordine = crea_ordine(nome_ordine, quantita_ordine, tempo, r); int ordine_in_attesa = 0; struct ingrediente_in_ricetta * ingrediente_r = r->ingredienti_ricetta; while (ingrediente_r != NULL && ordine_in_attesa == 0) { /* struct ingrediente_in_ricetta ** ingrediente_chek = malloc(sizeof(struct ingrediente_in_ricetta *)); *ingrediente_chek = ingrediente_r; controlla_scadenze(ingrediente_chek, tempo); */ struct lotto * lotto_ingrediente = ingrediente_r->ingrediente_associato->lotto_ingrediente; int ferma_scansione = 0; while (lotto_ingrediente != NULL && ferma_scansione == 0) { if (lotto_ingrediente->scadenza <= tempo) { // la lista dei lotti punta all'elemento successivo ingrediente_r->ingrediente_associato->lotto_ingrediente = lotto_ingrediente->next; // agiorno la quantità totale dei lotti di quel ingrediente ingrediente_r->ingrediente_associato->quantita_totale_lotti -= lotto_ingrediente->quantita; // elimino il lotto scaduto struct lotto * lotto_da_eliminare = lotto_ingrediente; free(lotto_da_eliminare); lotto_ingrediente = ingrediente_r->ingrediente_associato->lotto_ingrediente; } else{ // mi fermo appena trovo un lotto non scaduto (la lista dei lotti è in ordine di scadenza) ferma_scansione = 1; } } int quantita_necessarria = ingrediente_r->quantita * quantita_ordine; int quantita_totale_lotti = ingrediente_r->ingrediente_associato->quantita_totale_lotti; /* printf("%d", quantita_totale_lotti); printf(" necessaria : ") printf("%d", quantita_necessarria); printf("\n"); */ if (quantita_totale_lotti < quantita_necessarria) { // se devo mettere l'ordine in attesa mi fermo con la scansione ordine_in_attesa = 1; } else { ingrediente_r = ingrediente_r->next; } } if (ordine_in_attesa == 1) { // aggingo l'ordine in attesa if (ordini_attesa == NULL) { ordini_attesa = nuovo_ordine; coda_attesa = nuovo_ordine; } else{ if (coda_attesa != NULL) { coda_attesa->next = nuovo_ordine; coda_attesa = nuovo_ordine; } } } else { // aggiungo l'ordine in pronti if (ordini_pronti == NULL) { ordini_pronti = nuovo_ordine; coda_pronti = nuovo_ordine; } else{ if (coda_pronti != NULL) { coda_pronti->next = nuovo_ordine; coda_pronti = nuovo_ordine; } } elimina_lotti_utilizzati(nuovo_ordine, quantita_ordine); } printf("accettato\n"); } else{ r = r->next; } } if (ingrediente_trovato == 0) { printf("rifiutato\n"); } } void gestione_corriere(int capienza) { /* printf("prova visione ordini pronti in lista : ") struct ordine * o = ordini_pronti; while (o!=NULL) { printf("%s", o->nome_ordine); printf(" "); o = o->next; } */ /* controllo gli ordini in attesa e la capienza del camioncino aggiungo nella lista del camioncino in ordine di peso se supero la capienza esco dal while */ struct ordine * p = ordini_pronti; int quantita_parziale = p->peso_ordine; while (p!=NULL && quantita_parziale <= capienza) { if (camioncino == NULL) { ordini_pronti = p->next; // aggiorno la lista dei pronti p->next = NULL; camioncino = p; // inserisco in camioncino p = ordini_pronti; } else { // inserisco in ordine di peso, quindi trovo la posizione in lista struct ordine * ord_camioncino = camioncino; struct ordine * precedente = NULL; while (ord_camioncino != NULL && ord_camioncino->peso_ordine >= p->peso_ordine) // metto >= perchè se sono uguali inserisco in ordine di inserimento dell'ordine { precedente = ord_camioncino; ord_camioncino = ord_camioncino->next; } if (precedente == NULL) { ordini_pronti = p->next; p->next = camioncino; camioncino = p; } else{ ordini_pronti = p->next; p->next = precedente->next; precedente->next = p; } p = ordini_pronti; } if (p!=NULL) { quantita_parziale += p->peso_ordine; } } if (camioncino == NULL) { printf("camioncino vuoto\n"); } else{ while (camioncino != NULL) { printf("%d", camioncino->istante_di_tempo); printf(" "); printf("%s", camioncino->ricetta_ordine->nome_ricetta); printf(" "); printf("%d", camioncino->quantita); printf("\n"); // svuoto il camioncino struct ordine * corrente = camioncino; camioncino = camioncino->next; free(corrente); } if (camioncino != NULL) { camioncino = NULL; } } } int main(int argc, char const *argv[]) { char *BUFFER = malloc(BUFFER_SIZE * sizeof(char)); // questa è una riga char *richiesta = NULL; int periodo = 0, capienza = 0; int tempo = 0; struct tabella_ricette *ricettario = crea_ricettario(); struct tabella_ingredienti *magazzino = crea_magazzino(); // printf("INIZIO \n"); if (fgets(BUFFER, BUFFER_SIZE, stdin)) // lettura periodo e capienza { periodo = atoi(strtok(BUFFER, " \n")); capienza = atoi(strtok(NULL, " \n")); } while (fgets(BUFFER, BUFFER_SIZE, stdin)) // fgets(comando, 800, fp) { richiesta = strtok(BUFFER, " \n"); if (strcmp(richiesta, "aggiungi_ricetta") == 0) { char *nome_ricetta = strtok(NULL, " \n"); struct ricetta * ricetta_letta = inserisci_ricetta(nome_ricetta, ricettario); // se la ricetta è null stampo ignorato e non aggiungo ingredienti if (ricetta_letta != NULL) { char *nome_ingrediente = strtok(NULL, " \n"); while (nome_ingrediente != NULL) { int quantita_ingrediente = atoi(strtok(NULL, " \n")); aggiungi_ingrediente(nome_ingrediente, quantita_ingrediente, magazzino, ricetta_letta); nome_ingrediente = strtok(NULL, " \n"); } } } if (strcmp(richiesta, "rifornimento") == 0) { char *nomeLotto = strtok(NULL, " \n"); while (nomeLotto != NULL) { int quantita_lotto = atoi(strtok(NULL, " \n")); int scadenza = atoi(strtok(NULL, " \n")); aggiungi_lotto(nomeLotto, quantita_lotto, scadenza, magazzino); nomeLotto = strtok(NULL, " \n"); } controlla_ordini_attesa(tempo); printf("rifornito\n"); } if (strcmp(richiesta, "ordine") == 0) { char *nomeOrdine = strtok(NULL, " \n"); int a = atoi(strtok(NULL, " ")); gestione_ordine(nomeOrdine, a, tempo, ricettario); } if (strcmp(richiesta, "rimuovi_ricetta") == 0) { char *nome_ricetta = strtok(NULL, " \n"); elimina_ricetta(nome_ricetta, ricettario); } tempo += 1; if (((tempo%periodo) == 0)) { gestione_corriere(capienza); } } return 0; }
Leave a Comment