• Alin Popa
• Radu Iacob

Termen de predare: 08.11.2017, ora 23:55

Pentru fiecare zi (24 de ore) de întârziere, se vor scădea 10 puncte din nota acordată. Temele trimise după 7 de zile de întârziere vor putea fi notate cu maxim 30 de puncte. În consecință, deadline-ul hard este 15.11.2017, ora 23:00.

Update: 27.10.2017: Am publicat un checker local + subset de teste pe cs.curs Checker

Publicare: 25.10.2017

Dacă aveți nelămuriri, puteți să ne contactați pe forumul dedicat.
La orice întrebare vom răspunde în maxim 24 de ore.
Nu se acceptă întrebări în ultimele 24 de ore înainte de deadline.

• să se realizeze un program urmând anumite cerințe
• să se respecte formate stricte de intrare/ieşire
• să se însușească cunoștințele din primele patru laboratoare

Gigi, student în anul I la Calculatoare, este începător în programarea în C, însă reușește sa se acomodeze. Dupa laboratorul 3, ajunge acasă și se apucă sa exerseze instrucțiunile repetitive (for, while, do while). Astfel, descoperă un truc care i se pare foarte interesant: folosind instrucțiuni repetitive, poate sa afișeze în consola diverse forme amuzante, ca de exemplu:

x x x x x x x
  x x x x x x
    x x x x x
      x x x x
        x x x
          x x
            x      

Acesta ar fi un triunghi format din caracterul 'x' cu dimensiunea de 7 caractere (lățime, înălțime).

Scrieți un program care citește de la tastatură un număr ce reprezintă dimensiunea triunghiului și un caracter, și afișează un triunghi făcut din caracterul respectiv și cu dimensiunea respectivă. Triunghiul trebuie să aibă aceeași formă cu cel de mai sus (trebuie să reprezinte jumătatea din dreapta sus a unui pătrat tăiat pe diagonală). Caracterele de pe aceeași linie trebuie separate cu un spațiu. Spațiile libere (jumatatea din stanga jos simetrica triunghiului) trebuie făcută tot din caracterul spațiu.

Format intrare:

N C

Pe prima linie se va afla un număr N și un caracter C separate prin spațiu

N = dimensiunea (lățime și înălțime) a triunghiului C = caracterul ASCII care trebuie folosit

Exemplu

5 x

Output:

x x x x x
  x x x x
    x x x
      x x
        x

Explicație: Un triunghi ce folosește caracterul și dimensiunea specificate în fișierul de input, și care are forma de mai sus.

Între timp, Gigi devine din ce în ce mai bun la programare. Fiind un mare pasionat de jocuri (colecția lui de pe Steam atinge 2000$, are toate pachetele de tier 1 in Hearthstone, și are peste 900 de ore în CS:GO), decide să încerce să facă un mic joculeț în consolă (top-down single-player turn-based MMORPG). Începe cu ceva simplu: să creeze un personaj pe care să-l poată muta folosind tastatura.

O „tablă de joc” este o zonă de dimensiune NxM care va fi afișată în consolă astfel:

******
*    *
*    *
******

Acesta e un exemplu de tabla 2×4 (zona liberă din interior are 2 rânduri și 4 coloane). Pe o tablă va exista un „personaj”, care este reprezentat de caracterul ‘v’.

Jocul este turn-based, iar o tură funcționeaza în felul urmator:

• se afișează tabla de joc curentă
• se citește de la tastatură un singur caracter de mișcare (w, a, s sau d) urmat de caracterul newline (\n)
• personajul se mută pe tablă corespunzător (w = sus, a = stânga, s = jos, d = dreapta)
• se trece la tura următoare
• jocul se consideră încheiat când personajul ajunge în colțul din dreapta jos al tablei, caz în care se afișează tabla corespunzătoare (după aplicarea mutării ce trimite personajul în colțul din dreapta jos), urmată de mesajul “GAME COMPLETED” pe linia următoare

Exemplu:

• Fie tabla de joc de forma următoare, cu poziția personajului la coordonatele (y,x) = (1,2) (randul 1, coloana 2):

******
* v  *
*    *
******

• Utilizatorul scrie la tastatură caracterul ‘s’, apoi tastează Enter după aplicarea operațiilor corespunzătoare, programul afișează tabla de joc aferentă turei următoare (unde personajul a fost “mutat” cu o linie mai jos):

******
*    *
* v  *
******

• Dacă acum utilizatorul scrie la tastatură caracterul ‘d’ și tastează Enter, tabla va deveni:

******
*    *
*  > *
******

(personajul a fost mutat la dreapta)

• După încă o mutare la dreapta, personajul ajunge în colț iar jocul se termină. Se afișează tabla și mesajul de terminare:

******
*    *
*   >*
******
GAME COMPLETED

Scrieți un program care citește de la tastatură 5 numere: N, M, x, y, P (din care N, M, x si y cu semnificația dată mai sus, iar P va fi momentan 0 – îl veți folosi la taskul 3), afișează tabla curentă și aplică mișcarea conform cu datele citite de la tastatură. După fiecare mișcare citită de la tastatură, tabla de joc trebuie afișată din nou, având modificarea aplicată.

Format intrare:

Pe prima linie se dau numerele N, M, x, y, 0 separate prin spațiu.

Exemplu:

2 4 2 1 0

Pe fiecare linie care urmează se va citi un caracter de mișcare (w/a/s/d) sau caracterul q. Programul se încheie la citirea caracterului q (fără să mai afișeze încă o dată tabla).

Exemplu Ieșire:

După citirea primei linii (cu numerele N, M, x, y, P) și după fiecare caracter de mișcare citit de la tastatură, tabla de joc curentă trebuie afișată.

******
* v  *
*    *
******

Observații și restricții:

• 1 ≤ y ≤ N ≤ 80
• 1 ≤ x ≤ M ≤ 80
• coordonatele primei pozitii libere din stanga-sus sunt (1,1)
• dacă personajul se află într-una din margini (delimitate de asteriscuri) iar mișcarea cerută de utilizator este înspre marginea respectivă, mișcarea personajului nu trebuie să se efectueze (tabla de joc pentru runda următoare va fi identică cu cea de la runda precedentă)
• la afișarea unei table de joc, după ultima linie de asteriscuri trebuie afișat un singur caracter newline (\n)
• caracterul cu care este afișat personajul se modifică în funcție de direcția pe care personajul a fost mutat ultima oară. Se vor folosi caracterele ‘v’, ‘^’, ‘<’, ‘>’ pentru jos, sus, stânga și, respectiv, dreapta
• la început (după citirea primei linii de la tastatură), personajul va fi implicit orientat în jos și va folosi caracterul ‘v’ pentru afișare.

Având ambiții de gamer profesionist, lui Gigi i se pare că jocul este prea simplu, astfel încât decide să-i adauge niste obstacole.

Numărul P citit de la tastatură pe prima linie reprezintă numărul de obstacole. Dacă P>0, pe următoarele P linii se află informațiile despre fiecare obstacol: câte două numere l și c, și un caracter m, cu semnificația de mai jos.

• l – linia pe care se află obstacolul
• c – coloana pe care se află obstacolul
• m – un caracter ce reprezintă modul de funcționare al obstacolului: ‘f’ pentru obstacol fix, și ‘m’ pentru obstacol mobil

Un obstacol va fi reprezentat pe tabla de joc folosind caracterul ‘x’. Un obstacol fix va rămâne mereu acolo unde a fost poziționat, la coordonatele (l, c). Un obstacol mobil se va deplasa înspre personaj, pe una din cele 8 direcții, cu 1 poziție la fiecare 2 ture. Când utilizatorul execută o mutare care trimite personajul intr-o poziție ocupată de un obstacol (sau când un obstacol mobil vine peste personaj), jocul se termină (nu se mai afișează tabla de joc încă o dată, în schimb se afișează mesajul “GAME OVER” și execuția se încheie).

Modificați programul de până acum ca să ia în considerare varianta în care P>0.

Observații și restricții:

• 0 ≤ P ≤ 3

Exemplu intrare

3 4 2 1 3
2 1 f
1 4 m
3 4 m

Semnificație: Tabla este 3×4, personajul se află la coordonatele (1,2) și există 3 obstacole:

• unul la coordonatele (2,1) fix
• unul mobil la coordonatele (1, 4)
• unul mobil la coordonatele (3, 4)

Tabla de joc va arăta astfel:

******
* v x*
*x   *
*   x*
******

Dacă utilizatorul execută două mutări succesive în jos, după prima mutare tabla este:

******
*   x*
*xv  *
*   x*
******

După a doua mutare: (au trecut două ture, deci obstacolele mobile se vor muta cu o poziție spre personaj)

******
*    *
*x x *
* vx *
******

După o nouă mutare la dreapta, nu se mai afișează tabla de joc încă o dată, ci se afișează următorul mesaj și programul se încheie:

GAME OVER

Observații finale:

• toate coordonatele (pentru personaj și obstacole) vor avea valori valide (se vor afla in interiorul tablei de joc, nu vor avea valori negative, nu se vor suprapune etc.), deci nu e nevoie de verificări suplimentare

• după oricare din mesajele “GAME OVER” sau “GAME COMPLETED” trebuie afișat caracterul newline (\n)

• nu este permis să folosiți tablouri uni/multi-dimensionale pentru rezolvarea cerințelor temei sau variabile globale

• cerințele acestei teme trebuie abordate în ordine

• Un obstacol mobil se va deplasa înspre personaj alegând poziția adiacentă care minimizează funcția:

 | x_personaj - x_obstacol | + | y_personaj - y_obstacol | 

• obstacolele pot ajunge să se suprapună de-a lungul jocului

Tema va fi trimisă folosind vmchecker, cursul Programarea Calculatoarelor (CB & CD).

Formatul arhivei va fi următorul:

1. fișier(ele) sursa .c.
2. Un fișier Makefile (detalii aici) care să conțină următoarele reguli:
   1. build: creează executabilele task1, respectiv pacman
   2. clean: șterge fișierele obiect/executabile create.
3. Un fișier README în care vă descrieți rezolvarea fiecărui task.

• Nu folosiți variabile globale.
• Nu folositi tablouri uni-/multi-dimensionale
• Fiți consistenți în ceea ce privește coding style-ul.
• Modularizați pe cât de mult posibil codul.

Lista nu este exhaustivă.

• 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
• o temă care folosește semnificativ mai multa memorie decât este necesar
• este obligatoriu sa compilați cu opțiunea '-Wall'
• [-1.0]: numele variabilelor nu sunt sugestive
• [-1.0]: linii mai lungi de 80 de caractere
• [-5.0]: abordare ineficientă
  • în cadrul cursului de programare nu avem ca obiectiv rezolvarea în cel mai eficient mod posibil a programelor; totuși, ne dorim ca abordarea să nu fie una ineficientă, de genul să nu folosiți instrucțiuni repetitive acolo unde clar era cazul, etc.