¡Descarga Apunts Tipus Combinats y más Exámenes selectividad en PDF de Informática solo en Docsity!
Tipus Combinats
Taules parcialment ocupades
En C++ les taules tenen tamany fix, però molts problemes de programació tenen a veure amb dades de tamany variable. Per
poder treballar amb taules de tamany variable, podem fer servir taules d’un tamany màxim fix (que vindrà determinat pel
problema que tractem), però només omplir-ne una part. Per poder fer-ho necessitarem marcar d’alguna manera la última
casella de la part omplerta.
Essencialment hi ha dues maneres de marcar la taula: fent servir un sentinella o fent servir un enter extern a la taula, i agrupar
la taula amb l’enter mitjançant una tupla.
Normalment, anomenarem a les taules parcialment ocupades llistes.
Implementació amb sentinella
La manera més senzilla d’implementar una taula parcialment omplerta és posar-hi un sentinella. Si la taula és d’enters i
sempre seran positius, podem fer servir el -1, per exemple. Per exemple, donat el tipus:
const int MAX_ENTERS = 100;
typedef int tConjuntEnters1[100];
que guarda un conjunt d’enters positius, per emmagatzemar el conjunt {2, 3, 5} farem:
tConjuntEnters1 C;
C[0] = 2
C[1] = 3;
C[2] = 5;
C[3] = -1; // sentinella
Exercici 1 Fes una funció que mostra per pantalla un conjunt d’enters de tipus tConjuntEnters1 en el següent format (exactament):
{ 2, 3, 5 }
Si el conjunt està buit, es mostrarà (el sentinella ocupa la casella 0):
{ }
Exercici 2
Fes una funció que, donats dos conjunts, retorni un conjunt que representa la unió dels dos. Si els conjunts són {2, 3, 5} i {2, 7, 11}, la unió és {2, 3, 5, 7, 11}. Recorda marcar el conjunt resultat amb el sentinella perquè tingui el mateix format que els conjunts d’entrada.
Implementació amb una tupla
L’altra forma d’implementar una taula parcialment omplerta és declarar una tupla que agrupi la taula i un enter que marca el
final de la part omplerta. Típicament, aquest enter indica el número de caselles plenes (o equivalentment, la primera casella
buida).
Per exemple, si volem implementar el conjunt d’enters de la nova manera, farem el següent:
struct tConjuntEnters2 {
int enters[MAX_ENTERS];
int n_enters;
a on hem fet servir la constant MAX_ENTERS declarada amb tConjuntEnters2. En la nova representació, el mateix conjunt
{2, 3, 5} s’haurà d’inicialitzar així:
tConjuntEnters2 C;
C.enters[0] = 2;
C.enters[1] = 3;
C.enters[2] = 5;
C.n_enters = 3;
Exercici 3
Reimplementa la funció per mostrar per pantalla el conjunt d’enters però ara fent servir el nou tipus tConjuntEnters2.
Exercici 4
Implementa una funció que rebi dos conjunts d’enters (del nou tipus tConjuntEnters2) i retorni la intersecció dels dos conjunts. Si tenim els dos conjunts {2, 3, 5} i {2, 7, 11}, la intersecció és el conjunt {2}.
Combinacions de taules i tuples
Els tipus que podem crear en C++ són, doncs: enumerats, taules i tuples. Donat que qualsevol d’aquests és susceptible
d’ocupar les caselles d’una taula o els camps d’una tupla, es poden crear tipus jeràrquics amb facilitat.
Vegem-ne un exemple. Declararem una estructura per emmagatzemar les dades d’una coral. Per una banda tindrem els
cantaires, i per una altra les cançons que saben interpretar. Les estructures són les següents:
const int MAX_CANTANTS = 100;
const int MAX_CANSONS = 80;
struct tTipusVeu { baix, tenor, contralt, soprano };
struct tCantaire {
string nom, cognoms;
int telefon;
tTipusVeu veu;
struct tCanso {
string titol, autor;
int minuts; // durada de la can¸c´o
struct tCoral {
tCantaire cantaires[MAX_CANTANTS];
int n_cantaires;
tCanso cansons[MAX_CANSONS];
int n_cansons;
La tupla tCoral és la que agrupa tota la informació (en concret dues taules parcialment plenes de cantaires i cansons).
Suposem doncs, que en un programa, disposem d’una variable C de tipus tCoral que conté tota aquesta informació (alguna
part del programa ha omplert les dades a partir d’un fitxer, per exemple).
L’accés als camps i caselles d’aquesta estructura es fa fent servir els accessos a taules i tuples que convinguin per a cada part.
Per exemple:
C.cantaires[4].nom // el nom del 5`e cantant
C.cansons[0].titol // nom de la primera cans´o
C.cantaires[C.n_cantaires-1].veu // tipus de veu de l’´ultim cantaire
Exercici 5
Fes una funció que rebi la informació de la coral (de tipus tCoral) i calculi la durada total en minuts del repertori de la coral.
Taules d’índexs
Tornem a l’exemple de la coral. Suposem que volem afegir la informació dels concerts realitzats dins de la tupla tCoral. En
concret, de cada concert volem saber: 1) quins cantaires van assistir i 2) quines cançons es van cantar. El problema és que
no volem repetir tota la informació de les cançons i dels cantants una altra vegada (és a dir, el nom, telèfon, i tipus de veu
de cada cantant i el títol i durada de les cançons). Només volem identificar, per a cada concert, quins cantants en concret i
quines cançons, referenciant les que ja conté la coral.
Per aconseguir emmagatzemar aquesta informació sense repeticions, podem crear una taula d’índexs. En comptes de repetir
la informació sobre cantants a dins de la informació del concert, el concert només contindrà una taula (parcialment omplerta)
d’enters, que representaràn les caselles que cal anar a mirar a la llista “central” de cantaires per saber els que van assistir al
concert. El mateix farem per les cançons, el concert només guardarà una taula d’enters dels índexs de les cançons cantades.
Vegem l’exemple:
struct tData { int dia, mes, any; };
struct tConcert {
int cantaires[MAX_CANTAIRES]; // ´ındex a la taula de cantaires
int n_cantaires;
int cansons[MAX_CANSONS]; // ´ındexs a la taula de can¸cons
int n_cansons;
tData data; // data del concerts
string adresa; // lloc del concert
La tupla tCoral ara serà:
struct tCoral {
tCantaire cantaires[MAX_CANTANTS];
int n_cantaires;
tCanso cansons[MAX_CANSONS];
int n_cansons;
tConcert concerts[MAX_CONCERTS]; // Llista de concerts
int n_concert;
Per veure com s’accediria a la informació fent servir aquests índexs, podem implementar una funció que produeix una llista
per pantalla dels noms i cognoms dels cantaires que van assistir a un concert concret (identificat per l’índex ’n’):
void llista_cantaires_concert(const tCoral& C, int n) {
for (int k = 0; k < C.concerts[n].n_cantaires; k++) {
int idx = C.concerts[n].cantaires[k];
cout << C.cantaires[idx].nom << ’ ’
<< C.cantaires[idx].cognoms << endl;
En primer lloc, cal veure que s’ha de fer una iteració per la taula d’índexs, que està a dins de cada concert. El límit de la
iteració C.concerts[n].n_cantaires representa el número de cantaires que hi va haver en el concert n. Cada casella
d’aquesta taula és un número, que recollim a la variable idx, i amb aquest número anem a la taula de cantaires i extraiem el
nom i els cognoms.
Exercici 8
Suposant que tens accés a la informació de la coral a través d’una variable C, escriu codi que mostri per pantalla el títol de la primera cançó del tercer concert.
Exercici 9
Fes una funció que, donada la informació de la coral, calculi la durada d’un concert concret, és a dir, la suma en minuts de la durada de les cançons interpretades en aquest concert (identificat per un índex ’n’). Pots implementar altres funcions auxiliars si veus que és necessari.
Exercici 10
Fes una funció que, donada la informació de la coral i el títol d’una cançó, mostri per pantalla la data i el lloc dels concerts on s’ha inter- pretat. Aquest exercici és complex: identifica primer les operacions que hauries de fer (l’estratègia) i d’aquí, determina funcions/accions auxiliars que resolguin part del problema i t’acostin a la solució.
Problemes adicionals
Exercici 11
Una biblioteca vol mantenir informació sobre com està organitzat el seu material bibliogràfic. La biblioteca només té publicacions de tres tipus: ciència, literatura, i esport. Aquestes publicacions estan repartides en diferents plantes. Cada planta té associat un número i un nom de planta, i està dedicada exclusivament a un sol tipus de publicació.
De cadascuna de les publicacions ens interessa mantenir un codi que l’identifica, el títol de la publicació, els autors (màxim 10), l’editorial, l’any de publicació, el número de pàgines, i el tipus (un dels 3 esmentats). Adicionalment, cada publicació té un cert nombre d’exemplars, i cada un d’ells pot estar exclòs de préstec o no. Es vol saber també a on es troben físicament cada publicació (la planta i el prestatge, que té un codi associat), tenint en compte que tots els exemplars (com a màxim 20) d’una mateixa publicació es troben a la mateixa planta.
Finalment, la biblioteca té un llistat d’autors (ja que aquests poden aparèixer en més d’una publicació). De cada un es vol saber el nom, la nacionalitat, la data de naixement i el nombre de publicacions que té a la biblioteca.
Dissenyeu una estructura de dades per emmagatzemar aquestes dades, sabent que la biblioteca té 10 plantes, i que es mantindrà informació d’un màxim de 10000 publicacions amb 1000 autors diferents com a màxim.
Exercici 12
Donada la següent estructura de dades:
const int NEQUIPS = 12, NPARTIDES = 10;
typedef char tResultats[NPARTIDES];
struct tEquip { string nom_equip; int n_jugadors; tResultats resultats; };
struct tCampionat { tEquip equips; int n_equips; };
Feu les següents funcions/accions que treballen amb un tCampionat:
- busca_equip: donat un nom, retorna la casella del campionat a on es troba l’equip buscat, o -1 si no s’ha trobat.
- afegeix_equip: donat un nom, i un número de jugadors, afegeix l’equip al campionat. S’han de tenir en compte les següents situacions: - si l’equip té menys de 10 jugadors, s’ha d’escriure per pantalla “equip massa petit” i no fer res; - si el campionat ja està ple, s’ha d’escriure “ple”; i - si l’equip ja existeix, s’ha d’actualitzar el nombre de jugadors i s’ha d’escriure per pantalla “actualitzat”; - si l’equip no existeix, s’ha d’afegir i escriure per pantalla “afegit”.
No cal inicialitzar el camp resultats del tEquip.
- posa_resultats: donat el nom d’un equip i una taula de resultats, ha de modificar els resultats de l’equip. Si l’equip no existeix, ha d’escriure per pantalla “inexistent” i no fer res.
Exercici 13 Nota: aquest exercici sencer és força llarg, tot i que té moltes parts que es poden fer independentment
Pel fet que la representació dels enters en memòria en C++ té certs límits, volem implementar una petita llibreria que permeti treballar amb nombres grans (que anomenarem tBigNum) d’un número de xifres arbitrari (en concret, de fins a 1000 xifres). Per fer-ho definim el tipus tBigNum com:
