Newsgroup: it.comp.lang.c
Titolo: Progetto in C ... meglio evitare le liste ...

questo e' il testo dell'esame che dovrò fare ... qualcuno mi può aiutare o
quanto meno suggerire la struttura dati + efficiente e la sua
implementazione (+ che altro dove trovo un esempio simile di implementazione
per cominicare a ragionarci su?) ??? grazie 1000 ...
pro...@libero.it
Obiettivo del progetto è quello di gestire uno "stagno digitale" provvisto
di ninfee in superficie, ed in cui vivono e saltano rane.
Formalmente, uno stagno è una griglia quadrata  S di dimensioni B´B , S =
{ (x,y) Î N ´ N | 0 £ x £ B, 0 £ y £ H }.
Una ninfea n è una coppia di coordinate intere appartenenti ad S. Date due
ninfee n1 ed n2 , Distanza(n1,n2) Î R+ (numero reale non negativo) denota
l'usuale distanza euclidea fra i due punti di S in cui le due ninfee n1  ed
n2  si trovano.
Una ninfea n e' caratterizzata da un attributo Resistenza(n) Î N che misura
la sua capacità di sorreggere le rane che vi sostano o saltano sopra. Quindi
una ninfea e' una tripla di valori interi non negativi.
Una rana r può:
·nuotare nello stagno (e quindi non sostare o saltare su alcuna ninfea);
·sostare o saltare sopra una ninfea, purché quest'ultima sia in grado di
sorreggerla;
·saltare da una ninfea ad un'altra, purché quest'ultima sia sufficientemente
vicina alla prima da essere raggiunta da r in  un solo balzo.
La rana r e' caratterizzata da due attributi: l'attributo Peso(r) Î N e
l'attributo Salto(r) Î R+. La ninfea n sorregge la rana r quando Peso(r) £
Resistenza(n). La ninfea n sorregge il gruppo di rane r1,r2.,rk quando
Peso(r1) + Peso(r2) + . +Peso(rk) £  Resistenza(n).
Se r si trova sulla ninfea n1  e salta verso la ninfea n2 , allora r
raggiunge n2  in un solo balzo quando Distanza(n1,n2) £ Salto(r).
Se una rana raggiunge una ninfea con un salto, ma la ninfea non e' in grado
di sorreggerla, la rana cade nello stagno S insieme a tutte le altre rane
eventualmente presenti sulla ninfea. La ninfea viene sommersa dall'acqua,
scomparendo da S.
Si chiede di implementare strutture dati efficienti che consentano di
eseguire le seguenti operazioni:
crea(B)
Crea uno stagno S di dimensioni B´B.
inserisci_ninfea(x,y,a)
Inserisce in S nelle coordinate x,y una ninfea con Resistenza a. Se nelle
coordinate x,y è già presente una ninfea (eventualmente con rane),
l'operazione sostituisce la precedente con la nuova ninfea (priva di rane).
elimina_ninfea(x,y)
Elimina da S la ninfea presente nelle coordinate x,y con le eventuali rane
in sosta. Se non esiste una ninfea nel punto specificato non viene fatto
nulla
inserisci_ninfee_rand(k,a)
Aggiunge casualmente nello stagno k ninfee distinte con resistenza a. Anche
in questo caso ogni ninfea che preesisteva alla invocazione di questa
operazione viene sostituita da una nuova se quest'ultima capita nello stesso
punto in cui era la prima.
inserisci_rana(x,y,p,s)
Poni una rana r con Peso(r) = p e Salto(r) = s nella ninfea a coordinate x,y
(notare che se il peso totale delle rane che si vengono a trovare sulla
ninfea è superiore alla resistenza della ninfea rane e ninfea affondano). Se
non esiste una ninfea nel punto specificato la rana affonda.
elimina_rana(x,y)
                Elimina la rana eventualmente presente sulla ninfea a
coordinate x,y.
inserisci_rane_rand(k,p,s)
Poni casualmente k rane con Peso pari a p e Salto pari ad s nello stagno. Se
la rana non capita su una ninfea la rana affonda. Se la rana capita su una
ninfea che non può sorreggerla sia la rana che la ninfea affondano (insieme
alle altre rane eventualmente presenti sulla ninfea).
salta(x,y,x',y')
Fai saltare tutte le rane  eventualmente presenti sulla ninfea a coordinate
x,y verso la ninfea a coordinate x',y'. Non viene eseguita alcuna operazione
in caso di assenza di almeno una delle due ninfee specificate.
censisci(a,b,c,d)
                Calcola il numero delle rane presenti nel rettangolo di
stagno determinato dai punti (a,b) e (c,d).
numero_salti(x,y,x',y')
Per ogni rana r sulla ninfea a coordinate x,y viene calcola il minor numero
di salti che r deve spiccare per raggiungere la ninfea a coordinate x',y'.
Si noti che per svolgere questo calcolo occorre tener conto di:
1)       la distanza fra le ninfee
2)       la resistenza delle ninfee,
3)       il peso di r.

 wrote in message
cHI18.3554$RQ5....@news1.tin.it...


 ha scritto nel messaggio
news:cHI18.3554$RQ5....@news1.tin.it...


 ha scritto nel messaggio
news:8Tc28.15571$tl3.4...@twister2.libero.it...


Questo compito quando lo dovreste fare?
ciao
io sono di milano, sono al secondo anno di università, sono iscritto al
corso di laurea triennale in informatica,nn proprio un compito ma un
progetto che in teoria dovremmo fare entro il 31 gennaio,(io parlo per me)
ma se vado avanti così missà che salta!
a mio avviso nn è così semplice!
aspetto volentieri qualche dritta!
ciao a tutti
Luca
--------------------------------
Inviato via 
http://usenet.iol.it
 

 per cominicare a ragionarci su?)
Se hai un testo da seguire e se lo hai capito bene il C non dovresti
aver problemi con nessuna implementazione, in caso contrario posso
passarti il metodo per la gestione della lista concatenata che uso io,
ma ripeto...la trovi anche su un testo...
ciao duido
-- 
Posted via Mailgate.ORG Server - 
http://www.Mailgate.ORG

 ha scritto nel messaggio
news:a4002e3750f4e0c8488...@mygate.mailgate.org...


tutto.... vabbè mi metto sotto ... appena passa sta dannata influenza!
Piccola considerazione sulle ADT.
Ci sono ADT giuste per ogni circostanza... dire "le liste le usano i
bambini" e' una cavolata. Le liste le usi quando il problema e'
logicamente ed efficientemente rappresentabile con una lista :)
Un grafo poi come lo rappresenti?
Se il grafo sara' generalmente fortemente connesso meglio una matrice
di adiacenza, in caso contrario una LISTA di adiacenza (quelle che
usano i bambini).
Nota: l'ADT cerca di farla indipendente dal contenuto effettivo dei
vertici e dai link del grafo se scegli il grafo.
Comunque devi valutare prima il costo che hai con ogni ADT rispetto ai
vantaggi, poi scegli.
Mox :)