Exàmens de Programació. www.elsmeusapunts.es

1. 11/06/2011
1.- L'estació meteorològica de St. Fost de Campsentelles recull dades atmosfèriques automàticament i
sense aturar-se des de 1980.
Les dades recollides es recullen cada 10 minuts i diàriament queden enregistrades en una seqüència del
tipus
<A M D H1 m1 T1 h1 P1 V1 H2 m2 T2 h2 P2 V2 ··· H144 m144 T144 h144 P144 V144>
on
• A, és un enter: l'Any
• M es un enter: el Mes
• D és el dia. també un enter
• Hi mi constitueixen l'hora i minut en què s'enregistren les dadesi
• Ti hi Pi Vi són respectivament la Temperatura, humitat, Pressió i Vent del momenti. Tots aquests valors són de tipus real.
Com que es prenen dades cada 10 minuts la seqüència de cada dia té 144 paquets de H m T h P V
la seqüència < 2008 3 4 0 0 12.2 88.4 1010.0 1.0 0 10 12.2 88.5 1009.8 1.1 ···
indica que a les 0:00 del 3/4/2008 la temperatura era 12.2ºC, la humitat del 88.4%, la pressió de 1010.0
HPa i el vent de 1.0 m/s; a les 0:10, la temperatura era 12.2ºC, la humitat del 88.5%, la pressió de 1009.8
HPa i el vent de 1.1 m/s; ···
Es demana que dissenyeu un algorisme maxMin llegeixi de l'entrada estàndard les dades corresponents a un dia i escrigui a la sortida estàndard la data i les temperatures màxima i mínima del dia.
La sortida ha de ser del tipus:
< A M D Tmax Tmin >
on A, M i D tenen el mateix significat que abans i Tmax i Tmin són la temperatura màxima i mínima
del dia
Nota: En aquesta pregunta es valorarà l’aplicació correcta dels esquemes algorísmics i NO es demana
en cap cas la utilització de disseny descendent.
algorisme maxMin
var
A, M, D, H, m: enter;
//Any, Mes, Dia, Hora, minut
tMax, tMin: real;
//Temperatures màxima i mínima
i, j: enter;
//Comptadors pels bucles
T: real;
//Temperatura actual
auxiliar: real; //real per llegir les altres
//dades que no es necessiten
fvar
/*Tractament inicial*/
A := llegirEnter();
M := llegirEnter();
D := llegirEnter();
H := llegirEnter();
m := llegirEnter();
T := llegirReal();
tMax := T;
tMin := T;
per j := 1 fins 3 fer
auxiliar := llegirReal();
fper
// no es necessita
/*Tractament de la seqüència*/
1

2. per i := 2 fins 144 fer
H := llegirEnter();
m := llegirEnter();
T := llegirReal();
si T > tMax llavors tMax := T;
si T < tMin llavors tMin := T;
per j := 1 fins 3 fer
auxiliar := llegirReal();
fper
fper
/*Final del tractament*/
escriureEnter(A);
escriureEnter(M);
escriureEnter(D);
escriureReal(tMax);
escriureReal(tMin);
falgorisme
2.- Al centre meteorològic del Tibidabo, es mantenen les dades meteorològiques des del 1893. L'any 1992
es va decidir informatitzar-les i en l'actualitat ja es tenen les dades diàries de Temperatura, Pluja,
Humitat i Pressió, corresponents a tot el segle XX (1901 - 2000).
Per a cada element meteorològic s'ha creat una taula de taules i es descriuen seguit:
TempXX taula [100] de taula [365] de real,
PluvXX taula [100] de taula [365] de real,
HumeXX taula [100] de taula [365] de real,
PresXX taula [100] de taula [365] de real,
de manera que TempXX[54][186] conté la temperatura del dia 186 de l'any 1954 (el 5 de juliol).
De cara a homogeneïtzar les dades s'ha eliminat la dada del 29 de febrer dels anys de traspàs.
Es demana:
a) [10%] definiu la capçalera del mòdul (acció o funció) anyModel que rep una taula meteorològica del
segle Dxx[100][365], i en retorna una altra de 365 posicions en què cada posició és la mitjana dels
valors d'aquell dia en tot el segle.
funcio anyModel (DXX:taula [100] de taula [365] de real)
:taula[365] de real
b) [20%] codifiqueu el mòdul anyModel
funcio anyModel (DXX:taula [100] de taula
var
i, j: enter;
Dout: taula[365] de real
fvar
per i := 1 fins 365 fer
Dout[i] := 0;
fper
per i := 1 fins 100 fer
per j := 1 fins 365 fer
Dout[j] := Dout[j] + Dxx[i][j];
fper
fper
per i := 1 fins 365 fer
Dout[i] := Dout[i]/365;
fper
[365] de real)
:taula[365] de real
//inicialitzem a zero
//calculem mitjanes
2

3. retorna Dout;
ffuncio
3.- Una macro botiga de calçats té veritables problemes amb el magatzem perquè ha de tenir passadis-
sos amples perquè passin els dependents i massa habitualment les capses que es treuen del seu lloc
no es retornen.
Per aquest motiu ha decidit posar un magatzem automàtic informatitzat en què cada casella del
magatzem té cabuda per una capsa de sabates i l'emmagatzematge i recollida es fa automàticament
per un sistema de plataformes mòbils.
El magatzem consta de 10000 caselles que poden estar buides o ocupades.
Es demana que dissenyeu:
a) [10%] Un tipus box per emmagatzemar la informació de l'estat de totes les caselles. Indiqueu quin
valor indica que una casella està ocupada i quin valor indica que una casella està lliure.
tipus box = taula [10000] de booleans
ftipus
{true indica que està lliure; false indica que està ocupada}
b) [5%] Un tipus tSabata per emmagatzemar la informació d'un parell de sabates. Per a cada parella es
disposa de les següents dades: el fabricant (que representarem pel tipus tString) el codi (un enter),
la talla (un enter), el color (un caràcter), en quin box està emmagatzemat (enter), el valor de compra
de la peça (un real) i el valor de venda de la peça (un real).
tipus tSabata = tupla
fabric : tString;
codi: enter;
talla: enter;
color: caracter;
box: enter;
compra: real;
venda: real;
ftipus
El tipus tInventari que emmagatzema la informació de totes les parelles de sabates en el magatzem
(fins 10000) en una taula. Les posicions de la taula ocupades són sempre les primeres.
tipus tInventari = tupla
sabata : taula [10000] de tSabata
qtty : enter;
ftipus
Les dades de totes les sabates emmagatzemades estan a la variable botiga de tipus tInventari
c) [5%] Donada la variable botiga del tipus tInventari, escriviu l'expressió que permetrà conèixer si el
fabricant de la última sabata entrada al magatzem és "Pages".
botiga.sabata[botiga.qtty].fabric = "Pages"
d) [20%] Dissenyeu la acció boxLliure que rebi la variable de tipus tBox i retorni el número d'una casella
buida a l'hora que canvia d'estat lliure a ocupada. Si no hi ha cap box lliure, ha de retornar un 0.
acció boxlliure (entsor boxes: taula [10000] de boolea, sort pos:enter)
pos := 1;
mentre pos <= 10000 i no boxes[pos] fer
pos := pos + 1;
fmentre
si pos <= 10000 llavors
boxes[pos] := fals;
sino
3

4. pos := 0;
fsi
faccio
18/06/2011
1.- [30%] L’estació meteorològica de St. Fost de Campsentelles recull dades atmosfèriques automàticament i sense aturar-se des de 1980.
Les dades recollides es recullen cada 10 minuts i diàriament queden enregistrades en una seqüència del
tipus
<A M D H1 m1 T1 h1 P1 V1 H2 m2 T2 h2 P2 V2 ··· H144 m144 T144 h144 P144 V144>
on
•
•
•
•
•
A, és un enter: l’Any
M es un enter: el Mes
D és el día. També un enter
Hi mi constitueixen l’hora i minut en què s’enregistren les dadesi
Ti hi Pi Vi són respectivament la Temperatura, humitat, Pressió i Vent del momenti. Tots aquests
valors són de tipus real.
Com que es prenen dades cada 10 minuts la seqüència de cada dia té 144 paquets de H m T h P V
la seqüència < 2008 3 4 0 0 12.2 88.4 1010.0 1.0 0 10 12.2 88.5 1009.8 1.1 ···
indica que a les 0:00 del 3/4/2008 la temperatura era 12.2ºC, la humitat del 88.4%, la pressió de
1010.0 HPa i el vent de 1.0 m/s; a les 0:10, la temperatura era 12.2ºC, la humitat del 88.5%, la pressió
de 1009.8 HPa i el vent de 1.1 m/s; ···
Es demana que dissenyeu un algorisme pressioHumitat que llegeixi de l’entrada estàndard les dades
corresponents a un dia i escrigui a la sortida estàndard la data i la humitat i pressió mitjanes
del dia.
La sortida ha de ser del tipus:
< A M D Hm Pm >
on A, M i D tenen el mateix significat que abans i Hm és la humitat mitjana i Pm la pressió mitjana del
dia
Nota: En aquesta pregunta es valorarà l’aplicació correcta dels esquemes algorísmics i NO es
demana en cap cas la utilització de disseny descendent.
algorisme pressioHumit
var
A, M, D, H, m : enter;
//Any, Mes, Dia, Hora, minut
Hm, Pm: real; //humitat i pressió mitjanes
i: enter; //Comptador pel bucle
auxiliar: real;
//real per llegir les altres
//dades que no es necessiten
fvar
/* Tractament inicial */
A := llegirEnter();
M := llegirEnter(); D := llegirEnter();
4

5. Hm := 0; Pm := 0;
/* Tractament de la seqüència */
per i := 1 fins 144 fer
H := llegirEnter();
m := llegirEnter();
auxiliar := llegirReal();
Hm := Hm + llegirReal();
Pm := Pm + llegirReal();
auxiliar := llegirReal();
fper
/* Final del tractament */
Hm := Hm / 144.0;
Pm := Pm / 144.0;
escriureEnter(A);
escriureEnter(M);
escriureEnter(D);
escriureReal(Hm);
escriureReal(Pm);
falgorisme
2.- [30%]. Al centre meteorològic del Tibidabo, una aplicació informàtica mostra, per les pantalles, unes
gràfiques que corresponen a l’evolució de les dades meteorològiques diàries al llarg del darrer any (els
últims 365 dies). Es mostra la gràfica de Temperatura, Pluja, Humitat i Pressió. Aquestes dades estan
emmagatzemades en quatre taules de 365 valors reals cadascuna.
Temp
Pluv
Hume
Pres
tabla [100] de tabla [365] de real
tabla [100] de tabla [365] de real
tabla [100] de tabla [365] de real
tabla [100] de tabla [365] de real
Un investigador decideix fer un suavitzat de les dades, fet consistent en, per a cada dia, obtenir un nou
valor que és la mitjana entre el valor real del dia anterior, el de l’actual i el del posterior (p.e. la pressió
suavitzada del dia 58 de l’any es calcula amb les pressions reals dels dies 57, 58 i 59). D’aquesta manera
creu que als gràfics desapareixeran molts dels pics i mostraran millor les tendències de les dades meteorològiques.
S’adona que no es pot calcular el suavitzat del primer dia (perquè no hi ha anterior) ni del darrer
(perquè no hi ha posterior).
Es demana:
a) [10%] definiu la capçalera del mòdul (acció o funció) suavitzaDades que rep una taula anual meteorològica de 365 posicions, i en retorna una altra de 365 posicions en què en les posicions 2 a 364
estan les dades suavitzades.
funcio suavitzaDades (D:taula [365] de real) :taula[365] de real
b) [20%] codifiqueu el mòdul suavitzaDades
funcio suavitzaDades (Din:taula [365] de real) :taula[365] de real
var
i: enter;
Dout: taula[365] de real
5

6. fvar
per i := 2 fins 364 fer
Dout[i] := (Din[i-1] + Din[i] + Din[i+1])/3;
fper
retorna Dout;
ffuncio
3.- [40%] Una macro botiga de calçats té veritables problemes amb el magatzem perquè ha de tenir
passadissos amples perquè passin els dependents i massa habitualment les capses que es treuen
del seu lloc no es retornen.
Per aquest motiu ha decidit posar un magatzem automàtic informatitzat en què cada casella del magatzem té cabuda per una capsa de sabates i l’emmagatzematge i recollida es fa automàticament per un
sistema de plataformes mòbils.
El magatzem consta de 10000 caselles que poden estar buides o ocupades. Es demana que dissenyeu:
a) [10%] Un tipus box per emmagatzemar la informació de l’estat de totes les caselles.
Indiqueu quin valor indica que una casella està ocupada i quin valor indica que una casella està lliure.
tipus box = taula [10000] de booleans
ftipus
{true indica que està lliure; false indica que està ocupada}
b) [5%] Un tipus tSabata per emmagatzemar la informació d’un parell de sabates. Per a cada
parella es disposa de les següents dades: model (cadena de caràcters que representarem pel tipus
tString), el codi (un enter), la talla (un enter), el color (un caràcter), en quin box està emmagatzemat
(enter).
tipus tSabata = tupla
model : tString;
codi: enter;
talla: enter;
color: caracter;
box: enter;
ftipus
El tipus tInventari que emmagatzema la informació de totes les parelles de sabates en el magatzem
(fins 10000) en una taula. Les posicions de la taula ocupades són sempre les primeres.
tipus tInventari = tupla
sabata : taula [10000] de tSabata qtty : enter;
ftipus
Les dades de totes les sabates emmagatzemades estan a la variable botiga de tipus tInventari
c) [5%] Donada la variable botiga del tipus tInventari, escriviu l’expressió que permetrà
conèixer el color de la última sabata entrada al magatzem.
botiga.sabata[botiga.qtty].color
d) [20%] Dissenyeu la acció boxSabata que rebi la variable botiga, el codi d’un model de sabates,
la talla i el color i retorni el número del box on està emmagatzemada i la posició de la sabata en
la taula de botiga. En el cas que la sabata no estigui en el magatzem, retornarà un 0 en les dues
variables.
acció boxSabata (ent botiga: tInventari, ent codi: enter, ent talla:
enter; ent color: caracter; sort box:enter; sort pos:enter)
6

7. var
trobat
: booleà;
a : tSabata;
fvar
pos := 0;
box := 0;
trobat := fals;
mentre pos < botiga.qtty i no trobat fer
pos := pos + 1;
a := botiga.sabata[pos];
si (a.codi = codi i a.talla = talla i a.color=color) llavors
trobat := true;
box := a.box;
fsi
fmentre
si (no trobat) llavors
pos := 0;
fsi
faccio
22/06/2011
1.- [30%] L’estació meteorològica de St. Fost de Campsentelles recull dades atmosfèriques automàticament i sense aturar-se des de 1980.
Les dades recollides es recullen cada 10 minuts i diàriament queden enregistrades en una seqüència del
tipus
<A M D H1 m1 T1 h1 P1 V1 H2 m2 T2 h2 P2 V2 ··· H144 m144 T144 h144 P144 V144>
on
•
•
•
•
•
A, és un enter: l’Any
M es un enter: el Mes
D és el día. també un enter
Hi mi constitueixen l’hora i minut en què s’enregistren les dadesi
Ti hi Pi Vi són respectivament la Temperatura, humitat, Pluviositat i Vent del momenti. Tots aquests
valors són de tipus real.
Com que es prenen dades cada 10 minuts la seqüència de cada dia té 144 paquets de H m T h P V
la seqüència < 2008 3 4 0 0 12.2 88.4 0.0 1.0 0 10 12.2 88.5 0.08 1.1 ···
indica que a les 0:00 del 3/4/2008 la temperatura era 12.2ºC, la humitat del 88.4%, la pluja de 0.0 l/m2
i el vent de 1.0 m/s; a les 0:10, la temperatura era 12.2ºC, la humitat del 88.5%, la pluviositat de 0.08 l/
m2 i el vent de 1.1 m/s; ···
Es demana que dissenyeu un algorisme plujaTemp llegeixi de l’entrada estàndard les dades corresponents a un dia i escrigui a la sortida estàndard la data i la temperatura mitjana i la pluja total del dia.
La sortida ha de ser del tipus:
< A M D Tm Pt >
on A, M i D tenen el mateix significat que abans i Tm és la temperatura mitjana i Pt la pluja total del
7

8. dia.
Nota: En aquesta pregunta es valorarà l’aplicació correcta dels esquemes algorísmics i NO es
demana en cap cas la utilització de disseny descendent.
algorisme plujaTemp
var
A, M, D, H, m : enter;
//
Tm, Pt: real; //
i: enter; //
auxiliar: real; //
//
fvar
/* Tractament inicial */
A := llegirEnter();
M := llegirEnter();
D := llegirEnter();
Any, Mes, Dia, Hora, minut
temp. mitjana i pluja total
Comptador pel bucle
real per llegir les altres
dades que no es necessiten
Tm := 0; Pt := 0;
/* Tractament de la seqüència */
per i := 1 fins 144 fer
H := llegirEnter();
m := llegirEnter();
Tm := Tm + llegirReal();
auxiliar := llegirReal();
Pt := Pt + llegirReal();
auxiliar := llegirReal();
fper
/* Final del tractament */
Tm := Tm / 144.0;
escriureEnter(A);
escriureEnter(M);
escriureEnter(D);
escriureReal(Tm);
escriureReal(Pt);
falgorisme
2.- [30%] Al centre meteorològic del Tibidabo, una aplicació informàtica mostra, per les pantalles, unes
gràfiques que corresponen a l’evolució de les dades meteorològiques diàries al llarg del darrer any (els
últims 365 dies). Es mostra la gràfica de Temperatura, Pluja, Humitat i Pressió. Aquestes dades estan
emmagatzemades en quatre taules de 365 valors reals cadascuna.
Temp taula [365] de real, Pluv taula [365] de real, Hume taula [365] de real, Pres taula [365] de real,
A les 00:00 de cada dia, s’actualitzen les taules, fet consistent en què s’incorpora a la darrera posició de
cada la taula la dada del dia que acaba de finalitzar, es perd la dada més antiga i totes les altres corren
una posició endavant.
Es demana:
a) [10%] definiu la capçalera del mòdul (acció o funció) actualitzaDies que rep les quatre taules meteorològiques, els valors del dia de temperatura, pluja, humitat i pressió i en fa l’actualització per
al següent dia.
accio actualitzaDies ( entsor Te: taula [365] de real,
8

9. entsor Pl:
entsor Hu:
entsor Pr:
ent TeDia:
ent HuDia:
taula
taula
taula
real,
real,
[365] de real,
[365] de real,
[365] de real,
ent PlDia: real,
ent PrDia: real)
b) [20%] codifiqueu el mòdul actualitzaDies
accio actualitzaTaulaDies (
//accio auxiliar que actualitza una sola taula
entsor D: taula [365] de real,
ent dada: real)
var
i: enter;
fvar
per i := 1 fins 364 fer
D[i] := D[i + 1];
fper
D[365] := dada;
faccio
//es corre una posició endavant
//es posa la nova dada al final
accio actualitzaDies (
entsor Te: taula [365] de real,
entsor Pl: taula [365] de real,
entsor Hu: taula [365] de real,
entsor Pr: taula [365] de real,
ent TeDia: real, ent PlDia: real,
ent HuDia: real, ent PrDia: real)
actualitzaTaulaDies (Te, TeDia);
actualitzaTaulaDies (Pl, PlDia);
actualitzaTaulaDies (Hu, HuDia);
actualitzaTaulaDies (Pr, PrDia);
faccio
3.- [40%] Una macro botiga de calçats té veritables problemes amb el magatzem perquè ha de tenir
passadissos amples perquè passin els dependents i massa habitualment les capses que es treuen
del seu lloc no es retornen.
Per aquest motiu ha decidit posar un magatzem automàtic informatitzat en què cada casella del magatzem té cabuda per una capsa de sabates i l’emmagatzematge i recollida es fa automàticament per un
sistema de plataformes mòbils.
El magatzem consta de 10000 caselles que poden estar buides o ocupades. Es demana que dissenyeu:
a) [10%] Un tipus box per emmagatzemar la informació de l’estat de totes les caselles. Indiqueu
quin valor indica que una casella està ocupada i quin valor indica que una casella està lliure.
tipus box = taula [10000] de booleans
ftipus
{true indica que està lliure; false indica que està ocupada}
b) [5%] Un tipus tSabata per emmagatzemar la informació d’un parell de sabates. Per a cada
parella es disposa de les següents dades: model (cadena de caràcters que representarem pel tipus
tString), el codi (un enter), la talla (un enter), el material (un caràcter), en quin box està emmagatzemat (enter), el valor de compra de la peça (un real) i el valor de venda de la peça (un real) i el bonus
(un enter)
tipus tSabata = tupla
9

10. model : tString;
codi: enter;
talla: enter;
material: caracter;
box: enter;
compra: real;
venda: real;
bonus: enter;
ftipus
El tipus tInventari que emmagatzema la informació de totes les parelles de sabates en el magatzem
(fins 10000) en una taula. Les posicions de la taula ocupades són sempre les primeres.
tipus tInventari = tupla
sabata : taula [10000] de tSabata
qtty : enter;
ftipus
Les dades de totes les sabates emmagatzemades estan a la variable botiga de tipus tInventari
c) [5%] Donada la variable botiga del tipus tInventari, escriviu l’expressió que permetrà conèixer el
benefici si es ven la última sabata entrada al magatzem.
botiga.sabata[botiga.qtty].compra botiga.sabata[botiga.qtty].venda
d) [20%] Dissenyeu la acció rebaixes que rebi la variable botiga i disminueixi el preu de venda de cada
parella de sabates segons el valor del bonus.
bonus
descompte
0
5%
1
10%
2
15%
acció rebaixes (entsor botiga: tInventari)
var
i
: enter
desc : real;
fvar
i := 0;
mentre i < botiga.qtty fer
i := i + 1;
si botiga.sabata[i].bonus = 0 llavors
desc := 0.95;
sino si botiga.sabata[i].bonus = 1 llavors
desc := 0.90;
sino
desc := 0.85;
fsi
fsi
botiga.sabata[i].venda := botiga.sabata[i].venda * desc;
fmentre
faccio
10

11. 18/01/2012
1. (3 punts) A l'ecopark de Sant Fost de Campsentelles hi van a descarregar els camions de recollida
selectiva de deixalles procedents dels municipis de la comarca. Quan entren els camions s'omple un
registre que inclou dades del municipi d'origen, hora d'entrada, tipus i pes del material.
A la deixalleria s'agrupen els materials per tipus i són expedits a les plantes de reciclatge.
El registre diari d'entrades de l'ecopark és una seqüència del tipus
<M D A1 H1 m1 T1 P1 A2 H2 m2 T2 P2 ··· An Hn mn Tn Pn 0>
on
• M és un enter: el mes.
• D és el día. També un enter.
• Ai és el codi de l'ajuntament, un número enter de 5 xifres que coincideix amb el codi postal més baix
del municipi.
• Hi mi , enters, constitueixen l'hora i minut en què entra el camiói
• Ti és la codificació del tipus de material, un número que pot ser:
° 1 ⇒ paper, 2 ⇒ envasos, 3 ⇒ vidre, 4 ⇒ orgànica
• Pi és el pes, en kg, transportat pel camiói.
• 0 és el número 0 que indica el final de la seqüència
Com que cada municipi té un sistema diferent de recollida la quantitat de camions que entren en un dia
pot ser variable i per detectar la fi de la seqüència s'escriu un 0
la seqüència < 3 4 08105 6 12 1 5010 08101 6 17 3 7210 ··· 0>
indica que a les 6:12 del 3 d'abril va entrar una camió del municipi 08105 carregat amb 5010 kilos de
paper; a les 6:17 un camió del municipi 08101 amb 7210 Kg de vidre; ···
Es demana que dissenyeu un módul (acció o funció, el més adequat) de nom totalMaterial que rebi el
codi d'un material (T), llegeixi la seqüència de dades de l'entrada estàndar i escrigui a la sortida estàndar la quantitat de camions rebuts amb aquell material i la totalitat de quilos corresponent.
La sortida ha de ser del tipus: < T M D tc tq >
on T, M i D tenen el mateix significat que abans i tc és la quantitat total de camions que han entrat durant el dia amb el material de tipus T i tq la totalitat de quilos que portaven
Nota: En aquesta pregunta es valorarà l’aplicació correcta dels esquemes algorísmics i NO es demana
en cap cas la utilització de disseny descendent.
accio totalMaterial (ent code: caracter)
var
M, D, A, H, m, T, P : enter;
T : caracter;
tc, tp : enter;
fvar
//inici del tractament
M := llegeixEnter();
D := llegeixEnter();
tc := 0;
tp := 0;
A := llegeixEnter();
//recollida i acumulació de dades
mentre A ≠ 0 fer
11

12. H := llegeixEnter();
m := llegeixEnter();
T := llegeixCaracter();
P := llegeixEnter;
si T = code llavors
tc := tc + 1;
tp := tp + P;
fisi
A := llegeixEnter();
fmentre
//sortida de resultats
escriureEnter (code);
escriureEnter (M);
escriureEnter (D);
escriureEnter (tc);
escriureEnter (tp);
facción
2. (3punts) La cadena de restaurants Good menu té 4 locals, oberts els 365 dies de l'any, en els quals
serveix 10 menús
Per tal de fer estadístiques recull les dades anuals dels quatre locals en quatre variables definides com
taules de taules:
tipus
tVendesDia= taula[365] de enter;
tMenu= taula[10] de tVendesDia;
ftipus
var
BigMenu, MenuOne, DailyMenu, PresXX: tMenu;
fvar
de manera que BigMenu[1][186] conté la quantitat de menús del tipus 1 del dia 186 de l'any (el 5 de
juliol) del local Big Menu. De cara a homogeneïtzar les dades s'ha eliminat la dada del 29 de febrer dels
anys de traspàs.
Es demana:
i. definiu la capçalera del mòdul (acció o funció) totalDiari que rep les dades dels quatre restaurants i
retorna una taula de 365 posicions en què en cada posició te la totalitat de menús (sense distinció
del tipus) servits aquell dia entre tots els restaurants de la cadena. (1 punt)
funcio totalDiari (D1: tMenu, D2: tMenu, D3: tMenu, D4: tMenu): tVendesDia
ii. codifiqueu el mòdul totalDiari (2 punts)
funcio totalDiari ( D1: tmenu, D2: tmenu, D3: tmenu, D4: tmenu):tVendesDia
var
i, j: enter;
Dout : tVendesDia;
fvar
per i:= 1 fins 365 fer
//inicialitzem l'acumulador del dia a zero
Dout[i] := 0;
//acumulem els menus del dia i dels 4 restaurants
per j := 1 fins 10 fer
// acumulem els menus del tipus j del dia i dels 4 restaurants
Dout[i] := Dout[i] + D1 [j][i] + D2 [j][i] + D3 [j][i] + D4 [j][i];
12

13. fper
fper
retornar Dout;
ffuncio
3. (4punts) Un estudi de disseny d'aplicacions multimèdia vol organitzar el seu repositori de videomaterials. Per a aquest exercici suposarem que està definit el tipus de dada text que conté una cadena de
text i les accions i funcions escriureText i llegirText equivalent a les que coneixem per als altres tipus.
Es demana que dissenyeu:
a) Un tipus tInfoVideo per emmagatzemar la informació d'un clip de vídeo. Aquest informació ha
d'incloure: el nom del fitxer, el format, el codi de l'autor (un número enter entre 1 i 1000), la durada en
segons (un enter), el nom de la carpeta on està emmagatzemada i el preu d'ús del vídeo (un real). (0.5
punts)
tipus tInfoVideo = tupla
nom:text;
format:text;
autor:enter;
durada:enter;
carpeta:text;
preu:real;
ftupla
b) Un tipus tAutor per emmagatzemar la informació de cada autor de vídeos. De cada autor hem de
recopilar la següent informació. Cognoms (text), nom (text), dni(enter) i IBAN del seu compte
(text). (0.5 punts)
tipus tAutor = tupla
cognoms: text;
nom: text;
dni: enter;
IBAN: text;
ftipus
El tipus tInventari emmagatzema la informació de totes les imatges de què es disposa (fins 1000000) en
una taula. Les posicions de la taula ocupades són sempre les primeres.
tipus tInventari = tupla
foto : taula [1000000] de tInfoVideo;
qtty : enter;
ftupla
ftipus
El tipus tPersonal emmagatzema les dades de tots els fotògrafs col·laboradors de l'empresa (el codi de
l'autor és l'index dins la taula que li correspon)
tipus tPersonal = tupla
autor : taula [1000] de tAutor;
qtty : enter;
ftupla
ftipus
El programa que gestiona les dades té declarades les variables fons del tipus tInventari i la variable
col·laborator del tipus tPersonal
c) Donada la variable fons del tipus tInventari, escriviu l'expressió que permetrà conèixer si el primer
clip del fons val més de 200€. (1 punt)
13

14. fons.foto[1].preu > 200.0;
d) Dissenyeu el mòdul videosByAutor que rebi les variables de tipus tIventari i tPersonal i el dni d'un
autor i retorni la quantitat de clips d'aquest autor hi ha en el fons (2 punts)
funció videosByAutor (fons: tInventari, col: tPersonal, dni: enter):enter
var
i, autor, clips:enter;
fvar
clips := 0;
//localitzem el codi de l’autor
i := 1;
mentre i < col.qtty i dni ≠ col.autor[i].dni fer
i := i + 1;
fmentre
autor := i;
//comptem els vídeos d’aquest autor
per i := 1 fins fons.qtty fer
si autor = fons.foto[i].autor llavors
clips := clips + 1;
fsi
fper
retornar clips
ffuncio
23/06/2012
1. (3 punts) Un repositori multimèdia rep habitualment informació de les pujades de materials dels
seus associats. Aquesta informació s’enregistra en una seqüència anual del tipus
on
•
•
•
•
•
•
< M1 A1 D1 L1 T1 M2 A2 D2 L2 T2 ··· Mn An Dn Ln Tn F>
Mi es el tipus de material, un caràcter que pot ser
° V de vídeo,
° M de música
° P de presentació
° D de diaporama
Ai que és el nom de l’autor
Di que és la durada en segons
Li que és el tipus de llicència que pon prendre els valors CR, BY, NC, ND o SA
Ti que és el codi de la temàtica, un número que pren valors entre 1 i 1000
F, és la lletra F que marca la fi de la seqüència
Es demana construir un mòdul countByLicense (acció o funció, el més adequat) que rebi un tipus de
material i retorni, en comptadors diferents, quants ítems hi ha llicenciats sota cada tipus de llicència.
[podeu emprar el tipus simple text i els mòduls readText i writeText amb els mateixos significats que a les
pràctiques]
acció countByLicense (ent type: character, sor CR: enter, sor BY: enter, sor NC:
enter, sor ND: enter,
sor SA: enter)
14

15. var
material : carácter;
name, license : text
time, tema: enter
fvar
{inicialitza comptadors}
CR := 0;
BY := 0;
NC := 0;
ND := 0;
SA := 0;
{preparació de la sequència}
material := readChar();
{tractament de la seqüència}
mentre material ≠ ‘F’ fer
name := readText();
time := readInteger();
license := readText();
tema := readInteger();
si material = type llavors
si license = ‘CR’ llavors
CR := CR +1;
sino si license = ‘BY’ llavors
BY := BY +1;
sino si license = ‘NC’ llavors
NC := NC +1;
sino si license = ‘ND’ llavors
ND := ND +1;
sino
SA := SA +1
fsi
fsi
fsi
fsi
fsi
material := readChar();
fmentre faccio
2. (3 punts). A la central hidroelèctrica de Volga central es manté, per setmanes, un historial de la
potència generada en cada hora.
Per tal de fer estadístiques es reuneixen les dades en una taula de taules segons les següents definicions i declaracions
tipus
tDay = taula [24] de real;
tWeek = taula [7] de tDay
ftipus
var
volgaPower : tWeek
fvar
de manera que volgaPower[5][12] conté la potència generada divendres a les 12 del migdia.
Es demana que creeu el mòdul hourPower (acció o funció, el més adequat) que rebi una hora determinada i la variable volgaPower, i retorni la potencia mitjana generada durant aquella hora al llarg de la
15

16. setmana.
funció hourPower( hora: enter, volgaPower : tWeek) : real;
var
total : real;
dia : enter;
fvar
total := 0.0;
per dia := 1 fins 7 fer
total := total + volgaPower [dia][hora];
fper
total := total / 7;
retorna total
ffuncio
3. (4 punts). Un aficionat a les curses d’automòbils i rallies vol fer un programa on emmagatzemar tota
la informació de què disposa del calendari anual i dels automòbils que actualment participen en el
circuit per tal de fer-ne un seguiment informatitzat.
[podeu emprar el tipus simple text i els mòduls readText i writeText amb els mateixos significats que a les
pràctiques]
Es demana que dissenyeu
a. Un tipus tDate per emmagatzemar una data en format numèric (0.5 punts)
tipus
tDate = tupla
day , month , year : enter;
ftupla
ftipus
b. Un tipus tCar que contingui informació del seu nom, equip, fabricant del motor y potència (en cavalls) (0.5 punts)
tipus
tCar = tupla
name, equipe, poweredBy : text;
power :enter;
ftupla
ftipus
c. Un tipus tRace que contingui informació d’una cursa: nom, kilòmetres de recorregut, voltes, país,
data i import en premis (0.5 punts)
tipus
tRace = tupla
name, pais: text;
km : real;
voltes, awards : enter;
raceDay: tDate;
ftupla ftipus
El tipus tMaquina pot emmagatzemar tota la informació sobre automòbils (fins 50000) en una taula.
Les qtty primeres posicions són les que estan plenes
16

17. tipus tMaquina= tupla
car : taula [50000] de tCar;
qtty : enter;
ftupla
ftipus
El tipus tChampionship pot emmagatzemar tota la informació sobre les curses (fins
10000) en una taula. El camp winner conté els codis del cotxes guanyadors de cada cursa (aquest
codi coincideix amb la posició que ocupa la informació del cotxe en la taula car del tipus tMaquina)
Les qtty primeres posicions són les que estan plenes
tipus tChampionship= tupla
race : taula [10000] de tRace;
winnerCode: taula [10000] de enter;
qtty : enter;
ftupla
ftipus
El programa que gestiona tota la informació té dues variables autos del tipus tMaquina i carrera del
tipus tChampionship
d. Donada la variable autos, escriviu l’expressió que digui la potència del darrer cotxe introduït a
la taula (1 punt)
autos.car[autos.qtty].power
e. Dissenyeu el mòdul whatWon que rebi el nom d’un automóvil i les variables de tipus tMaquina i
tChampionship i retorni la quantitat de carreres que ha guanyat aquest automòbil. (1.5 punts)
funció whatWon (name: text, autos: tMaquina, carrera: tChampionship)
var
codeCar, maxRace, total, i, j: enter;
fvar
total := 0;
maxRace := carrera.qtty;
i := 1;
mentre i <= autos.qtty i name ≠ autos.car[i].name fer
i := i + 1;
fmentre
si i <= autos.qtty llavors {s’ha trobat un cotxer amb el nom, el seu codi és i }
per j := 1 fins maxRace fer
si carrera.winnerCode[j] = i llavors;
total := total + 1;
fsi
fper
fsi
retornar total;
ffuncio
12/01/2013
17

18. 1. Les dades d’una imatge se situen en una seqüència, que és diferent si es tracta d’una seqüència en
color de tres canals
{C W H R1 G1 B1 R2 G2 B2... Rn Gn Bn}
o monocromàtica d’un sol canal
{M W H P1 P2 ... Pn}
on:
• C: és la lletra ‘c’ que indica que la foto és en color
• M: pot prendre els valors ‘m’ si es tracta d’una foto en blanc i negre, o bé ‘r’ si es tracta d’un canal
vermell, ‘g’ si es tracta d’un canal verd o ‘b’ si es tracta d’un canal blau.
• W: és l’amplada en píxels de la imatge
• H: és l’alçada en píxels de la imatge
• Ri Gi Bi: són les intensitats dels components vermell, verd i blau del píxel-i en una imatge en color
(valors enters que prenen valor entre 0 i 255)
• Pi : és la intensitat de color (gris, vermell, verd o blau, segons sigui el tipus d’imatge) del píxel-i en
una imatge monocromàtica. També pot prendre valors enters entre 0 i 255.
Una imatge negativa B d’una imatge A és una imatge dels mateixos canals, les mateixes dimensions,
però on el valor de cada píxel en la imatge nova es calcula restant de 255 el valor del píxel de la imatge
original. Per exemple:
Si la imatge original és en color {c 2 2 100 110 120 130 140 150 160 170 180 190 200 210} la imatge negativa
serà {c 2 2 155 145 135 125 115 105 95 85 75 65 55 45}.
En el cas d’una imatge monocromàtica {r 2 2 165 110 0 0} el negatiu seria {r 2 2 90 140 255 255}
Es demana que construïu un algorisme que llegeixi de l’entrada estàndard una imatge i escrigui en la
sortida estàndard la seqüència de la imatge negativa.
algorisme negative
var
mode : character;
w, h, n : integer;
v, i : integer;
fvar
// picture type
//wide, high, totalpixels
mode := readCharacter();
w := readInteger();
h := readInteger();
writeCharacter(mode);
writeInteger(w);
writeInteger(h);
n := w * h;
si mode = ‘c’ llavors
n := n * 3;
fsi
//read image head
per i:=1 fins n fer
v := readInteger();
writeInteger (255 – v);
fper
falgorismee
// serial processing
//write new image head
//if color, number of values are triple
//read value
//write negative value
2.- En un casino, per controlar el joc dels croupiers de la taula de Black Jack, una càmera de vídeo enregistra les cartes que es van traient del shuffle (el dispensador de cartes), fa un reconeixement d’imatge
i les codifica de manera que a les piques els correspon ordenadament els números 1 a 13, als trèvols del
14 al 26, a cors del 27 al 39 i als diamants del 40 al 52. A mida que es van extraient les cartes els codis es
van enregistrant en una taula, les posicions sobrants de la qual es replenen a zeros, i que s’ha dimensi18

19. onat a 5000 per tal que hi càpiga la informació de totes les cartes que es juguen en una taula durant un
dia. D’un dia a un altre, naturalment, no es juga la mateixa quantitat de cartes.
Es demana construir una funció que rebi la taula enregistrada per la càmera i un número (entre 1 i 13
corresponent a una puntuació) i digui quantes cartes d’aquella puntuació han dispensat durant el dia el
shuffle (tingueu en compte que no ens importa si són piques, trèvols, cors o diamants, per comptar-los
només importa el valor)
Per exemple, per localitzar els 6 s'hauria de cercar el 6(♥), el 19(♣), en 32(♥) i el 45(♦). Si la seqüencia
diària fora {34 6 45 32 2 35 19 51 45 15 18} es retornaria un 5.
funcio lowerOccurrence (shuffle: taula [5000] de integer, n: integer): integer
var
card,counter, i : integer;
// actual card, cards counter,
// auxiliar counter
fvar
i:=1; //init counters
counter := 0;
n := n mod 13; // 0 is now the king,
// others values no change
card := suffle[i];
mentre ((card ≠ 0) y (i ≤ 5000)) fer //count each card occurrence
card := card mod 13;
// reduces numbers from
// 1 to 12 (queen) and 0 (king);
si card = n llavors
counter := counter + 1;
fsi
i := i + 1;
card := shuffle[i];
//next card
fmentre
retorna counter;
ffuncio
3. Un laboratori de recerca sobre la imatge vol crear un nou estàndard d’emmagatzemament i treball
amb imatge i per aquest motiu ha de crear dades estructurades i mòduls de programa.
S’ha de crear una dada estructurada picture capaç d’emmagatzemar una imatge de fins 10 megapixels
(10 milions de pixels). De la imatge s’ha de desar:
• El tipus d'imatge: que pot rebre els valors ‘c’, ‘m’, ‘r’, ‘g’ i ‘b’ segons els significats exposats en l’exercici 1 d’aquesta prova.
• L’amplada i l’alçada de la imatge en píxels
• Per a tres canals, la informació de cadascun dels píxel (un número entre 0 i 255).
Si una imatge no ocupa 10 megapixels, l’espai sobrant s’acaba d’omplir a zeros.
Les imatges en blanc i negre, emmagatzemaran la informació dels pixels en el mateix canal que correspon al color vermell de les imatges a color.
Les imatge monocromes corresponents a un canal de color emmagatzemaran la informació en el seu
canal corresponent i els altres dos canals restaran completament a zeros.
• Dissenyeu la dada estructurada picture
tipus
picture = tupla
pictType: character;
width: integer;
high: integer:
r: taula [10000000] de integer;
g: taula [10000000] de integer;
b: taula [10000000] de integer;
ftupla
19

20. ftipus
Per emmagatzemar les imatges de prova s’ha creat una dada estructura que permet mantenir-ne fins 1
milió de fotos
biblio = tupla
qtty : integer;
col : taula [1000000] de picture;
ftupla
i s’ha creat la variable test del tipus biblio.
Escriviu l’expressió que ens indiqui si la imatge en posició 12500 de test és en blanc i negre i més alta
que ample
(test.col[12500].pictType = ‘m’) i (test.col[12500].high > test.col[12500]. width)
Creeu un mòdul (acció o funció, el més adequat) que rebi una imatge en color i generi tres imatges monocromes corresponents als tres canals de la imatge general
accio canalSeparate (ent in: picture, sor R:picture, sor G:picture, sor B:picture)
var
n, i: integer;
fvar
R.pictType := ‘r’;
G.pictType := ‘g’;
B.pictType := ‘b’;
R.width := in.width;
R.high := in.high;
G.width := in.width;
G.high := in.high;
B.width := in.width;
B.high := in.high;
n := in.width * in.high;
// creates picture heads
per i:= 1 fins n fer //
R.r[i] := in.r[i];
//
R.g[i] := 0;
R.b[i]:= 0;
G.r[i] := 0;
G.g[i] := in.g[i];
//
G.b[i] := 0
B.r[i] := 0;
B.g[i] := 0;
B.b[i] := in.b[i];
//
fper
per i := n+1 fins 10000000 fer
//
R.r[i] := 0;
R.g[i] := 0;
R.b[i]:= 0;
G.r[i] := 0;
G.g[i] := 0;
G.b[i] := 0;
B.r[i] := 0;
B.g[i] := 0;
B.b[i] := 0;
fper
faccio
computes n pixel on each image
copies r channel in R
copies g channel in G
copies b channel in B
fill 0 rest of image
19/01/2013
20

21. 1. Les dades d’una imatge se situen en una seqüència, que és diferent si es tracta d’una seqüència en
color de tres canals
{C W H R1 G1 B1 R2 G2 B2 ... Rn Gn Bn}
o monocromàtica d’un sol canal on:
{M W H P1 P2 ... Pn}
• C: és la lletra ‘c’ que indica que la foto és en color
• M: pot prendre els valors ‘m’ si es tracta d’una foto en blanc i negre, o bé ‘r’ si es tracta d’un
canal vermell, ‘g’ si es tracta d’un canal verd o ‘b’ si es tracta d’un canal blau.
• W: és l’amplada en píxels de la imatge
• H: és l’alçada en píxels de la imatge
• Ri Gi Bi: són les intensitats dels components vermell, verd i blau del píxel i en una imatge en color (valors
enters que prenen valor entre 0 i 255)
• Pi : és la intensitat de color (gris, vermell, verd o blau, segons sigui el tipus d’imatge) del píxel i en una
imatge monocromàtica. També pot prendre valors enters entre 0 i 255.
Una de les maneres de crear imatges en fals color és permutar en cada píxel les intensitats dels tres
canals de color, de manera que si RGB d’un píxel és 10 20 30, en permutar els canals s’obté 30 10 20 (es
posa com intensitat de vermell la que en l’original és de verd, com intensitat de verd la que en l’original
és de blau i com intensitat de blau la que en l’original és de vermell.
Per a la imatge en color {c 2 2 100 110 120 130 140 150 160 170 180 190 200 210} la permuta donaria la
imatge {c 2 2 120 100 110 150 130 140 180 160 170 210 190 200}
Es demana que construïu un algorisme que llegeixi de l’entrada estàndard una imatge en color i escrigui a la sortida estàndard la seqüència de la imatge permutada.
algorisme permute
var
mode : character;
w, h, n : integer;
r, g, b, i : integer;
fvar
// picture type
// wide, high, totalpixels
// read image head
mode := readCharacter();
w := readInteger();
h := readInteger();
writeCharacter(mode);
writeInteger(w);
writeInteger(h);
n := w * h;
// serial processing
per i := 1 fins n fer
r := readInteger();
g := readInteger();
b := readInteger();
writeInteger (g);
writeInteger (b);
writeInteger (r);
fper
falgorisme
// write new image head
// red value
// green value
// blue value
// write green as new red value
// write blue as new green value
// write red as new blue value
L’enunciat s’il·lustra amb un exemple que no es correspon amb la descripció escrita. Mentre a la descripció s’explicita que el nou canal vermell ha de rebre el color de l’antic verd, el nou ver el color del
blau original i el nou blau el del vermell original, en l’exemple es realitzen unes altres substitucions
21

22. canviant el vermell pel blau, el verd pel vermell i el blau pel verd.
Si es fa servir l’exemple per elaborar l’algorisme, la solució seria:
algorisme permute
var
mode : character; // picture type
w, h, n : integer;
// wide, high, totalpixels
r, g, b, i : integer;
fvar
mode := readCharacter();
w := readInteger();
h := readInteger();
writeCharacter(mode);
writeInteger(w);
writeInteger(h);
n := w * h;
// serial processing
per i := 1 fins n fer
r := readInteger();
g := readInteger();
b := readInteger();
// read image head
// write new image head
// red value
// green value
// blue value
writeInteger (b);
// write blue as new red value
writeInteger (r); // write red as new green value
writeInteger (g); // write green as new blue value
fper
falgorisme
Les dues solucions s’han acceptat com correctes.
2. En un casino, per controlar el joc dels croupiers de la taula de Black Jack, una càmera de vídeo enregistra les cartes que es van traient del shuffle (el dispensador de cartes), fa un reconeixement
d’imatge i les codifica de manera que a les piques els correspon ordenadament els números 1 a 13, als
trèvols del 14 al 26, a cors del 27 al 39 i als diamants del 40 al 52. A mida que es van extraient les cartes
els codis es van enregistrant en una taula, les posicions sobrants de la qual es replenen a zeros, i que
s’ha dimensionat a 5000 per tal que hi càpiga la informació de totes les cartes que es juguen en una taula
durant un dia. D’un dia a un altre, naturalment, no es juga la mateixa quantitat de cartes.
Es demana construir una acció que rebi la taula enregistrada per la càmera i retorni quantes cartes
de cada símbol (piques, trèvols, cors o diamants) ha dispensat durant el dia el shuffle
accio howMany (ent shuffle: taula [5000] de integer, sor p: integer, sor t: integer, sor c: integer, sor
d: integer )
var
card, i : integer;
fvar
p :=
t :=
c :=
d :=
i :=
// actual card, auxiliar counter
0; //init counters
0;
0;
0;
1;
22

23. card := suffle[i];
mentre ((card ≠ 0) i (i ≤ 5000)) fer //count each card occurrence
card := (card – 1) div 13;
//0 ⇒ spades, 1 ⇒ clubs, 2 ⇒
// hearts, 3 ⇒ diamonds
si card = 0 llavors
p := p + 1;
sino si card = 1 llavors
t := t + 1;
sino si card = 2 llavors
c := c + 1;
sino
d := d +1;
fsi
fsi
fsi
i := i + 1;
card := shuffle[i]; //next card
fmentre
faccio
3. Un laboratori de recerca sobre la imatge vol crear un nou estàndard d’emmagatzemament i treball
amb imatge i per aquest motiu ha de crear dades estructurades i mòduls de programa.
S’ha de crear una dada estructurada picture capaç d’emmagatzemar una imatge de fins 10 megapíxels
(10 milions de pixels). De la imatge s’ha de desar:
• El tipus d’imatge: que pot rebre els valors ‘c’, ‘m’, ‘r’, ‘g’ i ‘b’ segons els significats exposats en l’exercici 1 d’aquesta prova.
• L’amplada i l’alçada de la imatge en píxels
• Per a tres canals, la informació de cadascun dels píxel (un número entre 0 i 255).
Si una imatge no ocupa 10 megapíxels, l’espai sobrant s’acaba d’omplir a zeros.
Les imatges en blanc i negre, emmagatzemaran la informació dels píxels en el mateix canal que
correspon al color vermell de les imatges a color.
Les imatge monocromes corresponents a un canal de color emmagatzemaran la informació en el seu
canal corresponent i els altres dos canals restaran completament a zeros.
• Dissenyeu la dada estructurada picture
tipus
picture = tupla
pictType : character;
width : integer;
high : integer:
r : taula [10000000] de integer;
g: taula [10000000] de integer;
b: taula [10000000] de integer;
ftupla
ftipus
Per emmagatzemar les imatges de prova s’ha creat una dada estructura que permet mantenir-ne fins
1 milió de fotos
biblio = tupla
qtty : integer;
col : taula [1000000] de picture;
ftupla
i s’ha creat la variable test del tipus biblio.
23

24. Escriviu l’expressió que ens indiqui si en la imatge que està en posició 505 de test, les components verda
i blava del últim píxel d’imatge són iguals
test.col[505].g[test.col[505].width* test.col[505].high] =
test.col[505].b[test.col[505].width* test.col[505].high]
Creeu un mòdul (acció o funció, el més adequat) que rebi dues imatges del mateix tipus i dimensions i
en retorni una tercera en que cada píxel sigui la suma entre els píxels de les imatges originals.
Nota: hi ha la possibilitat que en fer la suma surti un número superior a 255. En aquest cas el color a
assignar serà el obtingut de la suma després de restar-li 256. P.e. si els vermells són 150 i 150, a la imatge resultats es posarà 44 (150 + 150 – 256 = 44)
funcio imgAdd(first: picture, second:picture): picture
var
n, i: integer;
new: picture
fvar
new.pictType := first.pictType;
new.width := first.width;
new.high := first.high;
//copies picture head
n := first.width * first.high;
per i := 1 fins n fer //computes each component of pixel
new.r[i] := (first.r[i] + second.r[i]) mod 256;
new.g[i] := (first.g[i] + second.g[i]) mod 256;
new.b[i] := (first.b[i] + second.b[i]) mod 256;
fper
per i := n+1 fins 10000000 fer
//fill 0 rest of image
new.r[i] := 0;
new.g[i] := 0;
new.b[i] := 0;
fper
retorna new
ffuncio
23/01/2013
1. Les dades d’una imatge se situen en una seqüència, que és diferent si es tracta d’una seqüència en
color de tres canals
o monocromàtica d’un sol canal
{C W H R1 G1 B1 R2 G2 B2 ... Rn Gn Bn}
{M W H P1 P2 ... Pn}
on:
• C: és la lletra ‘c’ que indica que la foto és en color
• M: pot prendre els valors ‘m’ si es tracta d’una foto en blanc i negre, o bé ‘r’ si es tracta d’un canal
vermell, ‘g’ si es tracta d’un canal verd o ‘b’ si es tracta d’un canal blau.
• W: és l’amplada en píxels de la imatge
• H: és l’alçada en píxels de la imatge
• Ri Gi Bi: són les intensitats dels components vermell, verd i blau del píxel i en una imatge en color
(valors enters que prenen valor entre 0 i 255)
• Pi : és la intensitat de color (gris, vermell, verd o blau, segons sigui el tipus d’imatge) del píxel i en
una imatge monocromàtica. També pot prendre valors enters entre 0 i 255.
24

25. Molts de cops resulta útil crear, a partir d’imatges en color tricanal, una imatge monocromàtica que
contingui la informació d’un sol color. Per exemple, de la imatge {c 2 2 100 110 120 130 140 150 160 170
180 190 200 210} podem extraure el canal vermell i es crearia la imatge {r 2 2 100 130 160 190} i, en cas
d’extraure el canal blau la imatge seria {b 2 2 120 150 180 210}.
Es demana que construïu un mòdul (acció o funció, el més adequat) que rebi com paràmetre un caràcter
que indiqui el canal a extraure (‘r’, ‘g’, o ‘b’), llegeixi del canal d’entrada estàndard la seqüència d’una
imatge en color i escrigui en el canal de sortida estàndard la imatge monocroma del canal sol·licitat.
accio canalExtract(ent canal: caracter)
var
mode : character;
w, h, n : integer;
r, g, b, v, i : integer;
fvar
mode := readCharacter();
w := readInteger();
h := readInteger();
// picture type
// wide, high, totalpixels
// read image head
writeCharacter(canal);
writeInteger(w);
writeInteger(h);
n := w * h;
// write new image head
per i := 1 fins n fer
r := readInteger();
g := readInteger();
b := readInteger();
si canal = ‘r’ llavors
v := r;
sino si canal = ‘g’ llavors
v := g;
sino
v := b;
fsi
fsi
writeInteger(v);
fper
faccio
// serial processing
// canal reading
// canal selection
// canal write
2. En un casino, per controlar el joc dels croupiers de la taula de Black Jack, una càmera de vídeo enregistra les cartes que es van traient del shuffle (el dispensador de cartes), fa un reconeixement
d’imatge i les codifica de manera que a les piques els correspon ordenadament els números 1 a 13, als
trèvols del 14 al 26, a cors del 27 al 39 i als diamants del 40 al 52. A mida que es van extraient les cartes
els codis es van enregistrant en una taula, les posicions sobrants de la qual es replenen a zeros, i que
s’ha dimensionat a 5000 per tal que hi càpiga la informació de totes les cartes que es juguen en una taula
durant un dia. D’un dia a un altre, naturalment, no es juga la mateixa quantitat de cartes.
Es demana construir una funció que rebi la taula enregistrada per la càmera i que retorni la quantitat
de diamants jugats.
funcio diamondsQtty (shuffle: taula [5000] de integer): integer
var
card, diamond, i : integer;
// actual card, diamonds counter,
// auxiliar counter
fvar
25

26. i := 1;
diamond := 0;
card := suffle[i];
mentre ((card ≠ 0) i (i≤5000)) fer
si card > 39 llavors
diamond := diamond + 1;
fsi
i := i + 1;
card := shuffle[i];
fmentre
// count each card occurrence
// from 39 to max value are diamonds
// next card
retorna diamond;
ffuncio
3. Un laboratori de recerca sobre la imatge vol crear un nou estàndard d’emmagatzemament i treball
amb imatge i per aquest motiu ha de crear dades estructurades i mòduls de programa.
S’ha de crear una dada estructurada picture capaç d’emmagatzemar una imatge de fins 10 megapíxels
(10 milions de pixels). De la imatge s’ha de desar:
• El tipus d’imatge: que pot rebre els valors ‘c’, ‘m’, ‘r’, ‘g’ i ‘b’ segons els significats exposats en l’exercici 1 d’aquesta prova.
• L’amplada i l’alçada de la imatge en píxels
• Per a tres canals, la informació de cadascun dels píxel (un número entre 0 i 255).
Si una imatge no ocupa 10 megapíxels, l’espai sobrant s’acaba d’omplir a zeros.
Les imatges en blanc i negre, emmagatzemaran la informació dels píxels en el mateix canal que correspon al color vermell de les imatges a color.
Les imatge monocromes corresponents a un canal de color emmagatzemaran la informació en el seu
canal corresponent i els altres dos canals restaran completament a zeros.
• Dissenyeu la dada estructurada picture
tipus
picture = tupla
pictType : character;
width : integer;
high : integer:
r : taula [10000000] de integer;
g: taula [10000000] de integer;
b: taula [10000000] de integer;
ftupla
ftipus
Per emmagatzemar les imatges de prova s’ha creat una dada estructura que permet mantenir-ne fins
1 milió de fotos
biblio = tupla
qtty : integer;
col : taula [1000000] de picture;
ftupla
i s’ha creat la variable test del tipuxs biblio.
Escriviu l’expressió que ens indiqui si el darrer píxel de la imatge en posició 32 té component vermella
test.col[32].r[test.col[32].width* test.col[32].high]≠0
26

27. Creeu un mòdul (acció o funció, el més adequat) que rebi dues imatges del mateix tipus i dimensions i
en retorni una tercera en que cada píxel sigui la mitjana entre els píxels de les imatges originals.
funcio imgAverage (first: picture, second:picture): picture
var
n, i: integer;
new: picture
fvar
new.pictType := first.pictType;
new.width := first.width;
new.high := first.high;
// copies picture head
n := first.width * first.high;
per i := 1 fins n fer // computes average pixel
new.r[i] := (first.r[i] + second.r[i]) div 2;
new.g[i] := (first.g[i] + second.g[i]) div 2;
new.b[i] := (first.b[i] + second.b[i]) div 2;
fper
per i := n+1 fins 10000000 fer // fill 0 rest of image
new.r[i] := 0;
new.g[i] := 0;
new.b[i] := 0;
fper
retorna new
ffuncio
27