Newsgroup: it.comp.lang.c
Titolo: Esercizio

ciao, ho provato a fare questo esercizio:
*******************************************
Banco degli yogurt
 
Si consideri un archivio di yogurt contenente 100 tipi conservato in un 
archivio Y:
Codice numerico del tipo (progressivo univoco da 1 a 100)
Peso della confezione
Numero totale di pezzi
 
Esiste un supermercato che li vende ed ha il suo archivio del magazzino 
S di MAX 1.000 degli yogurt arrivati:
Codice numerico del modello (lo stesso dell'archivio S)
Prezzo di vendita unitario
Scadenza (intero)
Numero pezzi arrivati di questo modelli
 
N.B.: di un tipo possono arrivare anche 2 stock con differente numero di 
pezzi
 
ESERCIZIO BASE
 
Scrivere in C un programma che:
1) Legge da tastiera le informazioni relative ai 100 tipi di yogurt 
mettendo il numero totale dei pezzi a 0.
2) Chiama una funzione "magazzino" che legge da tastiera, in ordine 
casuale, e li inserisce nell'archivio del magazzino, fino a che l’utente 
conferma.
3) Chiama una funzione "aggiorna" che aggiorna il numero totale di pezzi 
arrivati nel supermercato nell'archivio degli yogurt Y.
4) Chiama una funzione “pezzi” che dato un codice restituisce tutti gli 
yogurt presenti nell’archivio (in base al codice con quel codice 
articolo con il relativo prezzo al KG.
5) Chiama una funzione "ordina" che ordina l’archivio S in base al 
codice dello yogurt ed alla data di scadenza e rende il valore totale 
degli yogurt presenti in quel supermercato.
**********************************************
Sotto il codice. Funziona tutto tranne l'ultima funzione di ordinamento 
che in effetti ho "elaborato" io anzichè utilizzare un algoritmo noto.
E' corretta un'assegnazione di questo tipo? tmp=m[j], o bisogna 
eguagliare campo per campo della struct?
 
La dichiarazione della struct Y andava fatta così? parlo del primo campo 
"yogurt y;" .
Sicuramente l'efficienza lascerà a desiderare, ma volevo capire se avevo 
fatto errori, anche di comprensione del testo.
Grazie a chi avrà la pazienza di annoiarsi dando un'occhiata
 
 
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
 
#define Ymax 100
#define Smax 1000
 
struct Y {
        int codice_tipo;
        float peso_confezione;
        int numero_pezzi;};
typedef struct Y yogurt;
 
struct S {
        yogurt y;
        float prezzo_unitario;
        int scadenza;
        int num_pezzi;};
typedef struct S supermercato;
 
void leggi(yogurt y[]);
int magazzino(supermercato m[]);
void aggiorna(yogurt y[],supermercato m[],int num_confezioni_totali);
void pezzi(yogurt y[],supermercato m[]);
void ordina(supermercato m[]);
 
int main() {
     yogurt y[Ymax];
     supermercato m[Smax];
     int num_confezioni_totali;
     leggi(y);
     num_confezioni_totali=magazzino(m);
     aggiorna(y,m,num_confezioni_totali);
     pezzi(y,m);
     ordina(m);
     system("PAUSE");
     return 0;
}
 
void leggi(yogurt y[]) {
      int i;
      for(i=0;i<Ymax;i++) {
          printf("inserisci il peso del tipo di yogurt N.ro %d\n",i+1);
          y[i].codice_tipo=i+1;
          scanf("%f",&y[i].peso_confezione);
          y[i].numero_pezzi=0;
          }
}
 
int magazzino(supermercato m[]) {
      int i=0;
      int done;
      int num_confezioni_totali=0;
      char conferma[3];
      do {
         printf("Devi inserire schede? Digita SI per confermare\n");
         scanf("%s",conferma);
         if(strcmp(conferma,"SI")==0) {
            printf("Inserisci codice,prezzo, scadenza e num pezzi della 
scheda N.ro %d\n",i+1);
             scanf("%d",&m[i].y.codice_tipo);
              scanf("%f",&m[i].prezzo_unitario);
               scanf("%d",&m[i].scadenza);
                scanf("%d",&m[i].num_pezzi);
                 num_confezioni_totali++;
                 i++;
                 done=1;}
          else if(strcmp(conferma,"SI")!=0) done = 0;
         } while(done==1);
       return num_confezioni_totali;
}
 
 
void aggiorna(yogurt y[],supermercato m[],int num_confezioni_totali) {
      int i,j;
      for(i=0;i<num_confezioni_totali;i++)
          for(j=0;j<Ymax;j++)
              if(m[i].y.codice_tipo==j+1) y[j].numero_pezzi+=m[i].num_pezzi;
}
 
void pezzi(yogurt y[],supermercato m[]) {
      int codice;
      int i;
      int j=0;
      printf("Inserisci il codice del prodotto di cui si vuole totale e 
prezzo\n");
      scanf("%d",&codice);
      for(i=0;i<Ymax;i++)
          if(codice==y[i].codice_tipo)
                   printf("Sono presenti %d pezzi e ",y[i].numero_pezzi);
      while(j<Smax) {
                   if(m[j].y.codice_tipo==codice)
                       {printf("il prezzo al kg è %f\n", 
m[j].prezzo_unitario);
                        break;}
                    j++;}
}
 
 
void ordina(supermercato m[]) {
      int i,j,totale_yogurt=0;
      supermercato tmp;
       for(i=0;i<Smax;i++)
          totale_yogurt+=m[i].num_pezzi;
      printf("Il numero totale di yogurt è: %d\n", totale_yogurt);
      for(i=0;i<Smax;i++)
          for(j=0;j<Smax;j++)
              if(m[j].y.codice_tipo>m[j+1].y.codice_tipo)
                 {tmp=m[j];
                  m[j]=m[j+1];
                  m[j+1]=tmp;}
               if(m[j].y.codice_tipo==m[j+1].y.codice_tipo && 
m[j].scadenza>m[j+1].scadenza)
                 {tmp=m[j];
                  m[j]=m[j+1];
                  m[j+1]=tmp;}
}

 degli yogurt presenti in quel supermercato.
 
Qui l'espressione "numero totale di pezzi" è usata in modo totalmente
differente rispetto a come è stata usata sopra credo. Non credo di aver
capito.. esiste una traccia originale di questo esercizio?
Se ti è stato assegnato a scuola chiedi delucidazioni all'insegnante.
Lo sforzo dovrebbe essere concentrato nell'implementazione della soluzione,
non nell'interpretazione di un problema formulato in maniera (a dir poco)
oscena.
 
-- 
Vincenzo Mercuri

 esiste una traccia originale di questo esercizio?
 
ciao,
anche se sono completamente inesperto e alle primissime armi ho avuto 
circa i tuoi stessi dubbi leggendo il testo.
Ho provato comunque a interpretarlo e a scrivere il codice, per motivi 
che non sto a dirti non ho possibilità di chiedere lumi al professore, 
comunque ti posto il testo completo e a seguire un altro testo, sono 
tutti abbastanza simili, almeno come tipologia (sono testi da esame).
 
 
************************************
Banco degli yogurt
 
Si consideri un archivio di yogurt contenente 100 tipi conservato in un 
archivio Y:
Codice numerico del tipo (progressivo univoco da 1 a 100)
Peso della confezione
Numero totale di pezzi
 
Esiste un supermercato che li vende ed ha il suo archivio del magazzino 
S di MAX 1.000 degli yogurt arrivati:
Codice numerico del modello (lo stesso dell'archivio S)
Prezzo di vendita unitario
Scadenza (intero)
Numero pezzi arrivati di questo modelli
 
N.B.: di un tipo possono arrivare anche 2 stock con differente numero di 
pezzi
 
ESERCIZIO BASE
 
Scrivere in C un programma che:
1) Legge da tastiera le informazioni relative ai 100 tipi di yogurt 
mettendo il numero totale dei pezzi a 0.
2) Chiama una funzione "magazzino" che legge da tastiera, in ordine 
casuale, e li inserisce nell'archivio del magazzino, fino a che l’utente 
conferma.
3) Chiama una funzione "aggiorna" che aggiorna il numero totale di pezzi 
arrivati nel supermercato nell'archivio degli yogurt Y.
4) Chiama una funzione “pezzi” che dato un codice restituisce tutti gli 
yogurt presenti nell’archivio (in base al codice con quel codice 
articolo con il relativo prezzo al KG.
5) Chiama una funzione "ordina" che ordina l’archivio S in base al 
codice dello yogurt ed alla data di scadenza e rende il valore totale 
degli yogurt presenti in quel supermercato.
 
 
ESERCIZIO  1
 
Inserire nel programma una funzione “Merce” che crea un vettore con solo 
i pezzi del magazzino S con valore della data di scadenza minore di un 
intero k letto da tastiera.
 
ESERCIZIO  2
 
Scrivere una funzione che costruisce 2 liste (L1 ed L2) contenenti 
rispettivamente tutti i tipi presenti nel magazzino S con prezzo 
superiore a 100 e minore di 100.
 
NB: le variabili usate devono essere locali e non è necessario 
controllare la correttezza dei dati in input.
********************************************
 
Prenotazione alberghi
 
Si considerino due alberghi A e B con 100 stanze ognuno e ciascuna 
stanza caratterizzata da: numero di stanza (progressivo da 1 a 200), 
numero di posti letto, bagno (1=SI 0=NO), prezzo, se occupate (le stanze 
possono essere occupate dai clienti od a prezzo pieno oppure con lo 
sconto (30%) se date ad un numero di persone inferiore al numero di 
posti letto ad esempio in uso singola la doppia) (2=sconto 1=occupata 
0=libera, all’inizio saranno tutte 0).
Esiste un archivio delle prenotazioni P per il fine settimana (Max 100), 
dove sono memorizzati: il numero progressivo della prenotazione, il 
numero di posti letto, se con bagno (1=SI 0=NO –1=meglio SI ma anche NO) 
ed il numero della stanza assegnata (se non è stata assegnata la stanza 
assegnare 0, all’inizio saranno tutte 0).
 
 
ESERCIZIO BASE
 
Scrivere in C un programma che:
1) Legge da tastiera, anche attraverso funzioni, tutti i dati delle 
stanze dei 2 alberghi e li mette nelle strutture dati A e B (tutti come 
liberi) e l'archivio delle prenotazioni P (Max 200) e le mette in una 
struttura dati P, finché vengono inseriti dall’utente (chiedere se vuole 
continuare).
2) Chiama una funzione “vendi”, prima per A poi per B) che scorre 
l'archivio delle prenotazioni e se ci sono stanze libere con le stesse 
caratteristiche richieste nella prenotazione (dare stanza anche solo se 
meglio SI), vengano registrati sia in A che in B che in P la vendita e 
l'acquisto e rende il numero di stanze rimaste libere in ciascun hotel.
3) Se ci sono stanze libere in A od in B e chiama una funzione “altre” 
che scorre l’archivio delle prenotazioni e le assegna a chi ha richiesto 
meglio SI, ma anche NO per il bagno ed in un secondo giro riscorre la 
lista ed assegna le stanze con lo sconto se ci sono stanze libere con un 
numero maggiore di posti letto rispetto a quanto richiesto.
4) Chiama una funzione “guadagno” che calcola il valore totale delle 
stanze affittate, il valore delle stanze rimaste libere ed il minor 
guadagno derivante dal totale degli sconti fatti e li rende al main.
 
 
ESERCIZIO  1
Inserire nel programma una funzione lastminute che crea 1 vettore V 
ordinato per prezzo contenente tutti i dati delle stanze rimaste libere 
con il prezzo ridotto al 50%.
 
ESERCIZIO  2
Scrivere una funzione che costruisce 1 lista delle prenotazioni 
(contenente codice prenotazione e numero di stanza assegnato) di chi 
aveva chiesto il bagno non obbligatorio (-1) e si è dovuto accontentare 
della stanza senza di esso.


 
Premesso che questo non è neanche italiano, rivisitiamo il problema.
Il mio dubbio era la distinzione tra singolo yogurt e confezione (cioè
insieme di yogurt). La frase "si consideri un archivio di yogurt..
conservato in un archivio Y" è orrenda. Facciamo così: questo archivio di
cui parla facciamo finta che sia un insieme di yogurt di quelli grandi,
quindi il singolo yogurt coincide con la confezione. Il numero di pezzi
lo interpretiamo come numero di yogurt dello stesso tipo, all'interno di
questo insieme (archivio, come lo chiama il testo). Così l'avevi 
interpretato tu.
Quindi scriviamo:
 
     typedef struct {
         int cod_tipo;
         int num_pezzi;
         float peso;
     } Yogurt; /* confezione nell'archivio iniziale */
 
     typedef struct {
         int cod_archivio;
         int scadenza;
         int num_pezzi;
         float prezzo;
         Yogurt y;
     } Yogurt_in_Stock; /* confezione nell'archivio in magazzino */
 
Quando ti parla di archivio Y e archivio S, ho come il sospetto
che non si tratti di strutture, ma array di strutture. Quindi:
 
#define NUMERO_TIPI 100
#define CAPIENZA_MAGAZZINO 1000
 
typedef Yogurt Y[NUMERO_TIPI];
typedef Yogurt_in_Stock S[CAPIENZA_MAGAZZINO];
 
void leggi(Y archivio_yogurt);
 
int main(void)
{
     Y archivio_yogurt = {0};
     S archivio_magazzino = {0};
     leggi(archivio_yogurt);
     /*...*/
     return 0;
}
 
void leggi(Y archivio_yogurt)
{
     int i;
     for(i = 0; i < NUMERO_TIPI; i++) {
         printf("Inserisci il peso della "
                "confezione di tipo N. %d: ", i + 1);
         archivio_yogurt[i].cod_tipo = i + 1;
         scanf("%f", &archivio_yogurt[i].peso);
     }
}
 
..qualcosa del genere. Partirei quindi da questi dati. Perdonami se non
ho tempo di andare oltre, comunque nel codice che avevi scritto ci sono
un po' di errori. Per esempio quando usi la variabile "done" per control-
lare il ciclo while, dovresti prima inizializzarla a 0 (valore logico
"false"). Altrimenti, essendo una variabile locale potrebbe assumere un
valore privo di significato (non come le variabili globali inizializzate
automaticamente a 0). Quindi il valore logico di "done" potrebbe essere
"true" a differenza di quanto ti aspetti. Sempre nellostesso frammento
poi fai eseguire il ciclo while (done==1), cioè ripeti il ciclo se "done"
(in italiano "fatto") è vera. Se hai finito, a rigor di logica, non
dovresti ripetere. Questo e altre cose, ma ti conviene ripensare al
programma sulla base delle nuove strutture dati.
 
-- 
Vincenzo Mercuri


si, condivido il modo di definire le strutture dati, anche io volevo 
fare un array di struct ma mi sono incasinato.
Non ho però ben capito perchè hai definito così la seconda struct, 
mettendoci dentro anche una Yogurt y.
 
Grazie ciao
 
 
 

 
 
Da qui in poi mi sono completamente perso...
 
:(
 
 
Sono stato completamente inutile, ma faccio "post" solo perché ho scritto
fin'ora, spero in qualche delucidazione sull'esercizio!
 
Ciao!


 
Eheh, come no :) appena ho letto il testo mi ï¿½ venuto in mente
il mio professore di Fondamenti di Informatica, ricordo che
aveva preconfezionato dei temi d'esame simili.. la vera sfida
era interpretare il testo.. a ingegneria facevano giï¿½ una prima
selezione in questo modo (ciao comunque, da un po' che non ci si
ritrova su iclc).
 
-- 
Vincenzo Mercuri


Perchè uno yogurt nel magazzino è pur sempre uno yogurt, a cui quindi
sarà associato il tipo (sempre da 1 a 100), peso della confezione e il
numero di pezzi nell'archivio Y originale. Però lì non ho capito neanche
io molto.. questo fa parte ancora della parte incomprensibile del
problema.. il num_pezzi del primo archivio in effetti si puo' benissimo
omettere e usare direttamente il campo "num_pezzi" della seconda struttura,
nell'archivio del magazzino.. anche perchè come ti dice il problema il
num_pezzi all'inizio dev'essere per tutti zero, quindi non ha senso che
venga usato se non quando si parla del magazzino. Ricapitolando, lo yogurt
ha come caratteristiche base il tipo, e il peso. Quando arriva nel 
magazzino
ha quattro ulteriori caratteristiche: codice magazzino, scadenza, numero
pezzi e prezzo, per questo lo yogurt in magazzino deve essere una struttura
che contiene una struttura.
 
Comunque sai che ti dico, tu sentiti libero di interpretare il problema
come vuoi, in modo comunque che abbia senso. Dopo di che traduci il tutto
in codice. A quel punto il codice dev'essere coerente al 100% con la tua
interpretazione del problema e lì possiamo darti una mano a capire come
svilupparlo. Credo che questo sia il modo migliore di esercitarti
ai fini dell'esame. Poi quando ti troverai lì a doverlo fare, se avrai
problemi sulla comprensione puoi farteli chiarire al momento stesso dal
docente (il quale è assolutamente tenuto a dare chiarimenti sulla traccia,
non a darti suggerimenti per la soluzione chiaramente).
 
-- 
Vincenzo Mercuri

 
 
Ciao anche a te! ;)
Sì, ultimamente iclc langue, ma sempre qui si sta!
 
Ciao!

 Y, semmai.
 
 
si, anche io ho interpretato come Y, altrimenti non la vedo uan cosa 
sensata.
Comunque ï¿½ troppo macchinoso da capire, passo ad un altro simile, ma piï¿½ 
chiaro come testo.
In ogni caso i suggerimenti che mi avete dato sono stati utilissimi.