Untitled
unknown
plain_text
14 days ago
30 kB
3
Indexable
Never
#include <stdio.h> #include <stdlib.h> #include <string.h> #include <stdbool.h> #include <time.h> #define BUFFER_SIZE 4999 #define SIZE_TABELLA_INIZIALE 1024 struct lotto { char *nome_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 struct ordine *next; }; struct ricetta **ricetta_in_tabella = NULL; int size_ricettario; struct ingrediente **ingredienti_in_tabella = NULL; int size_magazzino; int numero_elementi_magazzino; int numero_elementi_ricettario; struct ordine *ordini_pronti = NULL; struct ordine *coda_pronti = NULL; struct ordine *ordini_attesa = NULL; struct ordine *coda_attesa = NULL; struct ordine *camioncino = NULL; unsigned long funzione_hash(const char *chiave, int size) // funzione hash sdbm { unsigned long hash = 0; int c; while ((c = *chiave++)) { hash = c + (hash << 6) + (hash << 16) - hash; } return hash % size; } void resize_tabella_ricette() { int new_size = size_ricettario * 2; struct ricetta **copia_ricette = calloc(new_size, sizeof(struct ricetta *)); for (int i = 0; i < size_ricettario; i++) { struct ricetta *nodo = 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(ricetta_in_tabella); ricetta_in_tabella = copia_ricette; size_ricettario = new_size; } void resize_tabella_ingredienti() { int new_size = size_magazzino * 2; struct ingrediente **copia_ingredienti = calloc(new_size, sizeof(struct ingrdiente *)); for (int i = 0; i < size_magazzino; i++) { struct ingrediente *nodo = 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(ingredienti_in_tabella); ingredienti_in_tabella = copia_ingredienti; size_magazzino = new_size; } 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(char * nome_lotto, int quantita_lotto, int scadenza_lotto) { struct lotto *nuovo_lotto = malloc(sizeof(struct lotto)); nuovo_lotto->nome_lotto = strdup(nome_lotto); nuovo_lotto->quantita = quantita_lotto; nuovo_lotto->scadenza = scadenza_lotto; nuovo_lotto->next = NULL; return nuovo_lotto; } struct ingrediente *crea_ingrediente(char *nome) { struct ingrediente *nuovo_ingrediente = malloc(sizeof(struct ingrediente)); nuovo_ingrediente->nome_ingrediente = strdup(nome); nuovo_ingrediente->quantita_totale_lotti = 0; nuovo_ingrediente->next = NULL; nuovo_ingrediente->lotto_ingrediente = NULL; 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; // ingr_ricetta->nome_ingrediente = strdup(ingrediente_ricetta->nome_ingrediente); return ingr_ricetta; } 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; return nuovo_ordine; } struct ricetta *inserisci_ricetta(char *nome_ricetta) { /* controllo se la ricetta è presente in tabella, in quel caso stampo ignorato e ritorno NULL altrimenti aggiungo la ricetta in testa alla lista */ int index_hash = funzione_hash(nome_ricetta, size_ricettario); struct ricetta *ricetta_in_lista = 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 = ricetta_in_tabella[index_hash]; ricetta_in_tabella[index_hash] = ricetta_nuova; numero_elementi_ricettario++; if (numero_elementi_ricettario >= size_ricettario * 2) { resize_tabella_ricette(); } 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 ricetta *ricetta_associata) { /* calcolo il hash con il nome dell'ingrediente trovo l'ingrediente nel magazzino se non è presente lo aggiungo */ int index_hash = funzione_hash(nome_ingrediente, size_magazzino); struct ingrediente *ingrediente_in_lista = 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) { // printf("aggiungo nuovo ingrediente da aggiungi_ingrediente "); struct ingrediente *nuovo_ingrediente = crea_ingrediente(nome_ingrediente); nuovo_ingrediente->next = ingredienti_in_tabella[index_hash]; ingredienti_in_tabella[index_hash] = nuovo_ingrediente; numero_elementi_magazzino++; if (numero_elementi_magazzino >= size_magazzino * 2) // { resize_tabella_ingredienti(); } 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) { if (controlla_ordini(nome_ricetta) == 1) { printf("ordini in sospeso\n"); return; } unsigned long hash = funzione_hash(nome_ricetta, size_ricettario); struct ricetta *t = ricetta_in_tabella[hash]; struct ricetta *prec = NULL; while (t != NULL) { if (strcmp(t->nome_ricetta, nome_ricetta) == 0) { if (prec == NULL) { ricetta_in_tabella[hash] = t->next; } else { prec->next = t->next; } printf("rimossa\n"); numero_elementi_ricettario--; free(t->nome_ricetta); free(t); return; } prec = t; t = t->next; } printf("non presente\n"); return; } bool cerca_ingrediente_magazzino(char * nome_lotto){ bool ingrediente_trovato = 0; int index_hash = funzione_hash(nome_lotto, size_magazzino); struct ingrediente *i = ingredienti_in_tabella[index_hash]; while (i != NULL) { if (strcmp(i->nome_ingrediente, nome_lotto) == 0) { ingrediente_trovato = 1; break; } i = i->next; } return ingrediente_trovato; } void aggiungi_lotto(char *nome_lotto, int quantita_lotto, int scadenza_lotto) { struct lotto *nuovo_lotto = crea_lotto(nome_lotto,quantita_lotto, scadenza_lotto); int index_hash = funzione_hash(nome_lotto, size_magazzino); if (cerca_ingrediente_magazzino(nome_lotto) == 1) { struct ingrediente *ingrediente_associato = ingredienti_in_tabella[index_hash]; struct lotto *lotto_temp = ingrediente_associato->lotto_ingrediente; struct lotto *prec = NULL; while (lotto_temp != NULL) { if (lotto_temp->scadenza > scadenza_lotto) { break; } else{ prec = lotto_temp; lotto_temp = lotto_temp->next; } } if (prec == NULL) { nuovo_lotto->next = lotto_temp; ingrediente_associato->lotto_ingrediente = nuovo_lotto; } else { nuovo_lotto->next = lotto_temp; prec->next = nuovo_lotto; } ingrediente_associato->quantita_totale_lotti += quantita_lotto; } else{ // 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 = ingredienti_in_tabella[index_hash]; ingredienti_in_tabella[index_hash] = nuovo_ingrediente_da_rifornimento; numero_elementi_magazzino++; if (numero_elementi_magazzino >= size_magazzino * 2) { resize_tabella_ingredienti(); } } } 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->nome_lotto); 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 gestione_ordine(char *nome_ordine, int quantita_ordine, int tempo) { int index_hash = funzione_hash(nome_ordine, size_ricettario); int ingrediente_trovato = 0; struct ricetta *r = 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); struct ingrediente_in_ricetta *ingrediente_r = r->ingredienti_ricetta; while (ingrediente_r != NULL) { /* 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; while (lotto_ingrediente != NULL) { if (lotto_ingrediente->scadenza <= 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; // agiorno la quantità totale dei lotti di quel ingrediente ingrediente_r->ingrediente_associato->quantita_totale_lotti -= lotto_ingrediente->quantita; // elimino il lotto scaduto 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) break; } } 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 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; } } break; } else { ingrediente_r = ingrediente_r->next; // controllo se è l'ultimo ingrediente, in quel caso lo metto in pronti if (ingrediente_r == NULL) { 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 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; while (ingrediente_r != NULL) { /* 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; while (lotto_ingrediente != NULL) { 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) break; } } 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 prec = a; a = a->next; break; } else { // se i lotti per quel inigrediente sono sufficienti controllo i successivi ingrediente_r = ingrediente_r->next; if (ingrediente_r == NULL) { elimina_lotti_utilizzati(a, a->quantita); struct ordine * ordine_da_aggiungere = crea_ordine(a->nome_ordine, a->quantita, a->istante_di_tempo, a->ricetta_ordine); if (prec == NULL) { ordini_attesa = a->next; scambio_ordini(ordine_da_aggiungere); 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; scambio_ordini(ordine_da_aggiungere); a = a->next; } } } } } } int calcola_peso_ordine(struct ordine * ordine){ int peso_ordine = 0; struct ingrediente_in_ricetta * testa_ingredienti = ordine->ricetta_ordine->ingredienti_ricetta; while (testa_ingredienti != NULL) { peso_ordine += testa_ingredienti->quantita * ordine->quantita; } return peso_ordine; } void stampa_camioncino(); void gestione_corriere(int capienza) { struct ordine *p = ordini_pronti; int quantita_parziale = 0; /* 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 * o = ordini_pronti; while (o!=NULL) { printf("%s", o->nome_ordine); printf(" "); o = o->next; } */ while (p != NULL) { quantita_parziale += (p->ricetta_ordine->peso_ricetta) * p->quantita; if (quantita_parziale > capienza) { break; } else { // aggiungo ordine nel camioncino. L' eliminazione poi degli ordini del camioncino vengo fatti dopo aver stampato if (camioncino == NULL) { ordini_pronti = p->next; p->next = NULL; camioncino = p; p = ordini_pronti; } else { // inserisco in ordine di peso, quindi trovo la posizione in lista struct ordine *ord_camioncino = camioncino; struct ordine *precedente = NULL; int peso_da_aggiungere = ord_camioncino->ricetta_ordine->peso_ricetta * ord_camioncino->quantita ; int peso_p = p->ricetta_ordine->peso_ricetta * p->quantita; while (ord_camioncino != NULL && peso_da_aggiungere >= peso_p) // metto >= perchè se sono uguali inserisco in ordine di inserimento dell'ordine { precedente = ord_camioncino; ord_camioncino = ord_camioncino->next; if (ord_camioncino != NULL) { peso_da_aggiungere = ord_camioncino->ricetta_ordine->peso_ricetta * ord_camioncino->quantita; } } 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; } } } stampa_camioncino(); } void stampa_camioncino(){ 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); } } } int main(int argc, char const *argv[]) { FILE * f = stdin; char *BUFFER = malloc(BUFFER_SIZE * sizeof(char)); // questa è una riga char *richiesta = NULL; int periodo = 0, capienza = 0; int tempo = 0; numero_elementi_ricettario = 0; ricetta_in_tabella = calloc(SIZE_TABELLA_INIZIALE, sizeof(struct ricetta *)); size_ricettario = SIZE_TABELLA_INIZIALE; numero_elementi_magazzino = 0; ingredienti_in_tabella = calloc(SIZE_TABELLA_INIZIALE, sizeof(struct tabella_ingredienti *)); size_magazzino = SIZE_TABELLA_INIZIALE; // printf("INIZIO \n"); if (fgets(BUFFER, BUFFER_SIZE, f)) // lettura periodo e capienza { periodo = atoi(strtok(BUFFER, " \n")); capienza = atoi(strtok(NULL, " \n")); // printf("%d", periodo); printf("%d", capienza); } while (fgets(BUFFER, BUFFER_SIZE, f)) // 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); // 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, ricetta_letta); nome_ingrediente = strtok(NULL, " \n"); } } } else 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); nomeLotto = strtok(NULL, " \n"); } controlla_ordini_attesa(tempo); printf("rifornito\n"); } else if (strcmp(richiesta, "ordine") == 0){ char *nomeOrdine = strtok(NULL, " \n"); int a = atoi(strtok(NULL, " ")); gestione_ordine(nomeOrdine, a, tempo); } else if (strcmp(richiesta, "rimuovi_ricetta") == 0){ char *nome_ricetta = strtok(NULL, " \n"); elimina_ricetta(nome_ricetta); } tempo += 1; if (((tempo % periodo) == 0)) { gestione_corriere(capienza); } } return 0; }
Leave a Comment