Google Groups no longer supports new Usenet posts or subscriptions. Historical content remains viewable.
Dismiss
Esercizio
18 views
Skip to first unread message
lucas
Apr 11, 2013, 1:00:45 PM4/11/13
to
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;}
}
*******************************************
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;}
}
Vincenzo Mercuri
Apr 11, 2013, 2:17:15 PM4/11/13
to
Il 11/04/2013 19:00, lucas ha scritto:
[..]
Eh, comprendere il testo è un'impresa.. ma è la prima cosa da fare,
altrimenti non ha senso scrivere il codice.
> 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
>
Qui la parola archivio non so in che senso è usata. Da quello che ho
capito:
ci sono 100 tipi di yogurt. Una confezione di yogurt ha 3 caratteristiche:
il codice (da 1 a 100) del tipo, il peso, il numero di pezzi (il "numero
totale di pezzi" è il numero degli yogurt all'interno della confezione in
questione credo). Se quanto ho capito è vero, allora definire la struttura
`Y' e chiamarla "yogurt" è fuorviante perchè in realtà la struttura
descrive
una confezione (nè un tipo, nè uno yogurt). Piuttosto meglio chiamarla
`Confezione'.
> 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
>
Qui è il caos assoluto. 1000 è il numero max di confezioni? Cosa
significa modello? Se il modello si identifica con l'archivio S significa
che il magazzino ha archivi diversi (modelli diversi) ciascuno con un max
di 1000 confezioni o archivi diversi (S diversi) e un massimo di 1000
confezioni in totale? Per esempio S1 con 300 confezioni, S2 con 500, S3
con 200? Cosa sono gli stock? Se possono arrivare confezioni di yogurt
con lo stesso codice di tipo e numero differente di pezzi significa
che avranno anche pesi diversi e bisognerà anche valutare questo caso.
> 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.
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
[..]
Eh, comprendere il testo è un'impresa.. ma è la prima cosa da fare,
altrimenti non ha senso scrivere il codice.
> 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
>
capito:
ci sono 100 tipi di yogurt. Una confezione di yogurt ha 3 caratteristiche:
il codice (da 1 a 100) del tipo, il peso, il numero di pezzi (il "numero
totale di pezzi" è il numero degli yogurt all'interno della confezione in
questione credo). Se quanto ho capito è vero, allora definire la struttura
`Y' e chiamarla "yogurt" è fuorviante perchè in realtà la struttura
descrive
una confezione (nè un tipo, nè uno yogurt). Piuttosto meglio chiamarla
`Confezione'.
> 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
>
significa modello? Se il modello si identifica con l'archivio S significa
che il magazzino ha archivi diversi (modelli diversi) ciascuno con un max
di 1000 confezioni o archivi diversi (S diversi) e un massimo di 1000
confezioni in totale? Per esempio S1 con 300 confezioni, S2 con 500, S3
con 200? Cosa sono gli stock? Se possono arrivare confezioni di yogurt
con lo stesso codice di tipo e numero differente di pezzi significa
che avranno anche pesi diversi e bisognerà anche valutare questo caso.
> 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.
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
lucas
Apr 11, 2013, 4:13:40 PM4/11/13
to
Il 11/04/2013 20.17, Vincenzo Mercuri ha scritto:
> esiste una traccia originale di questo esercizio?
ciao,
> esiste una traccia originale di questo esercizio?
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
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
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.
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:
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.
Vincenzo Mercuri
Apr 11, 2013, 6:02:19 PM4/11/13
to
Il 11/04/2013 22:13, lucas ha scritto:
> Il 11/04/2013 20.17, Vincenzo Mercuri ha scritto:
>> 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).
>
Non devi preoccuparti di non sentirti esperto, hai bisogno appunto
> Il 11/04/2013 20.17, Vincenzo Mercuri ha scritto:
>> 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).
>
di esperienza, ma non con questo genere di problemi che ti fanno solo
passare la voglia di programmare. Non perchè difficili, ma perchè
non si riesce a decifrare quel che ti viene chiesto.
>
> ************************************
> 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
>
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
lucas
Apr 11, 2013, 7:41:58 PM4/11/13
to
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
fma...@gmail.com
Apr 11, 2013, 8:58:59 PM4/11/13
to
On Thursday, April 11, 2013 10:13:40 PM UTC+2, lucas wrote:
> Il 11/04/2013 20.17, Vincenzo Mercuri ha scritto:
> > 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).
>
Provo a rispondere anch'io, ma è stata dura... veramente non si capisce un
> Il 11/04/2013 20.17, Vincenzo Mercuri ha scritto:
> > 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).
>
tubo. Fidati più di Vincenzo (che ha infatti risposto per primo) che ha molta
più dimestichezza con queste cose ;)
> ************************************
> Banco degli yogurt
>
> Si consideri un archivio di yogurt contenente 100 tipi conservato in un
> archivio Y:
>
"esiste un archivio Y che contiene informazioni relative a 100 tipi diversi
di yogurt".
> Codice numerico del tipo (progressivo univoco da 1 a 100)
> Peso della confezione
> Numero totale di pezzi
Anche qui boh.. lo interpreto come "il massimo numero di pezzi disponibili
nel magazzino dell'azienda che gestisce l'archivio Y".
> Esiste un supermercato che li vende ed ha il suo archivio del magazzino
> S di MAX 1.000 degli yogurt arrivati:
supermercato che, vendendo gli yogurt di cui sopra, ha un suo archivio S"
> 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.
>
confezione, visto che il codice è progressivo e il totale è zero.
Un:
int prg = 1;
while (fgets(buf, sizeof(buf), stdin)!=NULL) {
double weight;
sscanf(buf, "%lf", &weight);
store_data(prg++, weight, 0);
}
Dovrebbe andare.
> 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.
>
i brividi..
> 3) Chiama una funzione "aggiorna" che aggiorna il numero totale di pezzi
> arrivati nel supermercato nell'archivio degli yogurt Y.
>
archivio S.
In quel caso è banale.
> 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.
>
:(
Sono stato completamente inutile, ma faccio "post" solo perché ho scritto
fin'ora, spero in qualche delucidazione sull'esercizio!
Ciao!
Vincenzo Mercuri
Apr 12, 2013, 1:28:40 AM4/12/13
to
On 12/04/2013 02:58, fma...@gmail.com wrote:
> On Thursday, April 11, 2013 10:13:40 PM UTC+2, lucas wrote:
>> Il 11/04/2013 20.17, Vincenzo Mercuri ha scritto:
>>> 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,
> On Thursday, April 11, 2013 10:13:40 PM UTC+2, lucas wrote:
>> Il 11/04/2013 20.17, Vincenzo Mercuri ha scritto:
>>> 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
>> comunque ti posto il testo completo e a seguire un altro testo, sono
>> tutti abbastanza simili, almeno come tipologia (sono testi da esame).
>>
>
> Provo a rispondere anch'io, ma � stata dura... veramente non si capisce un
>> tutti abbastanza simili, almeno come tipologia (sono testi da esame).
>>
>
> tubo. Fidati pi� di Vincenzo (che ha infatti risposto per primo) che ha molta
> pi� dimestichezza con queste cose ;)
>
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
Vincenzo Mercuri
Apr 12, 2013, 1:44:32 AM4/12/13
to
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
fma...@gmail.com
Apr 12, 2013, 2:42:34 AM4/12/13
to
On Friday, April 12, 2013 5:28:41 AM UTC+2, Vincenzo Mercuri wrote:
> On 12/04/2013 02:58, fma...@gmail.com wrote:
> > Provo a rispondere anch'io, ma è stata dura... veramente non si capisce un
> On 12/04/2013 02:58, fma...@gmail.com wrote:
> > tubo. Fidati più di Vincenzo (che ha infatti risposto per primo) che ha molta
> > più dimestichezza con queste cose ;)
>
> 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
> aveva preconfezionato dei temi d'esame simili.. la vera sfida
> selezione in questo modo
Sfortunatamente mi ricorda qualcosa.. Ho sempre pensato lo facessero per
capire chi era andato a lezione (e quindi aveva un contesto sul quale
potersi muovere) e chi no :)
> (ciao comunque, da un po' che non ci si ritrova su iclc).
>
Sì, ultimamente iclc langue, ma sempre qui si sta!
Ciao!
lucas
Apr 12, 2013, 5:40:00 AM4/12/13
to
Il 12/04/2013 2.58, fma...@gmail.com ha scritto:
>> Codice numerico del modello (lo stesso dell'archivio S)
>
> Y, semmai.
si, anche io ho interpretato come Y, altrimenti non la vedo uan cosa
>> Codice numerico del modello (lo stesso dell'archivio S)
>
> Y, semmai.
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.
0 new messages