La segona pràctica de programació. www.elsmeusapunts.es

1. Estudis d’Informàtica, Multimèdia i Telecomunicació
Programació
Pràctica 2
SOLUCIÓ

2. Exercici 1: Cerques en taules de taules [20 %]
Un observatori meteorològic emmagatzema les dades de temperatura en una dada
estructurada.
tipus
dia: taula[24] de real;{representa les 24 hores del dia}
mes30: taula[30] de dia; {representa els dies del mes}
ftipus
A més, s’ha creat les següents variables:
var
abril, juny, setembre, novembre: mes30; {guarda les temperatures dels
mesos assenyalats}
fvar
En cada posició de les taules de taules hi ha la temperatura mesurada en una hora concreta.
P.e. en abril[3][18] estaria la temperatura que feia el 3 d’abril a les 6 de la tarda
Tasca: Crear el mòdul average (acció o funció, el més adequat) que rebi la taula
corresponent a un mes, i retorni
• en una taula les temperatures mitjanes de cada hora del dia del mes (la temperatura
mitjana que ha fet en cadascuna de les hores, ha de retornar les 24 temperatures) i
• en una variable la temperatura mitjana del mes.
accio average(ent m: mes30, sor averageHour:dia, sor tAverage:real)
{averageHour és la taula que representa el dia mitjà i tAverage la temperatura
mitjana del mes}
var
i, j: enter;
sumMonth: real;
fvar
sumMonth := 0.0;
per i:=1 fins 24 fer
averageHour[i] := 0.0;
per j:=1 fins 30 fer
sumMonth := sumMonth + m[j][i];
averageHour[i] := averageHour[i] + m[j][i];
fper
averageHour[i] := averageHour[i]/30.0;
fper
tAverage := sumMonth / 720.0; {un mes, 720 hores}
faccio

3. Exercici 2: Treball taules de taules en PHP [30 %]
El joc minesweeper es un joc tradicional d’ordinador en què el jugador ha de descobrir en
quines posicions d’un tauler es troben les mines que el jugador identifica amb la imatge
.
Les caselles interiors tenen 8 caselles veïnes,
però les laterals o d’un vèrtex en tenen menys
Aspecte d’un joc finalitzat amb èxit
Quan el joc finalitza, es mostren les mines i, a cadascuna de les altres caselles, el nombre
de mines que estan al seu veïnatge (el veïnatge d’una casella està constituït per totes les
caselles amb qui comparteix una aresta o un vèrtex). Si en el veïnatge d’una casella no hi ha
cap mina no apareix cap xifra.
Es fa servir una taula de taules per emmagatzemar els nombres enters que representen les
dades de un tauler del joc minesweeper de manera que la taula de la imatge anterior seria
una taula de 8 x 8 on hauria un 9 en les caselles que representen una mina i a les altres
caselles el número corresponent al veïnatge. P.e
0
0
0
0
0
0
1
2
1
9
2
9
representa
Tasca: Crear un conjunt de functions en php que creïn i manipulin taules de taules segons
les indicacions. El programa principal ja forma part de la plantilla.
Per a dur a terme aquesta tasca es faciliten els fitxers d'imatge que poden mostrar les
caselles del camp de mines.
0.png
1.png
2.png
3.png
4.png
5.png
6.png
9.png
Indicacions preceptives
• El programa rebrà un paràmetre filename que és el nom del fitxer de dades en què
s’indiquen les mides del tauler i les coordenades de cada mina. El contingut del fitxer
és una cadena de text on podem veure una seqüència de nombres que respon a
l’esquema:
<files columnes f1 c1 f2 c2 .... fn cn>
on
files indica l’alçada del camp de mines
columnes indica l’amplada del camp de mines
fi ci indiquen la posició de la mina i

4. per exemple la cadena de text “3 4 0 3 2 3” correspondria a la
imatge del costat.
S’ha de tenir present que la posició inicial és la 0 0.
•
La plantilla prac2_exer2_plantilla.php porta incorporat el programa principal que fa
les crides a les function. El codi que va escrit a la plantilla no s'ha de modificar.
•
Es faciliten arxius de dades (data20 a data24) per a les proves.
•
Els fitxers d'imatge s'han d'ubicar a la mateixa carpeta de localhost que el fitxer php.
•
S'ha de crear la function createTable que rep dos paràmetres numèrics ($height,
$width) que són la quantitat de files de quadres ($row) i quants quadres hi ha per fila
($col), genera un array bidimensional que correspon a les fitxes sol·licitades, l’omple
de zeros i el retorna.
•
S’ha de crear la function putCell que rep un número i mostra la imatge corresponent.
El número rebut pot ser un 9 (i es mostrarà la imatge d'una mina), un 0 (i es mostrarà
la casella en blanc) o un número entre 1 i 6 (i mostrarà el quadre amb el número
dins). Els números es corresponen amb el nom de les imatges.
•
S’ha de crear la function drawLine que rep un array unidimensional (que correspon a
una filera de la taula) i mostra les caselles en pantalla. Per mostrar cadascuna de les
caselles, haurà d’emprar la function putCell.
•
S’ha de crear la function drawMinefield que rep l’array bidimensional com paràmetre
i mostra totes les caselles en pantalla. Per mostrar cadascuna de les files de fitxes,
haurà d’emprar la function drawLine.
•
S'ha de crear la function loadMinefieldData que rep dos paràmetres:
o $minefield, la taula plena de zeros de les dimensions adequades i que
actualitzarà posant un 9 a les caselles on vagi una mina i, en les altres
caselles, el valor del seu veïnatge.
o $data, un array unidimensional on figuren les coordenades de les mines
•
Per obtenir la dimensió d'una taula, es pot fer servir la funció count1 de php. En el
cas de taules de taules la funció count aplicada a la variable (la taula de taules)
retornarà quantes fileres té la taula i aplicada a una filera, indicarà quantes columnes
té la filera.
•
No es poden emprar variables global.
•
En les instruccions print no es pot posar una posició d'array directament dins d'una
cadena constant. Cal emprar l'operador de concatenació · (punt).
per exemple, la instrucció
print "<td width='80'> $oneDog[$i] </td>"
escriuria una casella d'una taula amb el contingut exacte $oneDog[$i] en lloc del
continguts d'aquesta casella de l'array. Per obtenir el resultat desitjat s'ha d'emprar la
concatenació
print "<td width='80'>".$oneDog[$i]."</td>"
•
1
Recordeu que, a diferencia de les taules en llenguatge algorísmic que comencen en
la posició 1, en PHP la primera posició dels arrays és la posició 0.
http://php.net/manual/es/function.count.php

5. •
Podeu emprar functions de les emprades en exercicis o solucions anteriors, ja siguin
completes o adaptades a les noves dades estructurades.
Podeu comprovar el funcionament a:
http://prog.uoc.edu/prac2/prac2_exer2.php?filename=data20
Consells
Potser la part més conflictiva de l’exercici és el càlcul del veïnatge de cada casella en la
function loadMinefieldData. Una primer aproximació a la solució podria ser:
1. Llegir les dades de cada mina i posar un 9 en el minefield.
2. Fer un recorregut per minefield i per a cada casella mirar quants 9 té al seu voltant
Però es pot mirar també d’una altra manera:
•
Cada cop que posem una mina actualitzem els seus veïns incrementant en una
unitat el valor de veïnatge (sempre i quan no sigui un 9).
Aquesta segona visió fa que la solució sigui més àgil perquè en lloc de calcular el veïnatge
de totes les caselles només hem hagut de mirar el veïnatge de les mines, amb la qual cosa
els còmputs són menors. A més, aprofitem el fet que el tauler hagi estat inicialitzat a zeros,
perquè abans de posar cap mina totes les caselles tenen veïnatge 0, que és el que
correspon.
Un altre aspecte a tenir en compte és a quines caselles valorar el
veïnatge? Posem pel cas que volem valorar el veïnatge de la mina de
posició [$x][$y]. La situació més habitual serà que aquesta mina està
rodejada per altres 8 caselles formant una minitaula de 3 x 3, la
coordenada de la primera casella d’aquesta minitaula serà [$x-1][$y-1] i la
de la última serà [$x+1][$y+1]. Un doble bucle serà de molta utilitat.
De totes maneres caldrà tenir en compte que aquesta no és la única possible situació,
perquè hi ha mines que poden estar en una cantonada o en un costat i en aquest cas té
menys cel·les veïnes que actualitzar. Evidentment mai s’actualitzarà en coordenades que
no pertanyin al tauler, és a dir, ni en coordenades negatives ni coordenades que igualin el
valor de $height o $width.
Avaluació
Es valorarà especialment l'aplicació correcta dels esquemes de cerca, recorregut i/o
tractament adequats al problema conjuntament amb l'ús adequat dels índex de les
taules.

6. Copieu aquí el codi de la vostra solució
<?php
/************* FUNCTION *************/
//Aquí va el codi de les funcions
function LF()
{ //line feed
print "<br />";
}
function createTable($height, $width)
{ //creates a table heigth X width inizialized to 0
for ($i=0; $i < $height; $i++)
for ($j=0; $j < $width; $j++)
$table[$i][$j]=0;
return $table;
}//de createTable
function loadMinefieldData(&$minefield, $data)
{
$height = count($minefield);
$width = count($minefield[0]);
$longData = (int)count($data)/2;
for ($i=0; $i < $longData; $i++)
{
$x = array_shift($data);
$y = array_shift($data);
for($j=-1; $j<2; $j++)
for($k=-1; $k<2; $k++)
if (($x+$j>-1)&&($x+$j<$height)&&($y+$k>-1)&&($y+$k<$width)&&$minefield[$x+$j][$y+$k]!=9)
$minefield[$x+$j][$y+$k]++;
$minefield[$x][$y] = 9;
}
}//de loadMinefieldData

7. function putCell($n)
{
print "<img src='$n.png'>";
}
function drawLine($in)
{
$long = count($in);
for ($i=0; $i < $long; $i++) putCell($in[$i]);
LF();
}//de drawLine
function drawMinefield($in)
{
$long = count($in);
for ($i=0; $i < $long; $i++) drawLine($in[$i]);
}//de drawMinefield
/************* MAIN *************/
//Aquí va el codi del programa principal
$filename = $_GET["filename"];
include($filename);
$data = explode(" ",$cadena);
$height = array_shift($data);
$width = array_shift($data);
$table = createTable($height, $width);
loadMinefieldData($table, $data);
drawMinefield($table);
?>

8. Exercici 3: Disseny i treball amb tuples [20 %]
Un pirata informàtic vol crear la seva Pirateleaks per informatitzar les seves dades de
gestió de tots els documents que ha aconseguit i que emmagatzema en un conjunt de
servidors de fitxers. Pretén mantenir fins 10 milions de documents. Amb aquest
objectiu us demana que creeu les dades estructurades adequades
Tasca:
•
Dissenyeu la dada estructurada date adequada per mantenir una data
exposada en format numèric
date = tupla
day, month, year : enter;
ftupla
•
Dissenyeu la dada estructurada form_doc capaç d'emmagatzemar la
informació d'un document: nom del document, tipus (e-mail, txt, sms, pict,
sound, video ...), data del document, data de gravació, font (codi de qui l’ha
facilitat, un número de 10 xifres), volum del fitxer en MB, nacionalitats a què es
refereix (molts documents poden afectar a més d’un país, es considera que
com a màxim afecta 10 països) i el nom del servidor on està gravat (als
servidors el nomena mitjançant una lletra majúscula i empra l’ordre alfabètic
per anar posant nous servidors).
form_doc = tupla
name, type : cadena;
docDate, recordDate: date;
fontCode: enter;
volum : real;
government : taula [10] de cadena;
server: caracter;
ftupla
Per mantenir tota la informació de la col·lecció de documents s'ha creat la tupla
leaks de la següent manera
leaks = tupla
doc: taula [10000000] de form_doc; {fitxes dels documents}
qtty : enter; {número que indica quantes fitxes estan plenes}
ftupla
i la variable pirateLeaks del tipus leaks, on s'ha entrat tota la informació de
manera que totes les fitxes plenes estan posades consecutivament des de la
primera posició.
•
Escriviu l'expressió que digui si el fitxer del darrer document entrat és un vídeo i
mesura més de 50 MB
pirateLeaks.doc[pirateLeaks.qtty].type = "video" i
pirateLeaks.doc[pirateLeaks.qtty].volum > 50.0

9. •
Escriviu el mòdul freshNews (acció o funció, el més adequat) que rebi
pirateLeaks, un any i un mes i escrigui en el canal de sortida estàndard els
noms, tipus i servidors on estan els documents que van poder ser gravats el
mateix dia en què es van originar i que pertanyin a l'any i al mes dit.
accio freshNews(ent f: leaks, ent y:enter, ent m:enter)
{acció perquè no retorna res}
var
i : enter;
fvar
per i:=1 fins f.qtty fer
si f.doc[i].docDate.year = y i f.doc[i].docDate.month = m llavors
si
f.doc[i].docDate.day = f.doc[i].recordDate.day i
f.doc[i].recordDate. month = m i
f.doc[i].recordDate.year = y llavors
writeString (f.doc[i].name);
writeString (f.doc[i].type);
writeCharacter (f.doc[i].server);
fsi
fsi
fper
faccio

10. Exercici 4: Treball amb tuples i taules de tuples en PHP [30 %]
S’ha emmagatzemat les dades d’una partida de la carta més alta en una sèrie de
tuples de manera que si $t és una tupla
$t[“name”] és el nom del jugador
$t["card"] és un array que conté els codis de les cartes del jugador
la dada que porta la informació original de les partides és una seqüència del tipus:
{ng b nc name1 c1·1 c1·2 ... c1·nc name2 c2·1 c2·2 ... c2nc ... nameng cng·1 cng·2 ... cng·nc } on
• ng : és el nombre de jugadors
• b: és l’aposta unitària.
• nc: es el nombre de cartes que juga cada jugador
• namei és el nom del jugador i.
• ci·j és la carta j del jugador de posició i.
Els jugadors han apostat cadascun una certa quantitat (es determina en cada partida)
i, en acabar, aquests diners se'ls queda qui ha tret la màxima puntuació (o es reparteix
a parts iguals entre els jugadors de màxima puntuació si n'hi ha més d'un)
Tasca: Recollides les dades en variables discretes i un array de tuples, crear un
conjunt de functions en php que manipulin taules de tuples segons les
indicacions. El programa principal i la function per carregar les dades des d'arxiu
a la taula de tuples ja formen part de la plantilla.
El programa s'escriurà a la plantilla prac2_exer4_plantilla.php que es canviarà
de nom a prac2_exer4.php pel lliurament.
Podeu provar el funcionament a l'enllaç
http://prog.uoc.edu/prac2/prac2_exer4.php?filename=data40
Indicacions preceptives
•
•
Els fitxers de dades i d'imatge s'han d'ubicar a la mateixa carpeta de localhost
que el fitxer php.
•
La plantilla porta incorporada la function getData que llegeix el paràmetre de
nom filename, carrega les dades i crea l'array de tuples i també calcula el
muntant de les apostes. Ambdos valors es retornen en paràmetres de sortida.
Per exemple, si $game és l'array de tuples, per saber el nom del primer jugador
de la partida, l'expressió seria $game[0]["name"]2
Per saber quina ha estat la segona carta jugada pel jugador de posició 3
l’expressió seria $game[3][“card”][1]2
•
El codi que va escrit a la plantilla no s'ha de modificar.
•
2
Per a dur a terme aquesta tasca es faciliten els fitxers de seqüències amb el
nom data40 a data44.
S'ha de crear la function putCard que rep el codi d’una carta i posa la imatge
de la carta espanyola corresponent en pantalla. Aquesta function ha de ser la
única manera de mostrar les imatges de carta en la pantalla
recordeu que en PHP la primera posició dels arrays és la posició 0

11. •
S’ha de crear la function cardValue que rep el codi d’una carta i retorna el valor
nominal de la carta (les figures valen 10, 11 i 12 respectivament).
•
S'ha de crear la function showTable que rep un array que conté la sèrie de
cartes d’un jugador i les mostra en la pantalla en una filera. Per mostrar-les
cridarà putCard.
•
S’ha de crear la funtion computeScore que rep un array que conté la sèrie de
cartes d’un jugador i retorna el valor suma de les cartes. Per dur a terme la
seva tasca cridarà cardValue
•
S’ha de crear la function showGame que rep el valor total apostat (entre tots
els jugadors) i la taula de tuples $game i
o calcula la puntuació de cada jugador (que emmagatzema en un array)
o de l'array anterior obté quina és la puntuació màxima de tots els
jugadors i quants jugadors l'han obtingut
o calcula el que s'haurà de pagar a cada guanyador
o per a cada jugador escriu:
En una línia Gamer i el nom del jugador
En la línia següent mostra les cartes del jugador i escriu la
puntuació obtinguda i el que li toca cobrar
•
S'ha de crear la function extractGame que rep un número $n i la taula de
tuples $game i retorna una nova taula de tuples en què cada jugador té les $n
primeres cartes que tenia en $game.
Per exemple. Si $game contenia
name
card
name
card
Shaw
23
Kelly
32
17
8
15
4
22
0
9
14
la crida extractGame(3, $game) retornaria una taula de tuples
name
card
name
card
Shaw
23
Kelly
32
17
8
22
0
En el cas que el número de cartes que es demana que s'extregui sigui superior
al de cartes que havia, es retornarà el nombre de cartes original. Per exemple,
la crida extractGame(7, $game) retornaria, un array de tuples igual a $game.
name
card
name
card
Shaw
23
Kelly
32
17
8
15
4
22
0
9
14
Consells
•
Observareu que getData no dóna informació de la quantitat de jugadors ni de la
quantitat de cartes que juguen a la partida. No és necessari. La quantitat de

12. jugadors es pot obtenir del mateix array de tuples emprant la funció count3
passant com paràmetre la taula de tuples (count ens dirà quantes tuples hi ha) i
la quantitat de cartes que ha jugat cadascun s’haurà d’obtenir de la mateixa
manera del l'array ["card"] del primer jugador count ($game[0]["card"])
•
Podeu reutilitzar directament o modificant-les functions d'altres pràctiques o
PACs, be siguin vostres o de les solucions.
Avaluació
Es valorarà especialment l'aplicació correcta dels esquemes de cerca,
recorregut i/o tractament adequats al problema conjuntament amb l'ús adequat
dels índex de les taules.
3
http://us2.php.net/manual/es/function.count.php

13. //Aquí heu de posar el vostre codi
<?php
/*************FUNCTION PLANTILLA ****************/
function getData(&$totalBet, &$p)
{ //get data File & returns a number & a associative data Array
$filename = $_GET["filename"];
include($filename);
$data = explode(" ", $cadena);
$nGamers= array_shift($data);
$bet= array_shift($data);
$nCards= array_shift($data);
$totalBet= $bet * $nGamers;
for ($i=0; $i < $nGamers; $i++)
{
$p[$i]["name"] = array_shift($data);
for ($j=0; $j < $nCards; $j++)
{
$p[$i]["card"][$j]= array_shift($data);
}
//to check the data entered uncomment the next line
//LF(); print $p[$i]["name"]. " ";print_r($p[$i]["card"]);
}
}// de getData
function LF()
{ //line feed
print "<br />";
}
/******************FUNCTIONS*********************/

14. function putCard($pref, $num)
{
print "<img src='".$pref.$num.".png'>";
}// de putCard
function cardValue($card)
{
$value=$card % 10 + 1;
if ($value>7) $value+=2;
return ($value);
}// de cardValue
//figures (8, 9, 10) have 10, 11 or 12 points
function showTable($table)
{
$long = count ($table);
for ($i=0; $i<$long; $i++)
putCard('e',$table[$i]);
}//de showTable
function computeScore($in)
{
$long = count($in);
$score = 0;
for ($i=0; $i<$long ;$i++) $score += cardValue($in[$i]);
return $score;
}//de computeScore
function showGame($bet, $game)
{
$longGame = count($game);
$longCards= count($game[0]["card"]);
//computes each player score
for ($i=0; $i<$longGame; $i++)
{
$score[$i] = computeScore($game[$i]["card"]);

15. }
//computes how many winners & maxScore
$winners = 0;
$maxScore = 0;
for ($i=0; $i<$longGame; $i++)
{
if ($score[$i] > $maxScore)
{
$maxScore = $score[$i];
$winners = 1;
}
else if ($score[$i] == $maxScore) $winners++;
}
$gain = $bet/$winners;
//shows each gamer cards, score & gain
for ($i=0; $i<$longGame; $i++)
{
LF();
print "<b>Gamer ".$game[$i]["name"]."</b>";
LF();
showTable($game[$i]["card"]);
print "Score: ".$score[$i].". Gain: ";
if ($score[$i]==$maxScore) print $gain;
else print 0;
}
}//de showGame
function extractGame($howManyCards, $in)
{
$longGame = count ($in);
$longCards= count($in[0]["card"]);
$long = min ($howManyCards, $longCards);

16. for($i=0; $i<$longGame; $i++)
{
$out[$i]["name"] = $in[$i]["name"];
for ($j=0; $j<$long; $j++) $out[$i]["card"][$j] = $in[$i]["card"][$j];
}
if ($long < $howManyCards)
{
LF();
print "There are less than $howManyCards cards in hand, assumed $long cards";
}
return $out;
}//de extractGame
/******************MAIN*********************/
getData($bet, $game); //$game is records array
LF();
print "<h3>Original Data</h3>";
showGame($bet, $game);
LF();LF();LF();LF();
print "<h3>Extract first two cards</h3>";
$game2 = extractGame(2, $game);
showGame($bet, $game2);
LF();LF();LF();LF();
print "<h3>Extract first six cards</h3>";
$game6 = extractGame(6, $game);
showGame($bet, $game6);
?>