Show page

Differences

This shows you the differences between two versions of the page.

--- programare:test2_scrabble [2020/11/22 00:44]
laurentiu.stefan97
+++ programare:test2_scrabble [2020/11/30 12:01] (current)
alexandru.mindru [Restrictii si precizari]
@@ Line 3: / Line 3: @@
   * Responsabili:
-     * [[todo@gmail.com|Tăzlăuanu Bianca]]
+     * [[tazlauanubianca30@gmail.com |Tăzlăuanu Bianca]]
-     * [[todo@gmail.com|Mîndru Alexandru-Ionuț]]
+     * [[alexandru20059@gmail.com|Mîndru Alexandru-Ionuț]]
      * [[steflaurentiu@gmail.com|Ștefan Laurențiu]]
-  * Data publicării: **22.11.2020**
+  * Data publicării: **23.11.2020**
   * Deadline soft: **TODO**
   * Deadline soft: **TODO**
@@ Line 13: / Line 13: @@
 /*
 <note important>
-**Atentie! deadline-ul soft coincide cu cel hard! Prin urmare, nu se vor mai accepta submisii dupa data de 13.01.2020!**
+****Atentie!** deadline-ul soft coincide cu cel hard! Prin urmare, nu se vor mai accepta submisii dupa data de 13.01.2020!**
 </note>
 */
@@ Line 29: / Line 29: @@
 Tema se bazeaza pe o forma a jocului de Scrabble in care va trebui sa folositi in mod special matrici si functii pentru prelucrarea sirurilor de caractere. Scopul final este implementarea completa a jocului astfel incat doi participanti (programul vostru impotriva checker-ului) sa poata sa joace alternativ si sa se determine un castigator.
-==== Descriere====
+==== Descriere ====
 Jocul are la baza doua table de joc pastrate sub forma unor matrici patratice de dimensiune 15 x 15. O tabla (matrice) va pastra cuvintele “jucate” de cei doi jucatori pe parcursul jocului, in timp ce cealalta tabla va fi folosita pentru a marca casute ce ofera punctaj bonus.
 Pentru claritate, vom folosi termenul de tabla de joc pentru a ne referi la matricea care stocheaza cuvinte si tabla de bonusuri pentru matricea care va stoca pozitiile ce ofera puncte bonus in joc.
-==== Tabla de joc====
+==== Tabla de joc ====
 Tabla de joc va contine cuvinte atat pe lungime, cat si pe latime. Fiecare casuta din matrice va stoca un singur caracter dintr-un cuvant sau caracterul ‘.’ daca este goala.
-Initial veti avea o matrice de caractere cu dimensiunea 15 x 15 in care fiecare element din matrice va contine caracterul ‘.’ (deoarece nu avem niciun cuvant salvat la inceput). In exemplul de mai jos este o matrice in care au fost inserate mai multe cuvinte: “CAT”, “AIRPLANE”, “TRAIN”, “PROGRAM”, “LECTURE”.\\
+Initial veti avea o matrice de caractere cu dimensiunea 15 x 15 in care fiecare element din matrice va contine caracterul ‘.’ (deoarece nu avem niciun cuvant salvat la inceput). In exemplul de mai jos este o matrice in care au fost inserate mai multe cuvinte: “CAT”, “AIRPLANE”, “TRAIN”, “PROGRAM”, “LECTURE”.
+{{ :programare:teme_2020:scrabble_image1.png?700 }}
-{{ :programare:teme_2020:scrabble_image1.png?500}}
+==== Tabla de punctaj bonusuri ====
+Aceasta tabla (bonus_board) este deja data in fisierul header (scrabble.h) ce se afla in arhiva cu checker-ul si va ramane neschimbata pe parcursul intregii teme.
+Aceasta tabla va avea aceeasi dimensiune ca si tabla de joc, de 15 X 15. Tabla este populata cu valori de 0, 1 si 2 cu urmatoarea semnificatie:
+  * 0 - niciun bonus
+  * 1 - punctajul se dubleaza daca pe patratica respectiva se afla o litera apartinand unui cuvant care are substringul “XX” in compozitie, se da substringul la fiecare joc
+  * 2 - punctajul se tripleaza daca pe patratica respectiva se afla o litera apartinand unui cuvant care se termina cu substringul “XX”, se da substringul la fiecare joc
-==== Cerinte ====
+Modul in care se calculeaza punctajul va fi detaliat ulterior in cerintele temei. Matricea arata in felul urmator:
+{{ :programare:teme_2020:scrabble_image2.png?500 }}
-Veti avea de rezolvat 5 task-uri obligatorii si un task bonus.
+==== Lista de cuvinte ====
+Pe langa table de bonusuri, in fisierul header scrabble.h din arhiva veti mai primi un vector de cuvinte pe care il veti folosi la anumite task-uri din tema. Vectorul se cheama words si contine 100 de string-uri.
-==== Task 1: Black&White (10p): ====
+<note warning> **Atentie!** Pentru fiecare cerinta veti primi datele de intrare la standard input. De fiecare data primul input pe care il va primi programul vostru este numarul taskului (0-5 pentru tema, 6 pentru bonus) urmand ca mai apoi sa cititi restul de date asa cum este descris pentru fiecare cerinta in parte. </note>
-Acest task presupune transformarea unei imagini color intr-o imagine alb-negru.
-Procedeul prin care o imagine color se transforma intr-o imagine alb-negru este urmatorul: **fiecare** pixel din imaginea color, fie acesta (R, G, B), va deveni (X, X, X) unde X = [ (R + G + B) / 3] unde prin [] se intelege **parte intreaga** (inferioara). De exemplu pixelul (3, 2, 2) va deveni (2, 2, 2), iar pixelul (10, 20, 30) va deveni (20, 20, 20).
+==== Cerinte ====
-Daca numele imaginii este **<nume>.bmp** atunci imaginea alb-negru se va scrie in fisierul **<nume>_black_white.bmp** (de exemplu, daca prima linie din fisierul input.txt este image.bmp atunci imaginea alb negru se va scrie in fisierul image_black_white.bmp).
+Veți avea de rezolvat 6 cerințe obligatorii și o cerință bonus.
-Exemplu concret: Daca imaginea color arata astfel:
+==== Cerinta 0: (2 Puncte) - 1 test ====
-{{ :programare:teme_2016:sunflower.png?200 | Imaginea originala}}
+Pentru rezolvarea task-urilor veti avea nevoie de tabla de joc. Tabla de bonus este data deja in fisierul header, dar tabla de joc va trebui sa o declarati si sa o initializati voi.
-Dupa transformare ar trebui sa arate astfel:
+Inainte de a incepe rezolvarea exercitiilor declarati o matrice de 15 X 15. Dupa ce o declarati, populati matricea cu valoarea ‘.’ (caracterul punct).
-{{ :programare:teme_2016:sunflower_blackwhite.png?500 | Imaginea alb-negru}}
-==== Task 2: No-Crop (20p): ====
+La input veti primi valoarea 0 (pentru task-ul 0). La standart output va trebui sa afisati matricea goala folosind functia print_board.
-Cu siguranta vi s-a intamplat cel putin o data sa nu puteti posta o poza pe o retea de socializare (ex. Instagram) din motiv ca poza respectiva nu este patratica si aceasta sa fie decupata, pierzand informatii utile din imaginea initiala. Ne dorim sa implementam functionalitatea unei aplicatii care rezolva aceasta problema, operatia asociata mai fiind numita de no-crop. Acest task presupune bordarea unei imagini in scopul obtinerii variantei patratice a acesteia.
+==== Cerinta 1: (18 Puncte) - 9 teste ====
+Pentru aceasta cerinta va trebui sa cititi numarul intreg N urmat de N linii continand coordonatele unui cuvant si cuvantul respectiv. Dupa ce faceti citirea unei linii, adaugati-o la coordonatele corespunzatoare in matricea de joc (cea pe care ati declarat-o la cerinta 0). Cuvantul va fi pastrat caracter cu caracter in matrice incepand cu coordonatele date.
-Procedeul prin care se transforma o imagine oarecare intr-o imagine patratica este:
+Dupa ce ati salvat toate cele N cuvinte puteti sa afisati matricea apeland functia de afisare in felul urmator: <code>print_board(game_board)</code>.
-  * Se determina maximul intre latimea si inaltimea imaginii
-  * Dimensiunea ce nu este maxima trebuie "completata" in mod simetric cu **pixeli albi (valorea (255,255,255)** la margini (stanga si dreapta la completarea coloanelor, respectiv sus si jos la completarea liniilor) astfel incat dimensiunea mai mica sa devina egala cu cealalta dimensiune
-  * In cazul in care diferenta intre dimensiunile imaginii este impara, atunci prima zona de completare va lua partea intreaga din diferenta (stanga sau sus), iar a doua zona va lua partea intreaga din diferenta + 1
-Sa presupunem ca avem urmatoarea imagine:
+<note warning>**Atentie!** Matricea in care pastrati cuvintele va trebui sa aiba caracterul ‘.’ pe pozitiile neocupate pentru ca functia de afisare sa functioneze.</note>
-<html>
+Se da un input de forma:
-<pre>
+<code>1
-(1 1 1) (1 1 1) (1 1 1) (1 1 1) (1 1 1)
+N
-(1 1 1) (1 1 1) (1 1 1) (1 1 1) (1 1 1)
+Y1 X1 D1 WORD1
-</pre>
+Y2 X2 D2 WORD2
-</html>
+…
+N -> numar de cuvinte primite
+Yi -> indicele pe verticala unde va fi plasat cuvantul (linia in matrice)
+Xi -> indicele pe orizontala unde va fi plasat cuvantul (coloana in matrice)
+Di -> directia in care este scris cuvantul:
+* Daca D == 0: cuvantul e scris pe orizontala, de la (Yi, Xi) spre dreapta
+* Daca D == 1: cuvantul e scris pe verticala, de la (Yi, Xi) in jos
+Yi - indicele liniei unde este plasata prima litera din cuvant
+Xi - indicele coloanei unde este plasata prima litera din cuvant
+(Yi, Xi) - pozitia de unde incepe cuvantul, de la</code>
-Observam ca inaltimea este egala cu 2, iar latimea este egala cu 5. Prin urmare, inaltimea imaginii trebuie completata astfel incat aceasta sa devina egala cu latimea (5). Diferenta intre cele doua dimensiuni este 3, asa ca imaginea rezultat va arata astfel:
+<note warning>**Atentie!** Numerotarea liniilor se face din coltul stanga sus si incepand cu indicele 0!</note>
-<html>
+<note warning>**Atentie!** Pentru acest task se garanteaza ca nu vor fi date cuvinte care sa iasa din dimensiunile tablei.</note>
-<pre>
-(255 255 255) (255 255 255) (255 255 255) (255 255 255) (255 255 255)
+Un exemplu de input este urmatorul:
-(1 1 1)       (1 1 1)       (1 1 1)       (1 1 1)       (1 1 1)
+<code>1
-(1 1 1)       (1 1 1)       (1 1 1)       (1 1 1)       (1 1 1)
-(255 255 255) (255 255 255) (255 255 255) (255 255 255) (255 255 255)
+4 0 CAT
-(255 255 255) (255 255 255) (255 255 255) (255 255 255) (255 255 255)
+6 1 TRAIN
-</pre>
+6 0 AIRPLANE
-</html>
+9 1 PROGRAM
+10 1 LECTURE</code>
+Acest input va produce urmatorul output:
+{{ :programare:teme_2020:scrabble_image3.png?400 }}
-Daca numele imaginii este **<nume>.bmp** atunci imaginea rezultata patratica se va scrie in fisierul **<nume>_nocrop.bmp** (de exemplu, daca prima linie din fisierul de input este image.bmp atunci imaginea rezultata se va scrie in fisierul image_nocrop.bmp).
+==== Cerinta 2: (20 Puncte) - 10 teste ====
+Pentru aceasta cerinta va trebui sa calculati punctajul obtinut de doi jucatori fara a tine cont de punctele bonus. Veti primi un input exact ca la task-ul precedent, dar de aceasta data veti afisa punctajul total al celor doi jucatori.
-Exemplu concret: Daca imaginea initiala arata astfel:
+Calcularea scorului unui cuvant se face prin insumarea scorului fiecarei litere din cuvant. Scorurile literelor sunt urmatoarele:
-{{ :programare:teme_2019:klaus_nocrop.jpg?200 | Imaginea originala}}
+<code>A, E, I, L, N, O, R, S, T, U - 1 Punct
+D, G - 2 Puncte
+B, C, M, P - 3 Puncte
+F, H, V, W, Y - 4 Puncte
+K - 5 Puncte
+J, X - 8 Puncte
+Q, Z - 10 Puncte</code>
-Atunci noua imagine ar trebui sa arate astfel:
+<note tip>**Tip!** Pentru a tine informatiile pentru scorurile fiecarei litere puteti tine un vector de dimensiune 26 cu toate valorile puse in ordine alfabetica. Pentru a afla la ce index in vector se afla scorul unei litere, substrageti valoarea ‘A’ din litera cautata. </note>
-{{ ::programare:teme_2019:klaus_crop.jpeg?200 | Imaginea bordata}}
-<note important>
-Frame-ul atasat imaginii de mai sus are doar scopul de a evidentia marginiile imaginii intrucat fundalul paginii de wiki este tot alb.
-</note>
-<note important>
+<note warning>**Atentie!** Doar pentru acest task nu se va tine cont de tabla de bonusuri!</note>
-La acest task veti avea de adus modificari si in headerele imaginii rezultat, dar numai in campurile **width** si **height** din Info Header!
-</note>
-==== Task 3: Convolutional Layers (20p): ====
+Se da un input de forma:
+<code>2
+N
+Y1 X1 D1 WORD1
+Y2 X2 D2 WORD2
+…
+Unde:
+XX este substringul pentru bonusul primit pentru casutele marcate cu 1.
+YY este substringul pentru bonusurile primite pentru casutele marcate cu 2.
+N este numarul de cunvinte
+Xi, Yi, WORDi sunt coordonatele pentru cuvantul WORDi
+Di este directia in care este scris cuvantul</code>
-In cadrul acestui task va trebui sa aplicati anumite [[https://en.wikipedia.org/wiki/Kernel_(image_processing)|filtre]] pe o imagine. Un filtru convolutional este o matrice care este aplicata fiecarui pixel din imagine pentru a obtine noul pixel. In continuare o sa vedem ce inseamna sa aplici o matrice (filtru de 3x3) unui pixel. Fie $(B_{22},G_{22},R_{22})$ un pixel din imagine care are urmatorii vecini:
+Output-ul va fi sub forma urmatoare:
+<code>Player 1: W Points
+Player 2: T Points
-$$ \begin{bmatrix}
+W este scorul obtinut de primul jucator.
-(B_{11},G_{11},R_{11}) & (B_{12},G_{12},R_{12}) & (B_{13},G_{13},R_{13}) \\
+T este scorul obtinut de al doilea jucator.
-(B_{21},G_{21},R_{21}) & (B_{22},G_{22},R_{22}) & (B_{23},G_{23},R_{23}) \\
+Textul pentru fiecare jucator va fi afisat pe o linie separata.</code>
-(B_{31},G_{31},R_{31}) & (B_{32},G_{32},R_{32}) & (B_{33},G_{33},R_{33})
-\end{bmatrix} $$
+Un exemplu de input este urmatorul:
+<code>2
+
+4 0 CAT
+6 1 TRAIN
+6 0 AIRPLANE
+9 1 PROGRAM
+10 1 LECTURE </code>
-si fie filtrul:
+Pentru acest input se obtine outputul urmator:
+<code>Player 1: 24 Points
+Player 2: 17 Points</code>
-$$ A = \begin{bmatrix}
+Explicatie:
-a_{11} & a_{12} & a_{13} \\
+<code>Jucatorului 1 ii revin urmatoarele cuvinte din input: “CAT”, “AIRPLANE”, “LECTURE”
-a_{21} & a_{22} & a_{23} \\
+Scor(Jucator 1) = Scor(“CAT”) + Scor(“AIRPLANE”) + Scor(“LECTURE”)
-a_{31} & a_{32} & a_{33}
+Scor(Jucator 1) = (3 + 1 + 1) + (1 + 1 + 1 + 3 + 1 + 1 + 1 + 1) + (1 + 1 + 3 + 1 + 1 + 1 + 1)
-\end{bmatrix} $$
+Scor(Jucator 1) = 5 + 10 + 9 = 24
+Scor(Jucator 2) = Scor(“TRAIN”) + Scor(“PROGRAM”) = 5 + 12 = 17</code>
-Atunci, in imaginea rezultata in urma aplicarii filtrului **A**, pixelul $(B_{22},G_{22},R_{22})$ va fi inlocuit cu $(B'_{22},G'_{22},R'_{22})$ unde:
-$$ B'_{22} = \sum_{i=1}^3 \sum_{j=1}^3 B_{ij}a_{ij} $$
+==== Cerinta 3: (30 Puncte) - 10 teste ====
-$$ G'_{22} = \sum_{i=1}^3 \sum_{j=1}^3 G_{ij}a_{ij} $$
+Pentru aceasta cerinta va trebui sa calculati punctajul celor doi jucatori, ca la task-ul precedent, dar de aceasta data va trebui sa verificati daca sunt indeplinite conditiile de bonus.
-$$ R'_{22} = \sum_{i=1}^3 \sum_{j=1}^3 R_{ij}a_{ij} $$
-<note>Daca in urma calculului uneia dintre cele 3 valori de mai sus, suma rezultata este < 0 atunci valoarea se va seta la 0. Asemanator, daca suma este > 255 atunci componenta corespunzatoare din pixel se va seta la 255. </note>
+Se da un input de forma:
+<code>3
+XX
+YY
+N
+Y1 X1 D1 WORD1
+Y2 X2 D2 WORD2
+…</code>
-<note important>**Daca un pixel are vecini in afara imaginii, la calculul sumei acesti vecini vor avea valoarea (0, 0, 0).**</note>
+Unde:
+<code>XX este substringul pentru bonusul primit pentru casutele marcate cu 1.
+YY este substringul pentru bonusurile primite pentru casutele marcate cu 2.
+N este numarul de cunvinte
+Xi, Yi, WORDi sunt coordonatele pentru cuvantul WORDi
+Di este directia in care este scris cuvantul</code>
-Sa presupunem ca avem urmatoarea imagine:
+Output-ul va fi sub forma urmatoare:
+<code>Player 1: X Points
+Player 2: Y Points</code>
-<html>
+Daca un cuvant are in componenta sa o litera la coordonatele X,Y, iar la aceleasi coordonate pe tabla de bonus casuta respectiva este marcata cu 1, se va verifica daca indeplineste conditia de bonus definita mai sus, iar la final, dupa ce se calculeaza punctajul pentru intregul cuvant, punctajul va fi inmultit cu 2. Acelasi rationament se aplica si pentru patratelele marcate cu 2, dar de data aceasta se va inmulti rezultatul cu 3. Regulile de aplicare a bonusul sunt detaliate la inceputul enuntului la rubrica “Tabla de bonusuri”.
-<pre>
-(2 2 2)    (3 3 3)   (0 0 0)   (0 0 0)
-(10 10 10) (1 1 1)   (0 0 0)   (0 0 0)
-(0 0 0)    (0 0 0)  (50 50 5)  (0 0 0)
-(0 0 0)    (0 0 0) (240 0 240) (0 0 0)
-</pre>
-</html>
-<note warning>Primul pixel (cel de pe prima linie si de pe prima coloana) trebuie sa fie pixelul din coltul stanga sus al imaginii (atunci cand este afisata pe ecran)! Atentie la faptul ca imaginea se citeste rasturnata din fisierul BMP. La aplicarea filtrelor trebuie sa considerati dispunerea de mai sus (nu cea din fisier). Cu alte cuvinte, liniile sunt dispuse crescator de sus in jos, prima linie fiind si prima linie afisata pe ecran, iar coloanele sunt dispuse crescator de stanga la dreapta. </note>
+Exemplu: (Vom folosi matricea de bonusuri de mai sus)
+<code>3
+LA
+IN
+
+4 0 CAT
+6 1 TRAIN
+6 0 AIRPLANE
+9 1 PROGRAM
+10 1 LECTURE</code>
-Pentru imaginea de mai sus, fisierul BMP ar arata astfel (ignorand cele 2 headere):
+<code>Scor(“TRAIN”) =  (1 + 1 + 1 + 1 + 1) * 3 = 15
+Pentru cuvantul “TRAIN” dupa ce calculam scorul fara bonus vom inmulti cu 3 deoarece cuvantul se termina cu silaba “IN”, iar litera “I” se afla la pozitia (7, 6) - pe aceeasi pozitie in tabla de bonusuri se afla cifra 2 - bonus_board[7][6] == 2.
-<html>
+Scor(“AIRPLANE”) =  (1 + 1 + 1 + 3 + 1 + 1 + 1 + 1) * 2 = 20
-<pre>
+Pentru cuvantul “AIRPLANE” dupa ce calculam scorul fara bonus vom inmulti cu 2 deoarece litera “R” se afla pe pozitia (6, 8) (bonus_board[6][8] = 1).</code>
-(0 0 0)    (0 0 0) (240 0 240) (0 0 0)      <b>No padding</b>
-(0 0 0)    (0 0 0)  (50 50 5)  (0 0 0)      <b>No padding</b>
-(10 10 10) (1 1 1)   (0 0 0)   (0 0 0)      <b>No padding</b>
-(2 2 2)    (3 3 3)   (0 0 0)   (0 0 0)      <b>No padding</b>
-</pre>
-</html>
-Pe imaginea de mai sus dorim sa aplicam urmatorul filtru:
+<note warning>Atentie! Daca cuvant se suprapune cu doua casute de bonus marcate cu 1 si o casuta de bonus marcata cu 2, daca sunt indeplinite conditiile de bonus, atunci scorul va fi inmultit cu * 2 * 2 * 3.</note>
-$$ \begin{bmatrix}0 & 1 & 0\\1 & 1 & 1\\0 & 1 & 0 \end{bmatrix} $$
-Imaginea rezultata va fi:
+==== Cerinta 4: (50 Puncte) - 10 teste ====
+Pentru acesta cerinta va trebui sa gasiti urmatorul cuvant pe care Player 2 poate sa il joace. Mai exact, veti primi ca input lista de cuvinte jucate pana in momentul respectiv de cei doi jucatori. Player 1 pune primul cuvant, apoi Player 2, si asa mai departe. Vor fi date un numar impar de mutari, astfel incat voi va trebui sa gasiti urmatorul cuvant pe care Player 2 poate sa il foloseasca.
-<html>
+Gasiti primul cuvant din vectorul de cuvinte (vectorul words din fisierul scrabble.h) care indeplineste conditiile:
-<pre>
+  * Face parte din lista de cuvinte (vectorul words din fisierul scrabble.h)
-(15 15 15) (6 6 6)     (3 3 3)      (0 0 0)
+  * Cuvantul nu e deja pus pe tabla de niciunul dintre jucatori
-(13 13 13) (14 14 14)  (51 51 6)    (0 0 0)
+  * Prima litera din cuvant se afla deja pe tabla si cuvantul poate fi pus in continuarea literei respective, fie pe orizontala, fie pe verticala. (Pentru a verifica acest lucru, se cauta pe tabla prima litera din cuvant de la coltul stanga sus, linie cu linie, pana la coltul dreapta jos al tablei de joc).
-(10 10 10) (51 51 6)   (255 50 245) (50 50 5)
+  * Cuvantul nu iese din marginile tablei de joc si nu se suprapune cu alte cuvinte (inafara de prima litera)
-(0 0 0)    (240 0 240) (255 50 245) (240 0 240)
-</pre>
-</html>
-Pentru rezolvarea acestui task va trebui sa aplicati un filtru asupra imaginii citite la taskurile anterioare.
+Sa se adauge cuvantul respectiv pe tabla de joc si sa se afiseze tabla. Daca un cuvant poate fi pus si pe orizontala si pe verticala, cuvantul va fi pus pe orizontala.
-Daca numele imaginii este **<nume>.bmp** atunci imaginea rezultata dupa aplicarea filtrului se va scrie in fisierul **<nume>_filter.bmp** (de exemplu, daca prima linie din fisierul input.txt este image.bmp atunci imaginea rezultata se va scrie in fisierul image_filter.bmp).
+Inputul va fi de forma urmatoare:
+<code>4
+XX
+YY
+N
+Y1 X1 D1 WORD1
+Y2 X2 D2 WORD2
+…
+Yn Xn Dn WORDn</code>
+Unde:
+<code>XX este substringul pentru bonusul primit pentru casutele marcate cu 1.
+YY este substringul pentru bonusurile primite pentru casutele marcate cu 2.
+N este numarul de cunvinte
+Xi, Yi, WORDi sunt coordonatele pentru cuvantul WORDi
+Di este directia in care este scris cuvantul</code>
-Exemplu concret: Daca imaginea initiala arata astfel:
+Exemplu:
-{{ :programare:teme_2019:klaus-task3-original.jpg?200 | Imaginea originala}}
+<code>4
+LA
+IN
+
+4 0 CAT
+6 1 TRAIN
+6 0 AIRPLANE
+9 1 PROGRAM
+10 1 LECTURE</code>
-Iar filtrul pe care dorim sa il aplicam este:
+Pe baza regulilor definite anterior este ales cuvantul “COMMUNITY”. Output-ul va fi urmatorul:
-$$ \begin{bmatrix}0 & 1 & 0\\1 & -4 & 1\\0 & 1 & 0 \end{bmatrix} $$
+{{ :programare:teme_2020:scrabble_image4.png?400 }}
+==== Cerinta 5: (30 Puncte) - 10 teste ====
+Pentru aceasta cerinta va trebui sa faceti acelasi lucru ca si la task-ul precedent, dar de aceasta data veti alege primul cuvant din lista de cuvinte care va aduce castigul (sau remiza) pentru Player 2. La calcularea scorurilor se va tine cont de bonus.  Cuvantul selectat trebuie sa incapa pe tabla de joc si sa nu se repete. Daca gasiti un astfel de cuvant atunci la output se va afisa tabla de joc care va contine si cuvantul respectiv, in caz contrat se va afisa mesajul “FAIL!”.
-Atunci noua imagine ar trebui sa arate astfel:
+Pasi in rezolvarea task-ului:
-{{ ::programare:teme_2019:klaus-task3-edgedec.jpg?200 | Imaginea cu filtru aplicat}}
+  * Se calculeaza scorul Player-ului 1.
+  * Se calculeaza scorul Player-ului 2.
+  * Se cauta cuvantul optim pe care Player 2 poate sa il joace (acel cuvant care adunat la scorul pe care Player 2 il are deja va produce in scor mai mare *sau* egal cu scorul Player-ului 1)
+  * Daca se gaseste cuvantul va fi afisata tabla ce va contine noul cuvantul.
+  * Daca nu se gaseste cuvantul va fi afisat mesajul “FAIL!”.
-<note important> Filtrele de convolutie vor avea mereu dimensiune impara! </note>
+Un cuvant este optim pentru Player 2 daca:
+  * Face parte din lista de cuvinte (vectorul words din fisierul scrabble.h)
+  * Cuvantul nu e deja pus pe tabla de niciunul dintre jucatori
+  * Prima litera din cuvant se afla deja pe tabla si cuvantul poate fi pus in continuarea literei respective, fie pe orizontala, fie pe verticala. (Pentru a verifica acest lucru, se cauta pe tabla prima litera din cuvant de la coltul stanga sus, linie cu linie, pana la coltul dreapta jos  al tablei de joc).
+  * Cuvantul nu iese din marginile tablei de joc si nu se suprapune cu alte cuvinte (inafara de prima litera)
+  * Produce cel mai mare scor posibil incluzand bonusurile
-==== Task 4: Min/Max Pooling Layer (10p) ====
+Inputul va fi de forma urmatoare:
+<code>5
+XX
+YY
+N
+X1 Y1 D1 WORD1
+X2 Y2 D2 WORD2
+…
+Xn Yn Dn WORDn</code>
+Unde:
+<code>XX este substringul pentru bonusul primit pentru casutele marcate cu 1.
+YY este substringul pentru bonusurile primite pentru casutele marcate cu 2.
+N este numarul de cunvinte
+Xi, Yi, WORDi sunt coordonatele pentru cuvantul WORDi
+Di este directia in care este scris cuvantul</code>
-In cadrul acestui task va trebui sa aplicati anumite [[https://machinelearningmastery.com/pooling-layers-for-convolutional-neural-networks/)|filtre de pooling]] pe o imagine, si anume Max Pooling Layer respectiv Min Pooling Layer. Un filtru de pooling este o operatie care este aplicata fiecarui pixel din imagine pentru a obtine un nou pixel. In continuare o sa vedem ce inseamna sa aplici o operatie de min/max pooling unui pixel. Fie $(B_{22},G_{22},R_{22})$ un pixel din imagine care are urmatorii vecini:
+Exemplu:
+<code>5
+LA
+IN
+
+4 0 CAT
+6 1 TRAIN
+6 0 AIRPLANE
+9 1 PROGRAM
+10 1 LECTURE  <code>
-$$ \begin{bmatrix}
+Player 1 are cuvintele: “CAT”, “AIRPLANE”, “LECTURE”
-(B_{11},G_{11},R_{11}) & (B_{12},G_{12},R_{12}) & (B_{13},G_{13},R_{13}) \\
+Player 2 are cuvintele: “TRAIN”, “PROGRAM”
-(B_{21},G_{21},R_{21}) & (B_{22},G_{22},R_{22}) & (B_{23},G_{23},R_{23}) \\
-(B_{31},G_{31},R_{31}) & (B_{32},G_{32},R_{32}) & (B_{33},G_{33},R_{33})
-\end{bmatrix} $$
-Atunci, in imaginea rezultata in urma aplicarii filtrului de pooling **max** de dimensiune **3**, pixelul $(R_{22},G_{22},B_{22})$ va fi inlocuit cu $(B'_{22},G'_{22},R'_{22})$ unde:
+<code>Scor(Player 1) = TODO
+Scor(Player 2) = TODO</code>
-$$ B'_{22} = \max(B_{ij}a_{ij}),\ \ \ i=1..3,\ j=1..3 $$
+==== Cerinta BONUS: (10 Puncte) - 10 teste ====
-$$ G'_{22} = \max(G_{ij}a_{ij}),\ \ \ i=1..3,\ j=1..3 $$
+Pentru bonus va trebui sa simulati jocul intre cei doi jucatori. Mai exact, daca inainte la input primeati alternativ cuvintele pentru Player 1 si Player 2, de aceasta data veti primi numai cuvintele pentru Player 1, iar cele pentru Player 2 va trebui sa le alegeti voi din vectorul de cuvinte.
-$$ R'_{22} = \max(R_{ij}a_{ij}),\ \ \ i=1..3,\ j=1..3 $$
-Analog se aplica si pentru filtrul de pooling **min**.
+Pasi in rezolvarea task-ului:
+  * Se citeste numarul task-ului (6), substringurile XX, YY si N
+  * Pentru i = 0 la N - 1:
+  * Se citeste Yi Xi Di WORDi (Mutarea cu numarul i a Player-ului 1)
+  * Se pune (salveaza) pe tabla la coordonatele date cuvant WORDi
+  * Se cauta cuvantul optim pe care Player 2 poate sa il joace
+  * Se pune (salveaza) pe tabla la coordonatele gasite cuvantul pentru Player 2
+  * Dupa ce sunt citite cele N cuvinte ale Player-ului 1 jocul se termina
+  * La finalul jocului se afiseaza tabla print_board(board) si pe linia imediat urmatoare
+  * “Player X Won!” unde X este 1 daca Player 1 a castigat sau 2 daca Player 2 a castigat.
-<note important>In functie de dimensiunea specificata pentru filtru, se va considera pentru fiecare element matricea corespunzatoare de dimensiune **k**, unde **k** este dimensiunea filtrului de pooling.</note>
+Un cuvant este optim pentru Player 2 daca:
+F  * ace parte din lista de cuvinte (vectorul words din fisierul scrabble.h)
+  * Cuvantul nu e deja pus pe tabla de niciunul dintre jucatori
+  * Prima litera din cuvant se afla deja pe tabla si cuvantul poate fi pus in continuarea literei respective, fie pe orizontala, fie pe verticala. (Pentru a verifica acest lucru, se cauta pe tabla prima litera din cuvant de la coltul stanga sus, linie cu linie, pana la coltul dreapta jos al tablei de joc).
+  * Cuvantul nu iese din marginile tablei de joc si nu se suprapune cu alte cuvinte (inafara de prima litera)
+  * Produce cel mai mare scor posibil incluzand bonusurile
-<note important>**Daca un pixel are vecini in afara imaginii, la calculul minimului/maximului acesti vecini vor avea valoarea (0, 0, 0).**</note>
+Inputul va fi de forma urmatoare:
+<code>6
-Sa presupunem ca avem urmatoarea imagine:
+XX
+YY
-<html>
-<pre>
-(2 2 2)    (3 3 3)   (0 0 0)     (0 0 0)
-(10 10 10) (1 1 1)   (7 7 7)     (0 0 0)
-(12 12 12) (0 0 0)   (50 50 5)   (0 0 0)
-(0 0 0)    (0 0 0)   (240 0 240) (0 0 0)
-</pre>
-</html>
-<note warning>Primul pixel (cel de pe prima linie si de pe prima coloana) trebuie sa fie pixelul din coltul stanga sus al imaginii (atunci cand este afisata pe ecran)! Atentie la faptul ca imaginea se citeste rasturnata din fisierul BMP. La aplicarea filtrelor trebuie sa considerati dispunerea de mai sus (nu cea din fisier). Cu alte cuvinte, liniile sunt dispuse crescator de sus in jos, prima linie fiind si prima linie afisata pe ecran, iar coloanele sunt dispuse crescator de stanga la dreapta. </note>
-Pentru imaginea de mai sus, fisierul BMP ar arata astfel (ignorand cele 2 headere):
-<html>
-<pre>
-(0 0 0)    (0 0 0) (240 0 240) (0 0 0)      <b>No padding</b>
-(12 12 12) (0 0 0)  (50 50 5)  (0 0 0)      <b>No padding</b>
-(10 10 10) (1 1 1)   (7 7 7)   (0 0 0)      <b>No padding</b>
-(2 2 2)    (3 3 3)   (0 0 0)   (0 0 0)      <b>No padding</b>
-</pre>
-</html>
-Pe imaginea de mai sus dorim sa aplicam filtrul **max** de pooling de dimensiune 3:\\
-Imaginea rezultata va fi:
-<html>
-<pre>
-(12 12 12) (240 50 240) (240 50 240) (240 50 240)
-(12 12 12) (240 50 240) (250 50 240) (240 50 240)
-(12 12 12) (50 50 12)   (50 50 7)    (50 50 7)
-(10 10 10) (10 10 10)   (7 7 7)      (7 7 7)
-</pre>
-</html>
-Pentru rezolvarea acestui task va trebui sa aplicati un filtru de pooling (diferentiat prin **m** pentru filtru de min, respectiv **M** pentru filtru de max) asupra imaginii citite la taskurile anterioare.
-Daca numele imaginii este **<nume>.bmp** atunci imaginea rezultata dupa aplicarea filtrului se va scrie in fisierul **<nume>_pooling.bmp** (de exemplu, daca prima linie din fisierul input.txt este image.bmp atunci imaginea rezultata se va scrie in fisierul image_pooling.bmp).
-Exemplu concret: Daca imaginea initiala arata astfel:
-{{ :programare:teme_2019:initial_tree.jpg?200 | Imaginea originala}}
-Iar filtrul pe care vrem sa il aplicam este unul de **max pooling** de dimensiune 5, imaginea rezultata va fi:
-{{ ::programare:teme_2019:max_pooling_tree.jpg?200 | Imaginea cu filtru aplicat}}
-<note important> Filtrele de pooling vor avea mereu dimensiune impara! </note>
-==== Task 5: Clustering (30p) ====
-In cadrul acestui task, ne propunem sa grupam (clusterizam) pixelii din cadrul imaginii noastre in zone asemanatoare de pixeli cu scopul de a evidentia aceste zone vizual sau pentru a transforma imaginea initiala intr-o imagine cat mai artificiala/simplista (o sa vedem in exemplul concret cum arata o imagine clusterizata).
-Pentru a stii cum incadram doi pixeli oarecere intr-o zona, operatia de clustering va primi ca input o valoare de **threshold** (prag) si o va folosi dupa cum este descris si in algoritmul de mai jos asociat operatiei.
-Algoritmul de clustering pe care o sa il implementati (si descrie formal ceea ce a fost descris mai sus) este urmatorul:
-**1)** Se alege un pixel din imagine care nu a fost inclus in nicio zona. Fie acest pixel $ (R, G, B) $. Daca toti pixelii au fost inclusi intr-o zona atunci algoritmul s-a terminat;
-**2)** Pornind de la acest pixel se detemina zona de pixeli care satisface simultan urmatoarele conditii:
-         * Pixelul ales la punctul **1)** face parte din aceasta zona;
-         * Oricare ar fi un pixel din zona $ (R',G',B') $ trebuie ca $ |R - R'| + |G - G'| + |B - B'| <= threshold$ unde threshold este o valoare data ca input algoritmului. De asemenea pixelul $ (R',G',B') $ nu trebuie sa fi fost deja inclus intr-o alta zona. Daca $ (R',G',B') $ era deja inclus intr-o alta zona, chiar daca s-ar indeplinii conditia ca suma modulelor sa fie mai mica decat un threshold atunci pixelul $ (R',G',B') $ nu va fi inclus in zona curenta;
-         * Zona gasita este maximala. Cu alte cuvinte, nu mai exista nici un alt pixel care sa fie vecin al zonei si sa indeplineasca conditiile de la punctul anterior.
-**3)** Se determina suma valorilor pixelilor din zona curenta cat si numarul acestora (pentru a aproxima culoarea pe care o sa o aiba zona curenta).\\
-$$ N = numarul\ de\ pixeli\ din\ zona\ curenta $$
-$$ sum_{R} = \sum_{i=1}^N R_{i} $$
-$$ sum_{G} = \sum_{i=1}^N G_{i} $$
-$$ sum_{B} = \sum_{i=1}^N B_{i} $$
-$ (R_{i}, G_{i}, B_{i}) $ reprezinta valoarea pixelului i din zona curenta;
-**4)** Fiecare pixel $ (R',G',B') $ din zona determinata va avea ca valoare noua media aritmetica a valorilor pixelilor din zona (culoarea zonei), adica $ (sum_{R} / N, sum_{G} / N, sum_{B} / N) $;
-**5)** Dupa deteminarea noii zone se reia algoritmul incepand cu pasul **1)**.
-<note>Modul in care alegem pixelul la pasul **1)** poate inflenta calitatea algoritmului. Pentru aceasta tema vom aplica urmatoarea metoda de selectie: daca exista mai multi pixeli care nu au fost deja inclusi intr-o zona, se va alege acel pixel care se afla pe linia mai mica, iar in caz de egalitate (pixeli pe aceeasi linie) se va alege cel care se afla pe coloana mai mica. **Atentie!** Prima linie este linia cea mai de sus din imagine (adica cea mai de jos din fisier) iar prima coloana este coloana cea mai la stanga in imagine. </note>
-Sa presupunem ca avem urmatoarea imagine (rasucita deja si in ordinea $ (R, G, B) $) si threshold = 10:
-<html>
-<pre>
-(10 10 10) (12 10 13) (10 10 10) (30 30 30) (30 29 31)
-(10 10 10) (12 15 10) (10 10 10) (30 28 30) (22 20 23)
-(11 11 11) (11 12 11) (10 10 10) (30 33 30) (22 21 23)
-(12 12 12) (12 10 12) (10 10 10) (30 30 31) (22 20 23)
-</pre>
-</html>
-Initial niciun pixel nu este inclus in vreo zona. Se alege pixelul din coltul stanga-sus de valoare (10 10 10) deoarece acesta nu se afla deja in nicio zona. Se determina zona maximala din care acesta face parte:
-<html>
-<pre>
-<font color="red"> (10 10 10) (12 10 13) (10 10 10)</font> (30 30 30) (30 29 31)
-<font color="red"> (10 10 10) (12 15 10) (10 10 10)</font> (30 28 30) (22 20 23)
-<font color="red"> (11 11 11) (11 12 11) (10 10 10)</font> (30 33 30) (22 21 23)
-<font color="red"> (12 12 12) (12 10 12) (10 10 10)</font> (30 30 31) (22 20 23)
-</pre>
-</html>
-Calculam numarul de elemente si sumele asociate zonei curente:\\
-\\
-$ N = 12 $\\
-\\
-$ sum_{R} = 130 $, $ sum_{G} = 130 $, $ sum_{B} = 129 $
-Prin urmare, fiecare pixel din zona rosie va fi inlocuit cu $ (sum_{R} / N, sum_{G} / N, sum_{B} / N) $, deci
-$ (10, 10, 10) $.
-<html>
-<pre>
-<font color="red"> (10 10 10) (10 10 10) (10 10 10)</font> (30 30 30) (30 29 31)
-<font color="red"> (10 10 10) (10 10 10) (10 10 10)</font> (30 28 30) (22 20 23)
-<font color="red"> (10 10 10) (10 10 10) (10 10 10)</font> (30 33 30) (22 21 23)
-<font color="red"> (10 10 10) (10 10 10) (10 10 10)</font> (30 30 31) (22 20 23)
-</pre>
-</html>
-Alegem din nou un pixel care nu a fost inclus intr-o zona conform algoritmului de selectie. Acest pixel este cel de pe linia 1 si coloana 4 (indexarea incepe la 1) de valoare (30 30 30). Se determina zona maximala din care acesta face parte (colorata cu verde):
-<html>
-<pre>
-<font color="red"> (10 10 10) (10 10 10) (10 10 10)</font> <font color="green">(30 30 30) (30 29 31)</font>
-<font color="red"> (10 10 10) (10 10 10) (10 10 10)</font> <font color="green">(30 28 30)</font> (22 20 23)
-<font color="red"> (10 10 10) (10 10 10) (10 10 10)</font> <font color="green">(30 33 30)</font> (22 21 23)
-<font color="red"> (10 10 10) (10 10 10) (10 10 10)</font> <font color="green">(30 30 31)</font> (22 20 23)
-</pre>
-</html>
-Calculam numarul de elemente si sumele asociate zonei curente:\\
-\\
-$ N = 5 $\\
-\\
-$ sum_{R} = 150 $, $ sum_{G} = 150 $, $ sum_{B} = 152 $
-Prin urmare, fiecare pixel din zona verde va fi inlocuit cu $ (sum_{R} / N, sum_{G} / N, sum_{B} / N) $, deci
-$ (30, 30, 30) $.
-<html>
-<pre>
-<font color="red"> (10 10 10) (10 10 10) (10 10 10)</font> <font color="green">(30 30 30) (30 30 30)</font>
-<font color="red"> (10 10 10) (10 10 10) (10 10 10)</font> <font color="green">(30 30 30)</font> (22 20 23)
-<font color="red"> (10 10 10) (10 10 10) (10 10 10)</font> <font color="green">(30 30 30)</font> (22 21 23)
-<font color="red"> (10 10 10) (10 10 10) (10 10 10)</font> <font color="green">(30 30 30)</font> (22 20 23)
-</pre>
-</html>
-Alegem din nou un pixel care nu a fost inclus intr-o zona conform algoritmului de selectie. Acest pixel este cel de pe linia 2 si coloana 5 (indexarea incepe la 1) de valoare (12 10 13). Se determina zona maximala din care acesta face parte (colorata cu albastru):
-<html>
-<pre>
-<font color="red"> (10 10 10) (10 10 10) (10 10 10)</font> <font color="green">(30 30 30) (30 30 30)</font>
-<font color="red"> (10 10 10) (10 10 10) (10 10 10)</font> <font color="green">(30 30 30)</font> <font color="blue">(22 20 23)</font>
-<font color="red"> (10 10 10) (10 10 10) (10 10 10)</font> <font color="green">(30 30 30)</font> <font color="blue">(22 21 23)</font>
-<font color="red"> (10 10 10) (10 10 10) (10 10 10)</font> <font color="green">(30 30 30)</font> <font color="blue">(22 20 23)</font>
-</pre>
-</html>
-Calculam numarul de elemente si sumele asociate zonei curente:\\
-\\
-$ N = 3 $\\
-\\
-$ sum_{R} = 66 $, $ sum_{G} = 61 $, $ sum_{B} = 69 $
-Prin urmare, fiecare pixel din zona albastra va fi inlocuit cu $ (sum_{R} / N, sum_{G} / N, sum_{B} / N) $, deci
-$ (22, 20, 23) $.
-<html>
-<pre>
-<font color="red"> (10 10 10) (10 10 10) (10 10 10)</font> <font color="green">(30 30 30) (30 30 30)</font>
-<font color="red"> (10 10 10) (10 10 10) (10 10 10)</font> <font color="green">(30 30 30)</font> <font color="blue">(22 20 23)</font>
-<font color="red"> (10 10 10) (10 10 10) (10 10 10)</font> <font color="green">(30 30 30)</font> <font color="blue">(22 20 23)</font>
-<font color="red"> (10 10 10) (10 10 10) (10 10 10)</font> <font color="green">(30 30 30)</font> <font color="blue">(22 20 23)</font>
-</pre>
-</html>
-Am determinat astfel 3 zone similare si putem spune ca am clusterizat imaginea. Aceasta imagine este cea care va fi afisata in fisierul .bmp corespunzator acestui task.\\
-Pentru rezolvarea acestui task va trebui sa aplicati operatia de clusterizare asupra imaginii citite la taskurile anterioare.
-Daca numele imaginii este **<nume>.bmp** atunci imaginea rezultata dupa aplicarea filtrului se va scrie in fisierul **<nume>_clustered.bmp** (de exemplu, daca prima linie din fisierul input.txt este image.bmp atunci imaginea rezultata se va scrie in fisierul image_clustered.bmp).
-Exemplu concret: Daca imaginea initiala arata astfel:
-{{ :programare:teme_2019:initial_landscape.jpg?200 | Imaginea originala}}
-Si vrem sa realizam o operatie de clusterizare avand valoarea de threshold egala cu 100, imaginea rezultata va fi:
-{{ ::programare:teme_2019:clustered_landscape.jpg?200 | Imaginea clusterizata}}
-==== Task 6: Clean Valgrind BONUS (20p) ====
-Intrucat unul din scopurile principale ale acestei teme este alocarea dinamica a memoriei, pentru a rezolva acest task trebuie sa nu aveti nicio eroare sau leak de memorie la rularea utilitarului [[https://stackoverflow.com/questions/5134891/how-do-i-use-valgrind-to-find-memory-leaks|valgrind]] pe aceasta.
-Utilitarul se va rula folosind urmatoarea comanda:
-<code> valgrind --tool=memcheck --leak-check=full --error-exitcode=1 ./bmp </code>
-<note important> Atentie! Numele executabilului rezultat in urma comenzii <code> make build </code> trebuie sa fie neaparat **bmp**! </note>
-<note important> Atentie! Pentru a putea primi punctaj pe acest task trebuie sa aveti punctaj maxim pe restul cerintelor! </note>
-==== Format input ====
-Fisierul de intrare, in care se afla informatiile despre fiecare task, se numeste **input.txt**. Acesta are urmatoarea structura:
-  * Pe prima linie se va gasi numele **fisierului binar** ce reprezinta imaginea in format **bmp** care va fi prelucrata ulterior si are formatul descris la inceput (aceasta are cu siguranta extensia **.bmp**, pentru a va putea fi mai usoara creearea numelor imaginilor de output)
-  * Pe a doua linie se va gasi numele **fisierului text** ce reprezinta filtrul ce trebuie aplicat la task-ul 3 (semnificatia acestuia este gasita la descrierea task-ului aferent)
-  * Pe a treia linie se va gasi numele **fisierului text** ce reprezinta filtrul de pooling ce trebuie aplicat la task-ul 4 (semnificatia acestuia este gasita la descrierea task-ului aferent)
-  * Pe a patra linie se va gasi numele **fisierului text** ce contine valoarea de threshold necesara aplicarii algoritmului de clustering de la task-ul 5
-**Format filtru:**
-<code>
 N
-VAL_11 VAL_12 ... VAL_1N
+Y1 X1 D1 WORD1
-VAL_21 VAL_22 ... VAL_2N
+Y2 X2 D2 WORD2
-........................
+…
-VAL_N1 VAL_N2 ... VAL_NN
+Yn Xn Dn WORDn</code>
-</code>
+Unde:
-  * **N**: dimensiunea filtrului
+<code>XX este substringul pentru bonusul primit pentru casutele marcate cu 1.
-  * **VAL_IJ**: valoarea filtrului de tip **double** de pe linia i si coloana j
+YY este substringul pentru bonusurile primite pentru casutele marcate cu 2.
+N este numarul de cunvinte
-**Format filtru pooling:**
+Xi, Yi, WORDi sunt coordonatele pentru cuvantul WORDi</code>
-<code>
-m/M N
-</code>
-  * primul caracter area valoarea **m** daca filtrul este de **minim**, iar **M** daca este de **maxim**
-  * **N**: dimensiunea filtrului
-**Exemplu**\\
-<code c input.txt>
-test1.bmp
-./input/filters/filter1.txt
-./input/pooling/pooling1.txt
-./input/clustering/cluster1.txt
-</code>
-<note important>
-Exemple de imagini in format bmp si de input-uri pentru task-uri gasiti in directorul ''input'' din checker.
-</note>
-<note warning>Cand scrieti imagini in format BMP, intre ultimul byte din header si byte-ul la care incepe matricea de pixeli (adica pana la byte-ul de offset) trebuie sa scrieti peste tot byte-ul 0. </note>
-==== Format output ====
-Dupa cum a fost descris deja, fiecare task are ca scop producerea unei noi imagini, dupa aplicarea unei operatii de procesare pe imaginea initiala. Prin urmare, programul vostru va trebui sa citeasca imaginea de input si sa produca **5** imagini noi, fiecare avand numele specificat in cadrul task-ului corespunzator.
-Bineinteles, puteti sa sariti peste implementarea unui task sau sa implementati selectiv un anumit numar de taskuri, singura restrictie pe care o aveti este sa nu primiti erori de tipul Segmentation fault, deoarece acestea vor invalida testarea temei.
-==== Resurse si checker-ul local ====
-Resursele pentru tema se pot descarca de [[https://drive.google.com/open?id=1ykxNGgllWT6GWDOPGmX8KY38YpW3FCGf|aici]]. Sunt prezente:
-  * **bmp_header.h**: headerul care contine declaratiile struct-urilor pe care le veti folosi in citirea unui fisier BMP;
-  * **checker.zip**: arhiva zip ce contine checker-ul cu care puteti sa va testati implementarea local.
 ==== Trimitere tema ====
-Tema va fi trimisa folosind [[https://v2.vmchecker.cs.pub.ro/homepage/|v2.vmchecker]], cursul **Programarea Calculatoarelor**, tema **Image Processing**.
+Tema va fi trimisa folosind [[https://v2.vmchecker.grid.pub.ro/homepage/|v2.vmchecker]], cursul **Programarea Calculatoarelor**, tema **todo_name**.
 Punctajul:
-     * 110p - teste (20p sunt bonus)
+     * 140p - teste
-       * 10 teste
+     * 10p - bonus
-       * 9p pe test
-       * 20p pentru rularea fara erori a utilitarului valgrind pe imaginea cea mai mare (doar daca aveti deja 90p)
      * 10p - coding style & README (checker-ul o sa va acorde aceste puncte doar pentru prezenta fisierului README, la corectare acestea vor fi validate)
@@ Line 476: / Line 351: @@
      * Nu folositi variabile globale.
      * Fiti consistenti in ceea ce priveste [[programare:coding-style|Coding Style-ul]].
-     * Toate matricile si vectorii folositi se vor aloca **dinamic**, pe **heap**;
+     * Toate matricile si vectorii folositi se vor aloca **static**;
-     * **Task-ul 2** este singurul in care aveti de modificat si headerele imaginii bmp, in rest **nu veti avea de modificat nimic in headerele imaginii**;
+     * Tema se va trimite pe vmchecker si se va testa local cu ajutorul checker-ului;
-     * Tema se va trimite pe vmchecker si se va testa local cu ajutorul checker-ului care va fi disponibil **in curand**;
      * Pe vmchecker veti uploada o arhiva in format .zip care sa contina:
-          - **Makefile**, cu cel puțin 3 targeturi, **build**, **run** și **clean**; Regula **run** trebuie sa ruleze executabilul care a fost obtinut la regula **build** si care are numele **bmp** (vezi si task-ul bonus);
+          - **sursele** voastre, adică fișierele .c și .h.
-          - **sursele** voastre, adică fișierele .c și .h. **Inclusiv headerul bmp_header.h sau sub orice altă denumire îl folosiți**;
           - **README**, în care trebuie să dați detalii despre implementare, de ce ați ales să rezolvați într-un anumit fel, etc.
      * Daca rezolvati doar o parte din task-uri asigurati-va ca pe celelalte nu primiti erori la rulare (precum SEGFAULT) sau time limit exceeded, altfel tot testul va fi punctat cu 0. De exemplu, daca task-urile 1 si 2 sunt OK dar task-ul 3               primeste SEGFAULT sau dureaza prea mult atunci tot testul se va nota cu 0.
-<note important>**Temele care nu folosesc alocare dinamica vor avea o depunctare de pana la 50 de puncte din punctajul temei, in functie de gravitate! De asemenea, nu va fi acordat punctajul pe bonus in acest caz!**</note>
-<note warning>Nu descarcati imaginile atasate in enunt pentru testare! Acestea nu respecta formatul BMP! Pentru testare folositi **numai** imaginile puse la dispozitie in arhiva de testare. Imaginile de mai sus au doar caracter informativ. </note>
 === Listă depunctări ===
@@ Line 493: / Line 362: @@
   * o temă care nu compilează și nu a rulat pe **vmchecker** nu va fi luată în considerare
   * o temă care nu rezolvă cerința și trece testele prin alte mijloace nu va fi luată în considerare
-  * [-50.0]: o tema care nu folosește deloc alocarea dinamică (-70.0 dacă aceasta ia și punctajul bonus)
   * [-1.0]: warning-uri la compilare (este obligatorie folosirea în fișierul **Makefile** a flag-ului de compilare **-Wall** pentru regula **build**)
   * [-1.0]: numele variabilelor nu sunt sugestive