Dragoş Burileanu Marius Pădure

Claudius Dan

1.

Descrierea mediului de lucru Dev-C++

Dev-C++ este un mediu integrat de dezvoltare pentru limbajul de programare C/C++ şi este oferit gratuit de către firma Bloodshed Software (Website: http://www.bloodshed.net). El foloseşte compilatorul GCC (GNU C – Free Software Foundation) şi poate crea fişiere executabile Win32, fie în mod consolă, fie prin intermediul unei interfeŃe grafice (GUI), şi de asemenea biblioteci statice sau dinamice (DLL-uri). CerinŃele de sistem recomandate de către autori sunt următoarele: sistem de operare MS-Windows 2000, XP; 32 MB memorie RAM; unitate centrală (compatibilă Intel) la 400 MHz; spaŃiu pe disc disponibil 200 MB. În afara distribuŃiei sale gratuite, Dev-C++ are un număr de caracteristici care îl fac extrem de atractiv pentru utilizare. Fără a intra în detalii, vom remarca în mod special faptul că interfaŃa grafică este foarte flexibilă, dar şi intuitivă şi uşor de folosit şi include toate facilităŃile necesare unui mediu de programare evoluat (editare completă, listare de funcŃii, compilare şi rulare, depanare, creare de proiecte, adăugare de biblioteci etc.). În această lucrare se utilizează mediul Dev-C++ pentru programarea în limbajul C, iar compilarea surselor va avea ca rezultat obŃinerea de fişiere executabile Win32. 1.1. Editarea unui program

Editarea (adică scrierea fişierului sursă al programului) se poate face în mediul Dev-C++ în două moduri. O modalitate eficientă, recomandată în special atunci când avem mai multe fişiere sursă, este de a crea mai întâi un Proiect (meniul File, opŃiunile New şi apoi Project...); în acest mod se permite adăugarea sau eliminarea imediată a unor fişiere şi editarea legăturilor după compilarea tuturor fişierelor sursă, ca şi un control al diferiŃilor parametri disponibili în mediul de programare. O a doua modalitate, mai simplă, este de a se crea direct un (singur) fişier sursă; această metodă va fi descrisă succint şi ilustrată în cele ce urmează. Presupunând ca suntem deja în interfaŃa grafică, se selectează meniul File, iar din New se alege Source File (sau se foloseşte combinaŃia de taste CTRL+N), aşa cum este prezentat în Figura 1.1. Se va deschide astfel o nouă fereastră (numita iniŃial Untitled1) în care se va scrie efectiv programul sursă. După încheierea editării, fişierul sursă trebuie salvat pe disc. Salvarea se face prin comanda Save As... (sau Save) din meniul File, aşa cum este ilustrat în Figura 1.2; fişierele se vor salva ca fişiere C (C source), şi vor avea pe disc extensia „.c”.

Figura 1.1. Deschiderea unui fişier sursă nou

1.2.

Compilarea programului

Următoarea etapă ce trebuie parcursă este compilarea programului sursă rezultat după terminarea editării, adică „traducerea” sa în limbajul calculatorului şi obŃinerea unui program obiect, reprezentat în cod maşină sau într-un limbaj apropiat de acesta. În cazul limbajului C, procesul de compilare şi editare de legături se împarte de fapt între mai multe programe: preprocesorul, compilatorul propriu-zis, asamblorul şi editorul de legături, rezultând în final un fişier executabil. 1

Figura 1.2. Salvarea fişierului editat În mediul Dev-C++ etapele sugerate anterior (practic compilarea şi editarea legăturilor) sunt parcurse automat şi transparent pentru utilizator prin apelarea opŃiunii Compile din meniul Execute, sau folosind combinaŃia de taste Ctrl+F9 (Figura 1.3).

Figura 1.3. OpŃiunea de compilare a fişierului sursă În cazul în care nu există erori, este creat un fişier executabil (având extensia „.exe”) care poate fi rulat, partea de jos a ferestrei interfeŃei grafice arătând, de exemplu, ca în Figura 1.4. În cazul în care se constată erori la compilare (tipic erori sintactice), lansarea în execuŃie nu este posibilă, iar erorile sunt semnalate în fereastra Compiler (aflată în colŃul din stânga jos al interfeŃei grafice). Figura 1.5 prezintă o astfel de situaŃie; este vorba de acelaşi exemplu (problema 2.2 din Capitolul 2), în care s-au omis intenŃionat ghilimelele ce încadrează specificatorul de format %d din linia 10. După ce erorile au fost înlăturate este necesar să se facă o nouă compilare (de remarcat faptul că după fiecare modificare adusă codului sursă, acesta trebuie recompilat). Când compilarea a decurs bine, este permisă rularea programului.

1.3.

Rularea programului

Rularea programului se face prin comanda Run (sau Ctrl+F10) din meniul Execute (a se vedea şi Figura 1.4). Această comandă lansează în execuŃie programul, tipărind eventual mesaje şi rezultate pe ecranul calculatorului.

2

3 . Compilarea cu succes a fişierului sursă Figura 1.4. Dacă se descoperă astfel de erori. programatorul trebuie să se reîntoarcă la editarea programului sursă.5. Pentru ca programul să fie lansat în execuŃie automat după compilare se poate folosi comanda Compile & Run (sau F9) din meniul Execute. O situaŃie ce conduce la erori de compilare a programului În această etapă sunt puse în evidenŃă erorile la execuŃie. să-l recompileze şi să-l ruleze din nou. sau sunt puse în evidenŃă erorile de logică dacă rezultatele sunt eronate. cum ar fi împărŃirea cu zero.Figura 1.

operaŃii de intrare/ieşire formatate Probleme rezolvate ScrieŃi un program care afişează pe ecran un text dat. printf("Introduceti al doilea numar.2. a: "). iar stdlib. #include <stdio. scanf("%d". fereastra de rulare DOS rămâne deschisă până când se introduce un caracter oarecare de la tastatură.h> #include <stdlib. printf("\n").h> int main() { int a. &a). printf("de mine. system("PAUSE"). ============================= P2. Acoladele ‚{‘ şi ‚}’ din interiorul funcŃiei marchează practic începutul şi sfârşitul programului. execuŃia programului oricum se încheie). s).1. &b). succesiunea operaŃiilor corespunde cu cea de scriere a comenzilor. Precizăm că toate programele din această lucrare întorc valori din main(). printf("\n"). – InstrucŃiunea system("PAUSE") are următorul efect: după afişarea rezultatelor.h este fişierul care defineşte funcŃiile standard de I/O din biblioteca C (printre acestea numărându-se şi funcŃiile printf() şi scanf()). deoarece instrucŃiunea return este plasată pe ultima linie din main(). stdio. printf("creat\n"). s = a + b.1 Programe simple. valoarea ‚0’ indică faptul că programul s-a terminat normal. P2. printf("Introduceti primul numar."). – FuncŃia printf() afişează şirul de caractere inclus între ghilimele.h”. #include <stdio.h> int main() { printf("Acesta este un program C"). SecvenŃa de caractere ‚\n’ determină trecerea afişării la un rând nou („newline”). b. printf("Suma celor doua numere este %d". Există şi alte secvenŃe de caractere care determină deplasarea poziŃiei următoare de afişare. system("PAUSE"). variabile şi constante. deşi din punct de vedere tehnic acest lucru este opŃional (strict formal.h este un fişier ce defineşte un număr de funcŃii utilitare din biblioteca standard (cum este şi system()). s. } 4 . fereastra se închide automat după rulare). 2. în cazul anterior. deoarece nu se precizează explicit un salt la o altă instrucŃiune. după compilare şi execuŃie: Acesta este un program C creat de mine. Uzual. printf("\n"). permiŃând astfel vizualizarea şi interpretarea rezultatelor programului (în lipsa unei astfel de comenzi.h> #include <stdlib. return 0. în acest caz a unor fişiere speciale care descriu conŃinutul unor biblioteci şi care poartă denumirea de fişiere header.2 ScrieŃi un program care citeşte două numere întregi a şi b şi calculează suma lor. – InstrucŃiunea return utilizată în main() determină întoarcerea unui cod de terminare către sistemul de operare (valoarea întoarsă trebuie să fie un întreg). scanf("%d". În exemplul anterior. orice altă valoare indică faptul că există o eroare. – Programul propriu-zis este descris de funcŃia main(). } Programul va afişa pe ecran. return 0. DiscuŃie: – Comanda #include realizează includerea în fişierul sursă a unui alt fişier (situat într-un director cunoscut de către compilator). având extensia „. InstrucŃiunile se execută secvenŃial. b: ").

} 5 . b şi s. sa spunem c. a. raza. pi = 3. a . declară variabilele de tip întreg a. cea de a doua la adresa variabilei b. după compilare şi execuŃie: Introduceti primul numar. return 0.%d = %d". aria = pi * raza * raza. printf("Introduceti doua numere intregi: "). s). Variabila s va fi folosită pentru a stoca valoarea sumei dintre a şi b.b” (această metodă a fost folosită în problema 2. } Dacă se introduc de la tastatură.h> int main() { int a.9 = -2 DiscuŃie: – InstrucŃiunea scanf("%d %d".Dacă se introduc de la tastatură. printf("\n"). ele vor fi evaluate înainte de apelul funcŃiei. return 0. /* calculul ariei */ printf("Aria cercului de raza %d este %f".3 ScrieŃi un program care calculează diferenŃa a două numere întregi introduse de la tastatură. valoarea razei se va citi de la tastatură şi va fi un număr întreg. printf("%d . &b). &a. numerele –7 şi 7. de exemplu. programul va afişa pe ecran. float aria. system("PAUSE"). – Linia s = a + b. b. printf("\n"). numerele 7 şi 9. după compilare şi execuŃie: Introduceti doua numere intregi: 7 9 7 .14. – FuncŃia scanf() citeşte un caracter introdus de la tastatură.h> #include <stdlib. – Este absolut corectă utilizarea unor expresii (cum este „a . a: -7 Introduceti al doilea numar. Această variantă este chiar mai eficientă decât utilizarea unei variabile suplimentare. valoarea citită va fi de tip întreg şi va fi stocată la adresa variabilei ce urmează simbolului ‚&’.b”) în lista de parametri a funcŃiei printf(). &raza).2).h> #include <stdlib. /* Comenzi */ printf("Introduceti raza: "). căreia să i se atribuie valoarea „a . ============================= P2. programul va afişa pe ecran. ============================= P2. scanf("%d %d". permite citirea de la tastatură a două numere întregi: prima valoare citită va fi stocată la adresa variabilei a. b. conform specificatorului „%d”. &b). #include <stdio. va afişa pe ecran textul Suma celor doua numere este urmat de valoarea calculată a lui s. #include <stdio. scanf("%d". – Linia printf("Suma celor doua numere este %d". atribuie variabilei s valoarea a + b.b). De notat că spaŃiul dintre cele două grupe de caractere „%d” din "%d %d" spune funcŃiei scanf() că cele două numere introduse de la tastatură pot fi separate de spaŃii.h> int main() { /* Declaratii */ int raza. aria). deoarece reduce spaŃiul de memorie necesar programului. s.4 ScrieŃi un program care calculează aria unui cerc de rază dată. b: 7 Suma celor doua numere este 0 DiscuŃie: – InstrucŃiunea int a. de exemplu. b. system("PAUSE"). &a.

scanf("%d".141593. compilatorul va fi informat că variabila care urmează nu poate fi modificată de program. return 0. din programul anterior se putea înlocui cu: float aria. float gradc. deci evaluarea expresiei „(gradf . Cele două constante utilizate (5 şi 9) se vor introduce în program sub forma „5. const float pi = 3. Prin urmare. ============================= P2. valoarea 100.14.14.0”. Se va utiliza relaŃia de transformare cunoscută: rad = grad * π / 180. F – grade Fahrenheit (număr întreg). instrucŃiunea float aria. Deoarece suprafaŃa unui cerc nu este neapărat un număr întreg. valoarea 3. printf("Masura unghiului este de %4.h> #include <stdlib. de exemplu. gradc). return 0. Acesta poate fi folosit pentru a crea constante de un anumit tip.2f radiani".32) * 5.0.h> int main() { int grad.5 ScrieŃi un program care transformă temperatura exprimată în grade Fahrenheit în grade Celsius. system("PAUSE").0” şi respectiv „9. unde C – grade Celsius (număr real). programul va afişa: Introduceti temperatura in grade Fahrenheit: 100 Temperatura in grade Celsius este 37. printf("Temperatura in grade Celsius este %f". astfel. – Comentariile se pot introduce oriunde în program. } Dacă se introduce de la tastatură. acelaşi efect putea fi obŃinut utilizând modificatorul const.32)*5/9” ar fi dus la un rezultat incorect (chiar dacă variabila gradc a fost declarată de tip float). printf("\n"). deşi asupra acestui lucru vom reveni în capitolul următor. system("PAUSE"). #include <stdio. variabila aria în care este calculată va fi declarată de tip real (deci se va utiliza tipul float). programul va afişa: Introduceti raza: 3 Aria cercului de raza 3 este 28. Deoarece această variabilă nu este de fapt asociată decât valorii constante 3. Se va utiliza formula: C = (F–32)*5/9 .260000 DiscuŃie: – Se declară variabila raza de tip întreg.777779 DiscuŃie: – După cum s-a cerut în enunŃul problemei. rad).Dacă se introduce de la tastatură. printf("\n"). rad = grad * pi / 180. pi=3.6 ScrieŃi un program care transformă măsura unui unghi din grade (număr întreg) în radiani (număr real).14.h> int main() { int gradf.h> #include <stdlib. de exemplu. printf("Introduceti temperatura in grade Fahrenheit: "). &gradf). vom spune deocamdată doar faptul că rezultatul împărŃirii a doi întregi este un întreg. float rad. ============================= P2. #include <stdio. se declară variabilele gradf de tip întreg şi gradc de tip real.0 / 9. &grad). gradc = (gradf . } 6 . const float pi = 3. printf("Introduceti unghiul in grade: ").14. scanf("%i". – Variabila reală pi se iniŃializează cu valoarea 3.

7 . ScrieŃi programe care calculează arii pentru pătrat. ScrieŃi un program care calculează lungimea unui cerc de rază dată. programul va afişa: Introduceti unghiul in grade: 360 Masura unghiului este de 6. – Fiecare caracter ce indică formatul variabilei poate fi precedat în cadrul unui specificator de format de un modificator ce va determina felul în care se va tipări valoarea. 1. Se citeşte un întreg . „%4.. ca şi seria şi grupa. Astfel. 6. ScrieŃi un program care transformă temperatura exprimată în grade Celsius în grade Fahrenheit. de exemplu. ca specificator de format pentru numere întregi zecimale poate fi utilizat atât „%d” cât şi „%i”. ScrieŃi un program care citeşte doi întregi şi calculează produsul lor.2. cu 2 cifre la partea fracŃionară. 3. dreptunghi. 7.2f” utilizat la a doua funcŃie printf() are următoare semnificaŃie: se va tipări un număr real în format zecimal utilizând în total 4 caractere (incluzând punctul zecimal). s-a folosit aici a doua variantă. valoarea razei se va citi de la tastatură şi va fi un număr întreg.Dacă se introduce de la tastatură. 5. valoarea 360. în exemplul anterior. ScrieŃi un program care transformă măsura unui unghi din radiani în grade. ScrieŃi un program care să afişeze: „AŃi introdus numărul . Probleme propuse ScrieŃi un program care să vă afişeze numele pe ecran.. ============================= 2. pe două rânduri succesive.28 radiani DiscuŃie: – După cum s-a arătat la partea teoretică. 2. triunghi. 4. ScrieŃi programe care calculează volume pentru cub. piramidă. 8.”. paralelipiped.

2e-2. 66 Dupa 'b' urmeaza 'c' Majuscula corespunzatoate lui 'm' este 'M' DiscuŃie: – Programul are. trei părŃi complet distincte.1120 sau 1. char b_mic.347).1.4f” va duce la afişarea lui y sub forma „ 0.3468. x = 12. operatori şi expresii Probleme rezolvate Următorul program ilustrează utilizarea tipurilor fundamentale de date în C. printf("Majuscula corespunzatoare lui '%c' este '%c'". În principiu. deoarece pe majoritatea calculatoarelor curente reprezentarea internă a lui int este pe 32 de biŃi).3f” va duce la afişarea lui x cu 6 caractere în total (5 cifre plus punctul zecimal) şi 3 cifre precizie pentru partea fracŃionară (ca atare. #include <stdio. afişarea se completează cu două spaŃii libere la stânga numărului). b_mic. } Programul va afişa pe ecran.346800 sau 12. unsigned short int u.347 sau 1. similar pentru celelalte două variabile. după compilare şi execuŃie: 66000 464 x = 12. de altfel. x. s-ar fi afişat corect şi dacă ar fi fost declarat int. return 0. y. aşa cum se observă. ch.'a' + 'A'). 3.h> int main() { long int i = 66000.3f sau %e\n". printf("Codurile ASCII pentru 'b' si 'B' sunt: %d. 98. – Partea a doua ilustrează câteva modalităŃi de afişare a numerelor reale. sau sunt reconvertite în caracterele corespunzătoare dacă este folosit specificatorul ‚%c’. x). b_mare). u). – În partea a treia a programului se exemplifică utilizarea şi afişarea caracterelor.3. însă nu afişează corect acelaşi număr declarat unsigned short int.4f sau %E\n\n". compilatorul semnalizează acest lucru printr-un mesaj de atenŃionare (fereastra Compiler). y. b_mic = 'b'. formatul „%6. ch = 'm'. codul ASCII al lui ‚b’.120000E-001 Codurile ASCII pentru 'b' si 'B' sunt: 98. printf("x = %f sau %6.3468 se va rotunji la 12.h> #include <stdlib. P3. Numerele de tipul unsigned short int sunt întotdeauna reprezentate pe 16 biŃi. formatul „%8. y). în sfârşit. b_mic. Compilatorul plasează. Cele trei variabile folosite sunt declarate de tipul char. cu două unităŃi mai mare decât este necesar.1 Tipuri fundamentale de date. b_mare = 'B'. numărul 12. y. Utilizarea specificatorului „%e” sau „%E” conduce la afişarea numărului real în formatul ştiinŃific. de exemplu. În prima parte se dau două exemple de folosire a numerelor întregi. Programul va afişa corect numărul 66000 declarat long int (de fapt. la adresa variabilei b_mic. b_mic + 1).112000 sau 0. constantele caracter se scriu între simbolurile apostrof. de exemplu. printf("y = %f sau %8. Variabilele x şi y se declară de tipul double şi se iniŃializează cu două valori concrete. u = 66000. Aceste valori pot fi utilizate. %d\n". şi se afişează ca numere întregi dacă se foloseşte specificatorul de format ‚%d’. ch . x. double x. gama lor fiind între 0 şi 216–1=65535. printf("Dupa '%c' urmeaza '%c'\n". ============================= 8 .1120” (deoarece lăŃimea câmpului de afişare specificată prin format este 8. ch. pentru a face diferite calcule aritmetice (după cum se arată şi în program). system("PAUSE"). y = 11. Această idee este reluată şi în problema următoare. printf("\n"). b_mare. printf("%ld\t%hu\n\n". i. specificatorul de format „%f” poate fi folosit cu oricare din tipurile float sau double şi afişarea se face uzual cu 6 cifre la partea fracŃionară. Specificatorii de format „%ld” şi „%hu” permit afişarea numerelor întregi zecimale de tipurile long int şi respectiv unsigned short int.234680e+001 y = 0.

ch = getch().2 ScrieŃi un program care afişează codul ASCII al unui caracter citit de la tastatură. + d). printf("Ati introdus z1 = %f + %fi". de exemplu. Caracterele necitite. system("PAUSE"). – Specificatorul de format „%3d” defineşte dimensiunea minimă a câmpului în care se va afişa numărul întreg (3 în cazul de faŃă).h> int main() { char ch. b printf("\nz1 * z2 = %f + %fi ". dar spre deosebire de aceasta din urmă. nu afişează automat pe ecran caracterul introdus de la tastatură (se mai spune că „nu are ecou pe ecran”).600000 + 6.100000i Introduceti z2: 3. scanf("%f %f".200000 + 2.4 4.h> #include <stdlib. c. c.h> int main() { float a.400000i z1 * z2 = -4. De notat că dacă se indică o lăŃime de câmp mai mică decât este necesar. b. Recomandăm folosirea funcŃiilor getch() şi getche() care sunt mai flexibile. numerele 1. &c. a. programul va afişa: Introduceti un caracter: (c) Caracterul c are codul ASCII 99 DiscuŃie: – Se declară variabila ch de tip caracter. d). printf ("Introduceti un caracter: "). d. b * d. rămân în buffer şi vor fi citite de următoarele apeluri la getc() sau getchar().950000 + 12.P3.400000 + 4. adică aşteaptă până când este apăsată o tastă şi apoi întoarce codul său ASCII. b. Este o variantă a funcŃiei de I/O getche(). FuncŃia getch() citeşte un caracter de la tastatură. } b).h> #include <stdlib. a * c – printf("\n"). d – numere reale). se va tipări un spaŃiu suplimentar la stânga sa. z2 = c + d i (se citesc efectiv a.2 şi 2. ============================= P3. printf("\nIntroduceti z2: ").3 ScrieŃi un program care adună şi înmulŃeşte două numere complexe exprimate sub forma z1 = a + bi .3. &a.3 Ati introdus z2 = 3.300000i z1 + z2 = 4. printf("\n"). ch). a * d + b * c). compilatorul va aloca totuşi lăŃimea necesară (doar numărul de zecimale precizat prin format va fi respectat întocmai).2 2. scanf("%f %f". ch. printf("\nz1 + z2 = %f + %fi". caracterul ‚c’. programul va afişa: Introduceti z1: 1. return 0. &b). a + c.1 Ati introdus z1 = 1. printf("Introduceti z1: "). inclusiv <Enter>. &d). de exemplu. IndicaŃie: (a + bi) + (c + d i) = (a + c) + (b + d)i (a + bi)(c + d i) = (ac – bd) + (ad + bc)i #include <stdio. printf("\nCaracterul %c are codul ASCII %3d".4 şi 4. #include <stdio. Precizăm că funcŃiile getch() şi getche() nu sunt funcŃii ANSI. respectiv 3. Bibliotecile standard ANSI pun la dispoziŃia utilizatorului doar funcŃiile getc() şi getchar() care însă citesc primul caracter introdus şi aşteaptă validarea scrierii de către utilizator prin tasta <Enter>.1. system("PAUSE"). return 0. deci necesită două cifre. printf("Ati introdus z2 = %f + %fi". c.300000i ============================= 9 . } Dacă se introduce de la tastatură. Dacă se introduc de la tastatură. deoarece codul ASCII al lui ‚c’ este 99 (pentru exemplul considerat anterior).

printf("7 / 4 = %d sau %f".4 Următorul program ilustrează utilizarea operatorilor de împărŃire (/) şi modulo (%).5 Următorul program ilustrează utilizarea operatorilor de incrementare şi decrementare. printf("\n"). /* secventa echivalenta cu: x = y. y = 10. printf("Restul impartirii lui 7 la 4 este %d". z. y y y y = = = = 11 9 11 9 ============================= P3. după compilare şi execuŃie: 7 / 4 = 1 sau 1. y = 10. y = %d\n". /* rezultat corect */ l = i % j. 10. #include <stdio. x = ++y. z = --y + 5.6 Următorul program ilustrează utilizarea operatorilor relaŃionali şi logici. z. /* Sectiunea 1 */ j = i > 5. j = 4. */ printf("x = %d. system("PAUSE"). y--. x = y.0 = 1. */ printf("z = %d.h> #include <stdlib. } Programul va afişa pe ecran. return 0. g = 4. y = %d\n". k. z = 3 * y--. x. 10 . } Programul va afişa pe ecran. k = i / j. y = %d\n". k. d. */ printf("z = %d. j. system("PAUSE").0 / 4.h> #include <stdlib. y = 10. x.0. y = 10. y).h> int main() { int i = 7. m. int a.000000 7. 30. h). printf("\n"). #include <stdio. y++. b. return 0. y = %d".h> int main() { int x.0 / 4. h = i / j. /* secventa echivalenta cu: y++. e. l).h> #include <stdlib.h> int main() { int i = 10. 14. #include <stdio. z = y+5. y). y). l. h). după compilare şi execuŃie: x z x z = = = = 11. printf("\n7. n. h. l = 18.0 = %f\n". y). /* secventa echivalenta cu: z = 3 * y. k. */ printf("x = %d. /* secventa echivalenta cu: y--. x = y++.P3.750000 Restul impartirii lui 7 la 4 este 3 ============================= P3. float f = 7.0. /* rezultate incorecte */ h = f / g. z. c.

printf("b = %d. SecŃiunea 2: se execută mai întâi parantezele. a == 0 = 1 2. printf("m = %d\n". printf("n = %d\n\n". !a = 1 2. c++ = 8 – SecŃiunea 6: „==” are prioritate mai mare decât „&&”. /* Sectiunea 6 */ b = a == 0 && c. /* Sectiunea 3 */ n = 10 > 5 && !(10 < 9) || 3 >= 4. b). b. 1 && 1 || 0 ≡ (1 && 1) || 0 = 1 || 0 = 1 5. b = 0 3. c > 7 = 0 2. /* Sectiunea 5 */ b = c++ > 7. e). printf("e = %d". k = 0 m = 1 n = 1 b b b e = = = = 7 0. system("PAUSE"). 1 > c = 0 . /* Sectiunea 7 */ e = !a > c >= 2. k). printf("b = %d\n". 0 && 1 = 0. printf("b = %d\n". apoi j = 1. j. deci va primi valoarea ‚0’. c). 10 > 5 = 1 . ordinea de evaluare este următoarea: 1. n). printf("\n"). m). prin urmare. c = %d\n". SecŃiunea 3: ordinea de evaluare este următoarea: 1. c = 8 1 0 DiscuŃie: – expresia – – SecŃiunea 1: expresia i > 5 este evaluată „adevărat” (10 > 5). n = 1 – SecŃiunea 4: operatorii ‚=’ şi „+=” au aceeaşi prioritate şi asociativitate de la dreapta spre stânga. apoi 0 || 1 = 1. apoi k = 0. d = 5. /* Sectiunea 4 */ b = d += 2. return 0. i >= 50 este evaluată „fals”.k = i >= 50. d += 2 ≡ d = d + 2 = 7 2. e = 0 ============================= 11 . b. /* Sectiunea 2 */ m = ((i > 11) && (l < 19)) || (l > 10). !(0) = 1 3. c = 7. 0 >= 2 = 0 3. b). 3 >= 4 = 0 4. printf("j = %d. e. ordinea de evaluare este următoarea: 1. deci va primi valoarea ‚1’. k = %d\n". } Programul va afişa pe ecran. b = 7 – SecŃiunea 5: ordinea de evaluare este următoarea: 1. (10 < 9) = 0 2. în final m = 1. 1 && c = 1 3. după compilare şi execuŃie: j = 1. b = 1 – SecŃiunea 7: ordinea de evaluare este următoarea: 1. a = 0.

x = 230. int i. m.250000 n = 1. – SecŃiunea 3: alături de lucrurile discutate deja până în acest moment.250000 (float)(4 * 6) / 5 = 4. l = (float)(i / j). în schimb ch_2 nu este afişat corect. v = 10. u = v.000000 l = 1. ch_2 = y. împărŃirea lui a la b produce un rezultat întreg (3). j. ch_2). y = 260. int u. /* Sectiunea 2 */ u. regulile de conversie implicită sunt aplicate operaŃie după operaŃie). numărul întreg 260 exprimat în binar este 100000100. float c = 10. ============================= 12 . unsigned char ch_1. ch_1. } Programul va afişa pe ecran. m.333. k = i / j.0.h> #include <stdlib. ch_2. n. ObservaŃie: putem deduce simplu valoarea ce va fi afişată pe ecran în acest ultim caz.333333 u = 10 ch_1 = 230 ch_2 = 4 p = 1.P3. deoarece numărul întreg 230 intră în gama de reprezentare a tipului unsigned char. y. p = (float)i / (float)j.7 Următorul program ilustrează conversiile implicite de tip în expresii şi atribuiri. 255]. – SecŃiunea 2: u primeşte valoarea întreagă a lui v. float k. l). ca şi utilizarea operatorului cast. ch_1 este afişat corect. deoarece cel de-al doilea operand va fi adus automat la tipul celui dintâi. l. system("PAUSE"). această valoare este apoi convertită la o valoare reală. p.250000 k = 1. mai facem doar o precizare: teoretic. ch_1 = x. double v. /* Sectiunea 3 */ i = 5. ambii operanzi fiind întregi. după compilare şi execuŃie: d = 3. d. printf("(float)(4 * 6) / 5 = %f". adică [0. k. b = 3. #include <stdio. producându-se o pierdere de informaŃie (numai cei 8 biŃi inferiori ai lui y sunt copiaŃi în ch_2). d = c / (a / b). printf("\n"). return 0. deoarece tipul lui c este float (chiar dacă rezultatul final al unei expresii va fi de tipul cel mai larg. printf("u = %d ch_1 = %d ch_2 = %d\n\n".h> int main() { /* Sectiunea 1 */ int a = 10. n. p). u. printf("k = %f\tl = %f\n".800000 DiscuŃie: – SecŃiunea 1: se evaluează mai întâi paranteza. este suficient sa forŃăm tipul unuia dintre cei doi operanzi ce realizează o operaŃie. j = 4. printf("m = %f\tn = %f\tp = %f\n". m = (float)i / j. d). n = i / (float)j.000000 m = 1. (float)(4 * 6) / 5). printf("d = %f\n\n". iar ultimii 8 biŃi codifică practic numărul întreg 4 (numărul 4 reprezentat în binar este 100). x.

float y. z. } 13 . 1. system("PAUSE"). printf("x = %f\n"). } 4. j=5. Ńinând cont de faptul că media trebuie să fie un număr real. Ce este incorect la următorul program? #include <stdio. ScrieŃi un program care citeşte pe n întreg şi afişează valoarea expresiei n/(n+1) cu patru zecimale. printf("x = %d\n". k = 10. x. j = 5. printf("y = %f\n". return 0. k = 10.h> int main() { int i=3. x = i * k / j + k – j + 3 * i.22. Probleme propuse ScrieŃi un program care calculează şi afişează pe ecran media aritmetică a două numere întregi citite de la tastatură. return 0.h> #include <stdlib. 3. #include <stdio. u = i < j == j > k.h> #include <stdlib. k=10. u. printf("z = %d\n".h> int main() { int x. j = 5. printf("u = %d". z). i = 3. i = 3. printf("\n").2.3. DeduceŃi ce afişează următorul program: 2. y). z = --i * j++. x). u). system("PAUSE"). (float)x = 10. PropuneŃi mai multe variante de a rezolva corect problema. y = (2 * k) / (float)(i * j) + 7.

1.").h> int main() { char ch. system("PAUSE"). else printf("Ati tastat %c . printf("Introduceti un numar intreg: "). P4. &numar). 4. &ch). system("PAUSE"). #include <stdio. printf("\n"). printf("Tastati un caracter: "). else printf("Ati introdus un numar pozitiv!"). return 0. printf("\n").3 Următorul program ilustrează valorile logice „adevărat” şi „fals” în C. scanf("%c". return 0. if(numar < 0) printf("Ati introdus un numar negativ!"). return 0. printf("\n"). ch).h> #include <stdlib. /* orice valoare diferită de 0 este considerată "adevarat"! */ if(0) printf("Acest text nu va fi afisat niciodata.1 InstrucŃiuni condiŃionale Probleme rezolvate Următorul program simplu determină dacă un număr întreg introdus de la tastatură este pozitiv (strict pozitiv sau zero).h> #include <stdlib.h> int main() { int numar. system("PAUSE").h> #include <stdlib. } ============================= P4. #include <stdio. if(ch == 't') printf("Ati tastat 't'!").h> int main() { if(32) printf("Acest text va fi intotdeauna afisat.4. #include <stdio. folosind două decizii simple.". } ============================= 14 .")... scanf("%d". sau strict negativ.2 Următorul program simplu citeşte un caracter introdus de la tastatură şi verifică dacă acesta a fost caracterul ‚t’. } ============================= P4.

5 Următorul program simplu ilustrează funcŃionarea instrucŃiunilor if multiple. se va presupune. printf("x1 = %1.3fi". b.h' */ x2 = (-b .h> #include <stdlib.h> int main() { float a. printf("Introduceti a (diferit de 0): "). system("PAUSE"). else printf("i este mare"). } printf("\n"). printf("\nx2 = %1.h> #include <stdlib. return 0. -b / (2 * a). x1. x2.3f . /* se va afisa "i este mare". #include <stdio. &a). j = -20. } else printf("\nj este negativ").P4. /* se va afisa "j este negativ".h> #include <math.%1. } ============================= 15 . else-ul este asociat celui mai apropiat if */ if(j > 0) { if(j > 1000) printf("\nj este foarte mare!"). } ============================= P4. printf("x1 = %1. scanf("%f".3fi".3f".3f\tx2 = %1.sqrt(delta)) / (2 * a). /* functia sqrt() este definita in fisierul header 'math. else-ul este asociat primului if */ printf("\n"). if(i > 0) if(i > 1000) printf("i este foarte mare!"). delta = b * b – 4 * a * c. pentru simplificare.h> int main() { int i = 100. printf("Introduceti c: "). că a ≠ 0 . -b / (2 * a). &c). delta. } else { printf("\nSe obtin radacini complexe:\n").3f + %1. sqrt(-delta) / (2 * a)). datorita folosirii acoladelor. system("PAUSE"). return 0.4 ScrieŃi un program care calculează şi afişează rădăcinile ecuaŃiei de gradul doi cu coeficienŃi reali a x 2 + bx + c = 0 (coeficienŃii fiind citiŃi de la tastatură). x2). &b). scanf("%f". x1. sqrt(-delta) / (2 * a)). #include <stdio. printf("\nSe obtin radacini reale:\n"). c. printf("Introduceti b: "). scanf("%f". if(delta >= 0) { x1 = (-b + sqrt(delta)) / (2 * a).

system("PAUSE"). printf("Introduceti ziua: "). if((zi > 0) && (zi <= 31)) if((luna > 0) && (luna <= 12)) if((an > 0) && (an < 10000)) printf ("Poate fi data calendaristica. return 0. scanf("%d". e = (c < 0) ? –c : c. /* daca e>f se va afisa e. } ============================= 16 .h> int main() { /* Sectiunea 1 */ float a. #include <stdio. &d). e. /* secventa echivalenta cu: if(a < b) min = a. else printf("Nu poate fi data din cauza lunii!"). /* Sectiunea 2 */ printf("Introduceti c: "). b. &c). min=(a < b) ? a : b.h> int main() { int zi. printf("Introduceti b: "). printf("Introduceti d: ").7 ScrieŃi un program care să calculeze şi să afişeze minimul dintre două numere reale citite de la tastatură. min. printf("Introduceti anul: "). scanf("%d"."). folosind operatorul condiŃional. luna. scanf("%d". int c. an. return 0. */ printf("Minimul dintre a si b este %f\n\n". /* se calculeaza modulul lui d */ printf("Maximul dintre |c| si |d| este %d".P4. else printf ("Nu poate fi data din cauza zilei!"). &an). scanf("%d". printf("Introduceti luna: "). } ============================= P4. &zi). d.h> #include <stdlib. printf("Introduceti a: "). min). #include <stdio. f. scanf("%f". /* se calculeaza modulul lui c */ f = (d < 0) ? –d : d. altfel se va afisa f */ printf("\n"). scanf("%f". scanf("%d". &a). (e > f) ? e : f). &luna). else min = b. &b). printf("\n").6 ScrieŃi un program care să determine dacă trei numere întregi introduse de la tastatură pot constitui o dată calendaristică (nu se iau în consideraŃie anii bisecŃi sau dacă luna are 30/31 zile). şi respectiv maximul dintre valorile absolute a două numere întregi. system("PAUSE"). else printf("Nu poate fi data din cauza anului!").h> #include <stdlib.

break. –. (float)a / (float)b). a . } 17 . system("PAUSE"). case '/': if(b == 0) printf ("\nImpartirea nu se poate efectua!"). a + b). } ============================= P4.9 ScrieŃi un program care să calculeze şi să afişeze aria sau lungimea unui cerc de rază dată (număr întreg. 2 * pi * r). b. char op. &b). scanf("%d".h> #include <stdlib. char c. float rez. scanf("%d".b). case '-': printf("\nDiferenta este %d". case 'q': case 'Q': printf("Iesire!"). case '*': printf("\nProdusul este %d". citit de la tastatură). scanf("%d". break.14. break. switch(op) { case '+': printf("\nSuma este %d". float pi = 3. default: printf ("\nAti introdus un cod incorect!"). printf("Introduceti optiunea. în funcŃie de opŃiunea utilizatorului. break. } printf("\n"). *. case 'a': case 'A': printf("Aria este: %. printf("pentru iesire din program: Q sau q \n\n"). case 'l': case 'L': printf("Lungimea este: %. break. printf("pentru lungime: L sau l \n"). Se citesc două numere întregi a şi b şi o operaŃie între ele (+. break. else printf("\nCatul este %f". c=getch().h> #include <stdlib.h> int main() { int a. break.8 Următorul program ilustrează funcŃionarea structurii de selecŃie. switch(c) { default: printf("Optiune necunoscuta!"). sau /) şi se va afişa rezultatul operaŃiei. return 0. #include <stdio.2f". &a). printf("Introduceti operatia: "). a * b). op = getche(). printf("Introduceti b: "). astfel:\n"). #include <stdio. printf("Introduceti raza: "). break. &r). pi * r * r).h> int main() { int r. printf("Introduceti a: "). printf("pentru arie: A sau a \n").P4.2f".

instrucŃiunile asociate unui case pot lipsi complet. 1. return 0.2.. return 0. IndicaŃie: ecuaŃia are soluŃie dacă a ≠ 0 . Folosind instrucŃiuni de decizie. ScrieŃi un program care calculează şi afişează rădăcina ecuaŃiei de gradul întâi cu coeficienŃi reali a x + b = 0 (coeficienŃii fiind citiŃi de la tastatură). &i). ============================= 4. de exemplu. ScrieŃi un program care să calculeze şi să afişeze maximul şi minimul dintre trei numere întregi citite de la tastatură. else printf("Optiune necunoscuta!"). ScrieŃi un program care citeşte de la tastatură un număr întreg între 1 şi 7 şi afişează denumirea zilei din săptămână corespunzătoare cifrei respective: 1 – luni.. 6. 4] 3x − 9 .printf("\n"). system("PAUSE"). printf("Ati introdus un numar pozitiv!"). utilizând operatorul condiŃional. pentru x > 4  4. else if(c == 'l' || c == 'L') printf("Lungimea este: %. else if(c == 'q' || c == 'Q') printf("Iesire!"). Programul va semnaliza printr-un mesaj de eroare dacă numărul introdus nu a fost în intervalul solicitat. printf("\n").2f". } DiscuŃie: – SecŃiunile structurii de selecŃie pot fi plasate în orice ordine. de exemplu. dacă a = 0 : dacă b = 0 ecuaŃia este nedeterminată. nu afectează în nici un fel funcŃionarea programului. împarte cele două numere şi afişează rezultatul. ca două sau mai multe case să execute aceleaşi instrucŃiuni fără să fie nevoie de repetarea lor – SecvenŃa din program realizată cu switch se putea scrie şi folosind instrucŃiuni de decizie multiple de tipul if-else-if. dar era evident mai complicat: if(c == 'a' || c == 'A') printf("Aria este: %. pentru x < 0  y =  3 . – Aşa cum se cunoaşte. else şi respectiv operatorul condiŃional. ScrieŃi un program care citeşte două numere întregi de la tastatură. 5. scrieŃi un program care citeşte de la tastatură un număr întreg x şi afişează o valoare y calculată astfel: 3. aceasta permite. Cum numitorul trebuie să fie diferit de zero. aşezarea lui default la începutul structurii. if(i > 0). discuŃie. 18 . pi * r * r). pentru x ∈ [0.h> #include <stdlib. iar dacă b ≠ 0 ecuaŃia nu are soluŃie. system("PAUSE"). discutaŃi această situaŃie în două moduri: folosind o decizie if .h> int main() { int i. ca în exemplul anterior. 2 – marŃi etc.2f". printf("Introduceti un numar intreg: "). scanf("%d".  − x + 3 . IndicaŃie: se va folosi o instrucŃiune switch. } 2. Probleme propuse Ce este incorect la următorul program? Ce va afişa programul dacă după compilare şi execuŃie se introduce de la tastatură numărul –10? #include <stdio.2 * pi * r).

h> int main() { int a. b.h> int main() { char ch. P5. a. b = 2 * a. se pot realiza operaŃii complexe în expresia ce semnifică testul de condiŃie. ch = getch(). #include <stdio. } while(a <= b). } se poate scrie mai simplu astfel: while((ch = getch()) != 'q') { printf("\nAti introdus %c ". } Dacă se introduce de la tastatură. a++. de exemplu. } printf("\n\nAti introdus q!"). while(ch != 'q') { printf("\nAti introdus %c ". ch = getch(). printf("stop\n"). &a). numărul 4. } ============================= P5. ch = getch(). programul va afişa: Introduceti un numar intreg pozitiv (<100): 4 start 4 * 4 = 16 5 * 5 = 25 6 * 6 = 36 7 * 7 = 49 8 * 8 = 64 stop 19 . } DiscuŃie: – Accentuăm faptul că în C.h> #include <stdlib. unde a este un întreg pozitiv care se citeşte de la tastatură.1 Cicluri Probleme rezolvate Următorul program simplu ilustrează utilizarea ciclului cu test iniŃial: se introduc continuu caractere de la tastatură. scanf("%d". printf("Introduceti un numar intreg pozitiv (<100): "). do { printf("%d * %d = %d\n". system("PAUSE"). printf("\n").5. astfel. return 0. a * a). ch). partea de program următoare: ch = getch(). ciclurile acceptă pentru testarea condiŃiei orice fel de expresii. #include <stdio. a. până când este tastată litera ‚q’.h> #include <stdlib. ch). printf("Introduceti un caracter ('q' pentru terminare): "). return 0. while(ch != 'q') { printf("\nAti introdus %c ".1.2 Următorul program simplu ilustrează utilizarea ciclului cu test final: se afişează pătratele numerelor întregi cuprinse între a şi 2a. Mai mult. ch). system("PAUSE"). 5. printf("start\n").

h> int main() { int n. scanf("%d". s. } system("PAUSE"). a. s). este următoarea: #include <stdio. n≥2 #include <stdio. printf("Introduceti un numar natural (>=2): "). i. i. } scanf("%d". system("PAUSE").h> #include <stdlib. } while(++a <= b). return 0. Ce se întâmplă dacă se introduce de la tastatură un număr întreg negativ? Dar dacă se introduce un număr natural impar? #include <stdio. printf("\n"). s = 0. return 0..4 Să se explice ce afişează următorul program după compilare şi execuŃie.DiscuŃie: – Cu aceeaşi observaŃie ca cea făcută la problema 5. s = 0. for(i = 1.. s += i. ciclul cu test final din problemă se mai poate scrie. &n). a. for( . ca şi particularităŃile ciclului for utilizat. astfel (reamintim că un operator de incrementare sau decrementare utilizat ca prefix determină ca valoarea nouă să fie calculată înaintea evaluării expresiei): do { printf("%d*%d = %d\n". 20 .3 Următorul program simplu ilustrează forma de bază a ciclului cu contor: se citeşte un număr natural şi se afişează suma 1 + 2 + . + n . s). } ============================= P5. } printf("Suma numerelor de la 1 la %d este %d". utilizând un ciclu cu test iniŃial. de exemplu. i. while(i < n) { i++. i -= 2) { j = i * i * i. a * a). &n). printf("\n").1.h> int main() { int n. j. n. j). system("PAUSE"). printf("Introduceti un numar natural par: "). printf("%d %d\n".h> #include <stdlib.h> #include <stdlib. &i). printf("Introduceti un numar natural (>=2): "). ============================= P5.h> int main() { int i. return 0. scanf("%d". } DiscuŃie: – O variantă a programului anterior. } printf("Suma numerelor de la 1 la %d este %d". i = 0. i++) { s = s + i. i <= n. n.

de asemenea. i <= b. s = 0. i++) s = s + i. i--. ============================= P5. } printf("\n"). i = b + 1! */ do { printf("%d ". b. i--. aşa cum s-a specificat şi la partea teoretică. scanf("%d". printf("Media aritmetica a numerelor dintre a si b: "). afişează numerele naturale din intervalul [a. şi nu numai cu 1 (ca în Pascal. scanf("%d". } while (i >= a). adică diferit de zero. programul va afişa: Introduceti un numar natural par: 8 8 512 6 216 4 64 2 8 DiscuŃie: – Programul numără descrescător. printf("%. /* dupa ultima iteratie a ciclului anterior. • contorul este utilizat şi în corpul ciclului.Dacă se introduce de la tastatură. for (i = a. se observă că modificarea contorului se poate face cu orice valoare.h> #include <stdlib. printf("Introduceti a (natural): "). system("PAUSE"). printf( "Numerele dintre a si b in ordine descrescatoare:\n").5 ScrieŃi un program care citeşte de la tastatură două numere naturale a şi b. în cazul problemei de faŃă pentru calculul lui j (acest lucru este posibil. deoarece contorul i este iniŃializat practic de către utilizator în afara ciclului (atenŃie însă că semnul ‚. din doi în doi. deoarece valoarea contorului nu este modificată de operaŃiile din cadrul ciclului). printf("Introduceti b (natural. numărul 8. printf("\n"). i). b>a): "). şi de asemenea calculează şi afişează media aritmetică a numerelor a şi b. i. i = a. – Sunt ilustrate o serie de variaŃii în modul de utilizare ale ciclului cu contor în C: • secŃiunea iniŃializare a ciclului lipseşte.(float)s / (b – a + 1)). i). #include <stdio. apoi afişează aceste numere. &a). &b). printf("\n"). } ============================= 21 . • testul de condiŃie are următoarea semnificaŃie: ciclul se reia atât timp cât i este „adevărat”. return 0. cu a < b . de la valoarea introdusă de utilizator şi până la 2. ciclul se repetă la infinit (justificaŃi această afirmaŃie!). printf("\nNumerele dintre a si b in ordine crescatoare:\n"). de exemplu). – Dacă numărul introdus de la tastatură este negativ. pe rânduri succesive. i++. de exemplu. while(i <= b) { printf ("%d ". împreună cu cuburile acestora.’ trebuie să fie prezent!).h> int main() { int a. sau pozitiv impar. b] în ordine crescătoare şi apoi descrescătoare.3f".

P5.6

ScrieŃi un program care citeşte de la tastatură un număr întreg n din intervalul afişează pe n!

[0, 100] , calculează şi

#include <stdio.h> #include <stdlib.h> int main() { int n, i; double fact; /* variabila fact = n! este declarata 'double' deoarece poate avea valori care sa nu poata fi reprezentate nici cu 4 octeti! */ printf("Introduceti un numar intreg intre 0 si 100: "); scanf("%d", &n); while(n < 0 || n > 100) { printf("Numarul introdus nu apartine intervalului!"); printf("\nIntroduceti din nou numarul: "); scanf("%d", &n); } if(n > 0) { for(fact = 1.0, i = 2; i <= n; i++) { fact = fact * i; /* sectiunea initializare cuprinde doua expresii separate de operatorul ','! */ } } else { fact = 1; /* pentru cazul n = 0 se foloseste definitia standard 0! = 1 */ } printf("Pentru n = %d, n! = %g\n", n, fact); /* specificatorul de format '%g' asigura tiparirea in formatul e sau f, care dintre ele este mai compact */ system("PAUSE"); return 0; }

============================= P5.7 ScrieŃi un program care afişează toŃi divizorii unui număr natural n citit de la tastatură; dacă numărul este prim, se va afişa acest lucru printr-un mesaj.

#include <stdio.h> #include <stdlib.h> int main() { int n, i, k; printf("Introduceti un numar natural: "); scanf("%d", &n); k = 0; for(i = 2; i <= n / 2; i++) { if(n % i == 0) { printf("%d ", i); k = 1; } } if(k == 1) printf("sunt divizorii lui %d", n); else printf("Numarul %d este prim!", n); printf("\n"); system("PAUSE"); return 0; }

Dacă se introduce de la tastatură, de exemplu, numărul 36, programul va afişa:
Introduceti un numar natural: 36 2 3 4 6 9 12 18 sunt divizorii lui 36

22

DiscuŃie:
– Programul foloseşte un ciclu cu contor pentru a căuta divizorii; se parcurge intervalul [2, n / 2] , incrementând unitar contorul i şi se caută numerele la care n se împarte exact (n%i==0). Variabila auxiliară k, iniŃializată cu 0, devine 1 dacă s-a găsit cel puŃin un divizor. – JustificaŃi condiŃia de terminare a ciclului i<=n/2; este testul de condiŃie formulat corect indiferent dacă n este par sau impar? ============================= P5.8 ScrieŃi un program care citeşte de la tastatură două numere naturale a şi b ( a numerele prime din intervalul
#include <stdio.h> #include <stdlib.h> int main() { int a, b, i, j, k, m; printf("Introduceti a (natural): "); scanf("%d", &a); printf("Introduceti b (natural, b>a): "); scanf("%d", &b); m = 0; for(i = a; i <= b; i++) { k = 0; for(j = 2; j <= i / 2; j++) { if(i % j == 0) k=1; } if(k == 0) { printf("%d ", i); m = 1; } } if(m == 1) printf("sunt numerele prime dintre %d si %d", a, b); else printf("Intre %d si %d nu exista numere prime!", a, b); printf("\n"); system("PAUSE"); return 0; }

< b ) şi afişează toate

[a, b] .

Dacă se introduc de la tastatură, de exemplu, perechile de numere 3, 18 şi respectiv 24, 28, programul va afişa în cele două situaŃii:
Introduceti a (natural): 3 Introduceti b (natural, b>a): 18 3 5 7 11 13 17 sunt numerele prime dintre 3 si 18 Introduceti a (natural): 24 Introduceti b (natural, b>a): 28 Intre 24 si 28 nu exista numere prime!

DiscuŃie:
– Problema este ceva mai complicată decât cea anterioară, în special dacă se doreşte tratarea tuturor cazurilor posibile. Primul ciclu for foloseşte contorul i pentru a parcurge întreg intervalul [a, b] ; se presupune mai întâi că fiecare număr i din interval este prim şi se iniŃializează cu 0 variabila k. Se parcurge apoi cu al doilea ciclu for (contor j) intervalul [2, i / 2] pentru a se cerceta dacă fiecare i are sau nu divizori, similar algoritmului utilizat în problema 5.7; dacă se găseşte un divizor, k va lua valoarea 1. Dacă după parcurgerea întregului ciclu interior k rămâne 0, înseamnă că i este prim, se afişează, şi ciclul exterior continuă cu următoarea valoare a lui i. Variabila auxiliară m foloseşte în acest program pentru a se putea trata şi cazul special în care în intervalul [a, b] nu există numere prime; m se iniŃializează cu 0 înainte de primul ciclu, şi devine 1 dacă a fost găsit cel puŃin un număr prim (care s-a afişat). =============================

23

P5.9

Următorul program ilustrează folosirea instrucŃiunilor break şi continue: se afişează numerele impare dintre 1 şi un număr natural ales de utilizator; trebuie să se permită reluarea exerciŃiului (fără ieşirea din program), dacă utilizatorul doreşte acest lucru, iar dacă valoarea introdusă este ≤ 0 , programul va tipări un mesaj de eroare şi va fi abandonat.

#include <stdio.h> #include <stdlib.h> int main() { int n, i, k; char ch; k = 1; do { printf("Introduceti un numar natural (>0): "); scanf("%d", &n); if(n <= 0) { printf("Valoare ilegala!\n"); break; /* se abandoneaza ciclul 'do...while' */ } for(i = 1; i <= n; i++) { if(i % 2 == 0) continue; /* se trece la inceputul ciclului 'for': se incrementeaza contorul, se reevalueaza conditia, apoi ciclul continua; programul nu va afisa numerele pare */ printf("%d ", i); } printf("sunt numerele impare intre 1 si %d", n); printf("\nDoriti sa reluati? (D/N): "); ch = getche(); if(ch == 'N') k=0; printf("\n\n"); } while(k); system("PAUSE"); return 0; }

=============================

5.2. 1.

Probleme propuse

ScrieŃi un program care citeşte pe n natural şi afişează valoarea expresiei:

s=
2. 3. 4. 5. 6. 7.

1 1 1 + + K + . 1+1 1+ 2 1+ n

ScrieŃi un program care citeşte pe n natural şi afişează valoarea expresiei:

s = 0! + 1! + 2! + K + n !

ScrieŃi un program care afişează numerele dintr-un interval

[a, b] ce se divid cu un număr natural k citit.

ScrieŃi un program care afişează numerele prime mai mici decât un număr natural k citit. ScrieŃi un program care să descompună în factori primi un număr natural n citit. ReluaŃi problema 5.9, cu următoarea modificare: se vor afişa numerele divizibile cu 3 dintre 1 şi un număr natural n citit. Este corect următorul fragment de program? Ce funcŃie realizează? Ce face, în principiu, ciclul cu contor scris sub forma for(;;)?
... for( ; ;) { ch = getche(); if(ch == 'A') } ...

break;

24

2 ScrieŃi un program citeşte un vector de elemente întregi. P6. n. v[i]). #include <stdio.h> #include <stdlib. float m. Precizare: Întrucât la rularea programului nu este cunoscut de la început numărul de elemente (el este mai mic decât 10) se va opta pentru citirea. împreună cu dimensiunea sa efectivă. i++) s += v[i]. a numărului de elemente. &v[i]). #include <stdio. v[i]). for(i = 0. &n). ============================= P6. for(i = 0. la început. scanf("%d". scanf("%d". printf("Introduceti nr. i). 6. } Programul va afişa pe ecran după compilare şi execuŃie: Introduceti nr. printf("Introduceti n: ").1. n. s = 0. i < n. system("PAUSE").1. i++) { printf("v[%d] = ". i. for(i = 0. } printf("Valorile citite sunt:\n"). i++) { printf("v[%d] = ". – Cel de al doilea ciclu for afişează valorile citite şi memorate. i < n. s.6. &v[i]). i--) printf("%d ". &n).1 Tablouri şi şiruri de caractere Probleme rezolvate ScrieŃi un program care citeşte de la tastatură un vector de maxim 10 elemente întregi împreună cu dimensiunea sa efectivă şi apoi afişează elementele sale. i. scanf("%d". i++) printf("v[%d] = %d\n". de elemente: 3 v[0] = -1 v[1] = 0 v[2] = 1 Valorile citite sunt: v[0] = -1 v[1] = 0 v[2] = 1 DiscuŃie: – Primul ciclu for citeşte elementele vectorului. 25 . i < n. i).h> #include <stdlib. de elemente: ").h> int main() { int v[10]. i >= 0. return 0. i. i < n. for(i = 0.h> int main() { int v[10]. scanf("%d". afişează în ordine inversă elementele vectorului şi calculează media aritmetică a elementelor sale. } for(i = n .

} min = max = v[0]. for(i = 1.h> int main() { int v[20]. return 0.2f\n". – Variabila s (ce va conŃine suma tuturor elementelor vectorului) se iniŃializează cu valoarea 0. şi determină maximul şi minimul dintre elementele acestui vector. printf("\tma = %. system("PAUSE"). } Programul va afişa pe ecran după compilare şi execuŃie: Introduceti n: 4 v[0] = 1 v[1] = 2 v[2] = 3 v[3] = 4 4 3 2 1 ma = 2. system("PAUSE"). primul ciclu for citeşte elementele vectorului.m = (float)s / n. m). este calculată şi afişată. i. scanf("%d". #include <stdio. } printf("max = %d\tmin = %d\n".3 ScrieŃi un program care citeşte un vector de elemente întregi. valoarea lui v[i]. ============================= P 6. min). i++) { if(v[i] >= max) max = v[i].h> #include <stdlib. scanf("%d". împreună cu dimensiunea sa efectivă. i++) { printf("v[%d] = ".50 DiscuŃie: – După citire numărului de elemente. i < n. media aritmetică. – La final. i). max. return 0. De remarcat conversia de tip (float)s / n. n. ma. &v[i]). min. for(i = 0.1) până la primul său element (i >= 0) prin decrementarea (i--) contorului. } Programul va afişa pe ecran după compilare şi execuŃie: Introduceti numarul de elemente din vector: 4 v[0] = -1 v[1] = 5 v[2] = -3 v[3] = 4 max = 5 min = -3 26 . n. Al treilea ciclu for parcurge vectorul şi la fiecare pas al ciclului se adună la vechea valoare a variabilei s. &n). printf("Introduceti numarul de elemente din vector: "). – Al doilea ciclu for parcurge vectorul de la ultimul (i ia valoarea n . if(v[i] <= min) min = v[i]. max. i < n.

1. Aceasta este metoda de ordonare / sortare „bubble-sort”. relaŃia sa de inegalitate în raport cu min respectiv max. La sfârşitul ciclului for. ============================= 27 . i < n. v[i]). v[i] = v[i+1]. v[0]. – Programul utilizează o variabila ind. i. dacă v[i] este mai mare decât max.4 ScrieŃi un program care citeşte un vector de elemente întregi. În primul caz. În al doilea caz. – Pentru interschimbarea elementelor care nu se află în ordinea dorită se utilizează variabila temporară tmp. for(i = 0. n. primul ciclu for citeşte elementele vectorului. } do { ind = 0.DiscuŃie: – După citire numărului de elemente. Parcurgerea ciclului se reia până când toate elementele sunt în ordinea dorită. i++) { printf("v[%d] = ". v[i+1] = tmp. } Programul va afişa pe ecran după compilare şi execuŃie: Introduceti numarul de elemente din vector: 4 v[0] = -1 v[1] = 4 v[2] = 2 v[3] = 0 v[0] = -1 v[1] = 0 v[2] = 2 v[3] = 4 DiscuŃie: – Primul ciclu for citeşte elementele vectorului. i < n . – Variabilele min şi max sunt iniŃializate cu valoarea primului element din vector. printf("Introduceti numarul de elemente din vector: "). ind. atunci elementul v[i] reprezintă un maxim local şi deci valoarea lui v[i] i se atribuie variabilei max. i). i < n. ordonează crescător elementele vectorului şi apoi afişează vectorul ordonat. Pentru parcurgerea vectorului se foloseşte un ciclu for care evoluează de la 0 până la penultimul element (ultima comparaŃie se face între penultimul şi ultimul element). dacă v[i] este mai mic decât min atunci elementul v[i] reprezintă un minim local şi deci valoarea lui v[i] i se atribuie variabilei min. ind = 1. scanf("%d". for(i = 0. tmp. împreună cu dimensiunea sa efectivă. #include <stdio. cu rol de indicator. &n). ============================= P6. Algoritmul parcurge vectorul şi testează la fiecare pas al ciclului for pentru fiecare element v[i]. n. variabilele min şi max conŃin valorile minimă respectiv maximă din vectorul v. „bubble-sort”. } } } while(ind).h> #include <stdlib. Dacă o pereche de elemente succesive este în ordinea dorită se trece la compararea următoarei perechi. for(i = 0. Anterior acesteia a fost citit numărul de elemente ale vectorului. n. system("PAUSE"). &v[i]). i++) printf("v[%d] = %d\n". respectiv până când ind îşi păstrează valoarea 0 după parcurgerea întregului vector. return 0. Aceasta variabila se iniŃializează cu valoarea 0 înaintea unui ciclu care compară perechile succesive de elemente ale vectorului. Dacă o pereche de elemente nu se află în ordinea dorită se schimbă între ele şi variabilei ind i se atribuie valoarea 1. scanf("%d". în limba engleză. Se va utiliza metoda de ordonare (se utilizează şi termenul sortare) denumită. i. elementul curent şi următorul. i++) { if(v[i] > v[i+1]) { tmp = v[i].h> int main() { int v[20].

&n).5 ScrieŃi un program care citeşte o matrice de maxim 10 × 10 elemente întregi. de linii: "). i++) { for(j = 0. j++) printf("%d\t".A[i][j]). 2-3 etc. de coloane: 2 A[0][0] = 1 A[0][1] = 2 A[1][0] = 3 A[1][1] = 4 Matricea citita este: 1 2 3 4 Matricea avand coloanele interschimbate este: 2 1 4 3 Dacă se introduce o altă matrice rezultatul va fi: Introduceti nr. for(i = 0. j++) printf("%d\t". i. scanf("%d". tmp. scanf("%d". de linii: 3 Introduceti nr. j < n. j += 2) for(i = 0. j. &A[i][j]). 0-1.P6. i < m. printf("Introduceti nr. j < n. j). for(i = 0. i++) { for(j = 0. i. împreună cu dimensiunile sale efective (linii respectiv coloane) şi afişează atât matricea iniŃială cât şi matricea având coloanele pare interschimbate cu coloanele impare (interschimbarea afectează coloanele alăturate. &m). i < m. for(i = 0. de coloane: 5 A[0][0] = 1 A[0][1] = 2 A[0][2] = 3 A[0][3] = 4 A[0][4] = 5 28 . } for(j = 0. scanf("%d". #include <stdio.h> int main() { int A[10][10]. } printf("\nMatricea citita este:\n").). i++) for(j = 0.h> #include <stdlib. return 0. de coloane: "). i < m. j < (n / 2) * 2. j++) { printf("A[%d][%d] = ". } printf("\nMatricea avand coloanele interschimbate este:\n"). printf("\n"). A[i][j]). printf("Introduceti nr. } system("PAUSE"). de linii: 2 Introduceti nr. j < n. A[i][j+1] = tmp. n. printf("\n"). m. i++) { tmp = A[i][j]. } Programul va afişa pe ecran după compilare şi execuŃie: Introduceti nr. i < m. A[i][j] = A[i][j+1].

6 ScrieŃi un program care citeşte de la tastatură o matrice pătrată de dimensiune maximă 10 × 10 elemente reale împreună cu dimensiunea sa efectivă şi determină şi afişează suma elementelor de pe diagonala principală şi de pe diagonala secundară.A[1][0] A[1][1] A[1][2] A[1][3] A[1][4] A[2][0] A[2][1] A[2][2] A[2][3] A[2][4] = = = = = = = = = = 6 7 8 9 10 11 12 13 14 15 este: 3 8 13 4 9 14 5 10 15 Matricea citita 1 2 6 7 11 12 Matricea avand coloanele interschimbate este: 2 1 4 3 5 7 6 9 8 10 12 11 14 13 15 DiscuŃie: – AtenŃie: dacă textul problemei nu specifică în mod explicit că avem de a face cu o matrice pătrată. scanf("%f". Reprezentarea sugestiva a parcurgerii matricei în acest caz este prezentată în Figura 6. float sum1 = 0. A[0][0] A[0][1] A[0][0] A[0][1] A[1][0] A[1][1] (6.h> int main() { float mat[10][10]. toate coloanele j se interschimbă cu coloanele j+1 utilizând o variabilă temporară tmp pentru fiecare element A[i][j]. care utilizează contorul i. j++) { printf("Introduceti mat[%d][%d]: ".a) A[1][0] A[1][1] (6. i++) { for(j = 0. } printf("\n"). i++) for(j = 0.0. &mat[i][j]). &dim). #include <stdio.3f\t". } 29 .j.mat[i][j]). /* Citirea matricei */ for(i = 0.h> #include <stdlib. utilizând şi parcurgerea pe coloane şi apoi pe linii ca în Figura 6. parcurge liniile matricei.0.b. ============================= P6.b) – Interschimbarea coloanelor pare cu cele impare se face utilizând a doua modalitate de parcurgere a matricei. sum2 = 0. i < dim. i. a doua. parcurge coloanele matricei A. int dim.a. Parcurgerea unei matrice se poate face. printf("Introduceti dimensiunea matricei patrate: "). j < dim. j < dim. matricea prelucrată poate avea numărul de linii diferit de cel de coloane! – Citirea elementelor matricei A se face cu ajutorul a două cicluri for imbricate: prima din ele. în general. j++) { printf("%1. i < dim. i . } /* Afisarea matricei citite */ printf("\nMatricea introdusa este:\n\n"). scanf("%d". Cu excepŃia cazului când n este impar. ce utilizează contorul j. j). for(i = 0.

000 14.3f\n".000 2.000 7.000 5. j. #include <stdio. &dim). printf(" este %1. Recomandăm ca citirea dimensiunii să se facă astfel: do { printf("Introduceti dimensiunea matricei patrate: ").000 Suma elementelor de pe diagonala principala este 34. 30 .000 9. return 0. sum1).000 6. s2[101].7 ============================= ScrieŃi un program care citeşte două şiruri de maximum 100 de caractere de la tastatură. sum2). Aceste elemente au acelaşi indice pentru linii şi coloane. Programul nu verifică faptul că dimensiunea nu depăşeşte dimensiunea maximă.000 16.000 10.000 DiscuŃie: – Mai întâi se citeşte dimensiunea efectivă a matricei şi apoi elementele sale.000 Suma elementelor de pe diagonala secundara este 34.000 13.000 12. după compilare şi execuŃie: Introduceti Introduceti Introduceti Introduceti Introduceti Introduceti Introduceti Introduceti Introduceti Introduceti Introduceti Introduceti Introduceti Introduceti Introduceti Introduceti Introduceti dimensiunea matricei patrate: 4 mat[0][0]: 1 mat[0][1]: 2 mat[0][2]: 3 mat[0][3]: 4 mat[1][0]: 5 mat[1][1]: 6 mat[1][2]: 7 mat[1][3]: 8 mat[2][0]: 9 mat[2][1]: 10 mat[2][2]: 11 mat[2][3]: 12 mat[3][0]: 13 mat[3][1]: 14 mat[3][2]: 15 mat[3][3]: 16 Matricea introdusa este: 1./* Suma elementelor de pe diagonala principala */ for(i = 0. printf(" este %1. i++) sum1 += mat[i][i]. scanf("%d". i < dim. concatenează al doilea şir de caractere la primul şi afişează rezultatul. – Se calculează şi se afişează suma elementelor de pe diagonala principală. – Se calculează şi se afişează suma elementelor de pe diagonala secundară.000 15.000 4. /* Suma elementelor de pe diagonala secundara */ for(i = 0. system("PAUSE").000 11.h> #include <stdlib. } Programul va afişa pe ecran.000 8.h> int main() { char s1[201]. int i. Aceste elemente au indicele coloanei egal cu „dimensiunea – indicele rândului – 1”. În expresia anterioară trebuie să scădem 1 pentru că în C numărătoarea începe de la 0! P6. } while(dim < 1 || dim > 10). printf("\nSuma elementelor de pe diagonala secundara").3f\n". i++) sum2 += mat[i][dim-i-1]. i < dim.000 3. printf("\nSuma elementelor de pe diagonala principala"). – Apoi se afişează matricea citită pentru a verifica datele introduse.

printf("Introduceti sirul 2: "). Corpul instrucŃiunii while conŃine o instrucŃiune vidă întrucât atribuirile sunt realizate direct în condiŃia instrucŃiunii. se atribuie s1[i] = NULL. i++. s2). /* atribuie de la capatul sirului 1 caracterele din s2 cat timp mai sunt caractere in s2 */ while(s2[j] != NULL) { s1[i] = s2[j]. scanf("%s". s2).h> int main() { char s1[201]. system("PAUSE"). Cât timp rezultatul atribuirii s1[i] = s2[j] nu este NULL. s1 şi s2. 31 . strcat(s1. } Dacă se introduc de la tastatură şirurile "aaa" respectiv "bbb" programul va rula astfel: Introduceti sirul 1: aaa Introduceti sirul 2: bbb aaabbb DiscuŃie: – Cele două şiruri de caractere. j++. Din acel moment caracterele din al doilea şir se adaugă în continuare în primul şir cu al doilea ciclu while. while(s1[i] != NULL) i++. adică sir2 nu s-a terminat. scanf("%s". return 0. int i. – Se remarcă utilizarea operatorului de post-incrementare. return 0.h> #include <stdlib. Programul va afişa rezultatul. printf("Introduceti sirul 1: ").h> #include <stdlib. s1).h> int main() { char sir[101]. care se va elimina din şirul de caractere dacă el există în şir. printf("Introduceti sirul 1: "). s2). j. – Primul ciclu while parcurge sir1 până la capăt prin detectarea condiŃiei s1[i] == NULL. s2[101]. scanf("%s". printf("%s\n". printf("Introduceti sirul 2: "). se incrementează i.i = j = 0. scanf("%s". c. s1). } ============================= P6.h> #include <string. apoi se incrementează j. – Problema se poate rezolva şi apelând funcŃia standard strcat() astfel: #include <stdio. system("PAUSE"). printf("apoi caracterul ce se doreste eliminat ").8 ScrieŃi un program care citeşte un şir de maximum 100 de caractere de la tastatură şi apoi citeşte încă un caracter separat. printf("%s\n". sunt citite cu ajutorul funcŃiei scanf(). – La ieşirea din al doilea ciclu while. #include <stdio. s1). printf("Introduceti sirul de caractere\n"). Al doilea ciclu while se putea scrie condensat astfel: while((s1[i++] = s2[j++]) != NULL). pentru a marca sfârşitul şirului concatenat. } s1[i] = NULL. s1).

} system("PAUSE"). for(i = j = 0. j++. care este următorul element din sir. sir[i] != c. i++) if(sir[i] != c) sir[j++] = sir[i]. } Dacă de la tastatură se introduce şirul "abcd".printf("separat prin spatiu\n"). &c).h> #include <stdlib. while(i >= 0) { i--. Dacă elementul curent este identic cu caracterul ce se doreşte eliminat. scanf("%s %c". atunci atribuirea anterioară nu are loc. programul va rula astfel: Introduceti sirul de caractere apoi caracterul ce se doreste eliminat separat prin spatiu orar o rar DiscuŃie: – Ciclul for parcurge şirul de caractere. printf("%c". sir[j] = NULL.h> int main() { char sir[101]. } Dacă se introduc de la tastatură şirul "orar" respectiv caracterul 'o'. sir). astfel că în următoarele iteraŃii. sir). while(sir[i] != NULL) i++. sir[i] != NULL. sir. sir[j]. se testează dacă elementul curent este diferit de caracterul ce se doreşte eliminat. printf("%s\n". adică sir[i] != NULL. echivalentă cu secvenŃa: sir[j] = sir[i]. return 0. – De remarcat atribuirea sir[j] = NULL care marchează sfârşitul de şir. #include <stdio. programul va rula astfel: abcd dcba ============================= 32 . int i = 0. ============================= P6. scanf("%s". sir. (j se incrementează pentru a pregăti următoarea iteraŃie). va fi suprascris cu primul caracter diferit de c întâlnit în sir. sir[i]). system("PAUSE").9 ScrieŃi un program care citeşte un şir de maximum 100 de caractere de la tastatură şi afişează acest şir în ordine inversă. return 0. şi dacă da atunci elementul curent din şir se păstrează pe poziŃia curentă prin atribuirea sir[j++] = sir[i]. Cât timp nu s-a atins sfârşitul şirului.

ScrieŃi un program care citeşte de la tastatură două şiruri de caractere (de maximum 31 de caractere fiecare) şi transformă caracterele majuscule în minuscule şi caracterele minuscule în majuscule. 6. 10. ScrieŃi un program care citeşte de la tastatură un vector de maximum 20 de elemente întregi şi interschimbă elementele de pe poziŃii pare cu cele de pe poziŃiile impare.2. 7. 2. 8.6. ScrieŃi un program care citeşte de la tastatură două şiruri de caractere (de maximum 11 caractere fiecare) şi afişează pe ecran numărul de apariŃii ale caracterelor din primul şir în cel de al doilea şir. ScrieŃi un program care citeşte de la tastatură o matrice de dimensiuni maxime 10 × 10 elemente întregi apoi determină şi afişează elementele maxime de pe fiecare linie. Probleme propuse ScrieŃi un program care citeşte de la tastatură un vector de maximum 50 de numere întregi şi determină numărul elementelor impare ale vectorului. ScrieŃi un program care citeşte de la tastatură doi vectori de maximum 100 de elemente întregi (numărul elementelor poate fi diferit) apoi determină şi afişează intersecŃia celor doi vectori (adică elementele comune celor doi vectori). Exemplu: sir1 = "abcdabcc". 9. ScrieŃi un program care citeşte de la tastatură două şiruri de caractere (de maximum 41 de caractere fiecare) şi determină de câte ori apare secvenŃa de caractere din al doilea şir în primul. ScrieŃi un program care citeşte de la tastatură două şiruri de caractere (de maximum 51 de caractere fiecare) şi elimină toate caracterele conŃinute în al doilea şir din primul şir. Precizare: se vor citi de la tastatură vectorul împreună cu dimensiunea sa efectivă. 3. c = 1" 12. sir2 = "aacde" şi trebuie să rezulte "a = 2. b = 0. ScrieŃi un program care citeşte de la tastatură o matrice pătrată de dimensiuni maxime 100 × 100 elemente reale apoi calculează suma elementelor de sub şi de deasupra diagonalei principale. ScrieŃi un program care citeşte de la tastatură o matrice pătrată de dimensiuni maxime 10 × 10 elemente reale. ScrieŃi un program care citeşte de la tastatură două matrice A şi B (de dimensiuni maxime 10 × 10 elemente reale) apoi calculează produsul lor. Precizare: programul va semnala cazul în care cele doua matrice nu se pot înmulŃi. sir2 = "ad" şi trebuie să rezulte "bcbc". 11. 13. 4. 1. ScrieŃi un program care citeşte de la tastatură un vector de maximum 15 elemente întregi şi inserează un element pe o poziŃie k. afişează matricea transpusă şi apoi calculează suma elementelor matricei. Exemplu: sir1 = "abc". 33 . elementul ce se doreşte inserat precum şi poziŃia unde se doreşte inserat elementul. Exemplu: sir1 = "abcdabcd". ScrieŃi un program care citeşte de la tastatură un vector de maximum 30 de elemente întregi şi sortează în ordine crescătoare doar elementele de pe poziŃiile impare. sir2 = "ab" şi programul trebuie să afişeze "Sirul ab apare de 2 ori". 5. Exemplu: sir = "abcdABC" şi programul trebuie să afişeze "ABCDabc".

prenumele şi data naşterii.luna. i < n. uniuni.datan. &grup[i]. return 0.h> int main() { struct data { int zi. &grup[i]. Precizări: Pentru fiecare persoana se vor memora numele.zi <= 0) && (grup[i].1 Alte tipuri de date: structuri. grup[i].prenume.an. Datele fiecărei persoane va fi memorat sub forma unei structuri.datan. int i. Data naşterii va fi tot o structură care va avea câmpurile zi. &grup[i].datan.zi). grup[i]. grup[i]. tipul enumerat Probleme rezolvate ScrieŃi un program care citeşte datele pentru un grup de cel mult 10 persoane şi afişează datele citite. char luna[12].zi). printf("\n").h> #include <stdlib.datan. struct data datan. struct persoana grup[10]. do { printf("Introduceti numarul de persoane: ").1.datan. struct persoana { char nume[20]. }. i < n. } while((grup[i].nume. } printf("Nume Prenume An Luna Zi\n"). i++) printf("|%s\t|%s\t|%d\t|%s\t|%d\t|\n". char prenume[20]. &grup[i]. P7.7.datan.luna.nume.zi >= 31))). int an.an < 0) || ((grup[i]. grup[i]. grup[i]. scanf("%d". &n).datan. &grup[i]. for(i = 0.datan. for(i = 0. } while ((n <= 0) || (n > 10)). 7.an.prenume. #include <stdio. } Programul va afişa: Introduceti numarul de persoane: 2 Nume Prenume An Luna Zi POPA Marius 1980 Mai 22 Nume Prenume An Luna Zi DUTA Ioana 1981 Iunie 2 Nume Prenume An Luna Zi |POPA |Marius |1980 |Mai |22 |DUTA |Ioana |1981 |Iunie |2 | | 34 .datan. scanf("%s\t%s\t%d\t%s\t%d". }. i++) { do { printf("Nume Prenume An Luna Zi\n"). lună şi an. n. system("PAUSE").

} complex.real).2 ScrieŃi un program care citeşte două numere complexe de la tastatură. de exemplu. – Al treilea ciclu for afişează rezultatele citite de la tastatură ca un tabel sub forma: | Nume | Prenume | An | Luna | Zi |.0 Introduceti partea reala a celui de al doilea nr. a şi b se citesc de la tastatură iar rezultatul sumei complexe se atribuie variabilei sum. complex a. Deci corpul ciclului va fi executat până când n va fi în intervalul [1. – Al doilea ciclu for citeşte element cu element persoanele din variabila grup. – Variabila grup este un tablou de 10 elemente de tipul persoana.. b şi sum sunt cele trei variabile utilizate în cadrul programului.imag).real = a.3 ScrieŃi un program care citeşte şi stochează două momente succesive de timp. 10]. Programul va afişa timpul scurs între cele două momente.imag + b. printf("Introduceti partea scanf("%f". a. sum.real. momentul la care a plecat un atlet şi respectiv a sosit un atlet într-o competiŃie.2f + (%. } reala a primului nr.: "). ============================= P7. Al treilea câmp are la rândul sau trei alte câmpuri: zi. #include <stdio. calculează şi afişează suma celor două numere complexe. &b.: -0.. b. &b.DiscuŃie: – În programul anterior se definesc două structuri: data şi persoana..” aplicat de două ori asupra unei variabile de tipul grup[i].: "). Această atribuire se poate face numai utilizând operatorul . Structura persoana utilizează un câmp datan care este de tipul struct data.2 Introduceti partea imaginara a primului nr. n. &a. De notat că atribuirea sum = a + b nu este posibilă în C. ============================= P7. printf("Suma celor doua numere complexe este: ") .00 + (1. Programul va afişa: Introduceti partea reala a primului nr.: 1.imag). – Primul ciclu do – while citeşte numărul de persoane.: "). reala celui de al doilea nr. luna şi an.: 1. De notat că elementul grup[i] are 3 câmpuri: primele două (nume.” pentru a selecta individual câmpurile real şi imag. care trebuie să fie un număr pozitiv şi mai mic decât 10.h> int main(void) { typedef struct { float real. Precizare: Un număr complex se va memora sub forma unei structuri cu câmpurile real şi imag.00) * i DiscuŃie: DeclaraŃia typedef introduce un tip utilizator cu numele complex. prenume) sunt de tipul şir de caractere în timp ce al treilea este de tipul struct datan. system("PAUSE"). scanf("%f". printf("Introduceti partea scanf("%f".real + b. ce reprezintă. printf(" %. printf("Introduceti partea printf("doilea nr. Structura are doua câmpuri: real şi imag de tipul float.: 0 Suma celor doua numere complexe este: 1.2f) * i\n". imaginara celui de al ").h> #include <stdlib. sum.2 Introduceti partea imaginara a celui de al doilea nr. sum.imag). printf("Introduceti partea scanf("%f".imag = a. &a. return 0.real. float imag. imaginara a primului nr.imag.. sum.: ").real). Deci pentru accesarea acestor subcâmpuri avem nevoie de operatorul . 35 . sum.

h> int main() { struct timp { int ora. system("PAUSE").sec). minutul şi secunda în care a plecat respectiv a terminat proba atletul. int start_int.start_int). /* secunda */ }.". start_int = start.ora. /* ora */ int min. ============================= P7. printf("timp: %d s\n". sizeof(struct exemplu)). RelaŃia de calcul are în vedere faptul că o oră are 3600 de secunde iar un minut are 60 de secunde.min. se va afişa: 10 codat este: 167772160 167772160 decodat este: 10 36 . stop_int = stop. } s.4 ScrieŃi un program care determină spaŃiul de memorie ocupat de o structură. reprezintă echivalentul în secunde al timpului efectuat. printf("Introduceti stop: "). system("PAUSE"). &stop. printf("Introduceti start: "). } Programul va afişa: Introduceti start: 10:11:10 Introduceti stop: 10:12:11 timp: 61 s DiscuŃie: − start şi stop reprezintă două variabile care stochează ora. ============================= P7. stop_int .5 ScrieŃi un program care codează şi decodează un întreg folosind uniuni prin inversarea ordinii octeŃilor care compun numărul întreg. stop_int . scanf("%d:%d:%d".ora * 3600 + start.sec. struct timp start.ora. &start. &start. DiferenŃa dintre cele două variabile.ora * 3600 + stop. #include <stdio.sec).start_int. int *p. stop_int. int main() { printf("Structura exemplu are dimensiunea: %d octeti.h> #include <stdlib. return 0. stop.h> struct exemplu { int i. char str[80]. &stop. &stop. Pentru valorile variabilelor din program. } Programul va afişa: Structura exemplu are dimensiunea: 96 octeti. return 0.h> #include <stdlib. start_int şi stop_int reprezintă echivalentul în secunde al celor două momente de timp.min * 60 + stop.min. double d.min * 60 + start.sec. printf("\n"). scanf("%d:%d:%d".#include <stdio. &start. /* minutul */ int sec.

h> int encode(int i). printf("Intoduceti un numar intreg: ").c[0].c[2] = ch.num.num = i. i). u. printf("\n"). int i.c[2]. printf("%d codat este: %d\n". /* decodarea intregului */ crypt.c[0]. unsigned char ch.#include <stdio.c[3]. char c[4].num = in.c = 'A'.c[1].c[0] = crypt. ch = crypt.c[0] = crypt.c). in = crypt. i = crypt. u.h> #include <stdlib. /* codarea intregului */ crypt.h> int main() { union { char c. } u. system("PAUSE"). un caracter. crypt. crypt. float f. &in).i = 65. scanf("%d".c[1]. return 0. printf("%d decodat este: %d". ch = crypt. } crypt.c[2] = ch.i). ch = crypt.num. int in. crypt. P7.6 ScrieŃi un program care memorează pe rând. 37 . union coddecod { int num. ch = crypt.c[1] = crypt.c[2]. in). un număr întreg şi un număr real. printf("Codul ASCII: %d\n". printf("Un caracter: %c\n".c[1] = crypt. u. u. crypt. după compilare şi execuŃie: Intoduceti un numar intreg: 10 10 codat este: 167772160 167772160 decodat este: 10 DiscuŃie: – Prin intermediul unei uniuni se pot accesa octeŃii care compun un număr întreg. crypt. crypt. i. crypt.c[3] = ch. int main() { int i.c[3]. in.c[3] = ch. } Programul va afişa pe ecran. în acelaşi spaŃiu de memorie.h> #include <stdlib. crypt. #include <stdio.

– Următoarele 2 linii atribuie câmpului f o valoare egală cu vechea valoare a câmpului i (adică 65) la care se adună 0. break. Întrucât codul ASCII are valoarea 65 (el având asociat caracterul 'A'). z.u.14 Aria cercului de raza 2: 0. u. case 2: printf("Un float: %f\n".2f\n".h> #include <stdlib.c + 1). ============================= P7. switch (z. – Ultimele trei linii ilustrează calculul ariei unui cerc într-un mod greşit.u.i). câmpului i. valoarea câmpului c este distrusă.f = 3. Variabila este apoi tipărită cu ajutorul specificatorului de format %c pentru caractere.i = 2.f = 3.f * u.14 (adică numărul PI) şi u. u. u. A treia linie ilustrează tipărirea caracterului asociat codului ASCII imediat următor. În acest moment.h> int main() { struct { int tip.00 DiscuŃie: – În cadrul programului se defineşte o variabilă u având tipul „union”.i îşi pierde valoarea 65. u. case 1: printf("Un intreg: %d\n". în lucrul cu uniuni trebuie avut grijă ca la orice moment de timp să fie ştiut tipul datei ce se află stocat în variabila uniune. return 0. z.c). } z. break. int i. default: printf("Format necunoscut\n").i. return 0. se pierde numai după ce a avut loc atribuirea. break.u. system("PAUSE"). u.i). u. – Primele două linii după declararea variabilei atribuie variabilei u.tip = 2.14. #include <stdio.f = u. Variabila poate stoca la un moment dat un caracter. în câmpul c (adică u. În acest punct al execuŃiei programului.i * u. } Programul va afişa: Un caracter: A Codul ASCII: 65 Caracterul urmator: B Un float: 65. u. z.tip = 0.141500 38 .tip) { case 0: printf("Un caracter: %c\n". union { char c.c = 'A'.14. z.7 ReluaŃi problema anterioară dar construiŃi şi o metodă care vă permite să aflaŃi în orice moment tipul informaŃiei stocate. Întrucât o variabilă de tipul enumerat poate lua valori de mai multe tipuri în timpul execuŃiei programului. } Programul va afişa: Un float: 3. z. adică ordinea operaŃiilor se desfăşoară astfel încât se adună întâi 65 cu 0. } system("PAUSE"). 65.14.printf("Caracterul urmator: %c\n". un întreg sau un număr real. Tipărirea se va face utilizând specificatorul de format %d. break.14 şi apoi se atribuie lui u.2f\n".u. z. printf("Aria cercului de raza %d: %.f). printf("Un float: %.14.i + 0.f). În primele două linii atribuirile u.f valoarea 65. programul va afişa caracterul 'B'. z.i = 2 (adică raza cercului) au ca efect modificarea valoarea lui PI astfel încât rezultatul final este în mod greşit altul decât cel aşteptat. float f. De remarcat faptul că vechea valoare. u. } u.u.f = 3. de data aceasta. – Următoarele trei linii ilustrează atribuirea valorii 65.c) valoarea 'A'.1415.

for(activitate = laborator. parŃial şi examen) ale unei materii (fizică. didactic şi materii. fiecare materie având examinări. biologie. biologie. parŃial şi lucrarea finală.DiscuŃie: – Acest program ilustrează utilizarea unei uniuni. #include <stdio. Variabilele activitate şi materie sunt de tipul didactic respectiv materii. pentru fiecare din cele materii. suma/3). Valorile pe care le ia câmpul tip (de exemplu: 0 pentru caractere. } În urma introducerii notelor la laborator. materie <= chimie. } printf("Media = %. float nota.8 ScrieŃi un program care calculează media notelor obŃinute la probele de verificare (laborator. de exemplu.2f\n". programul va afişa: 9 10 10 Media = 9. &nota). la laborator. Astfel. materii materie. typedef enum {fizica. tip. În interiorul acestuia se citeşte succesiv variabila nota.h> int main() { typedef enum {laborator. se afişează valoarea mediei. ============================= 39 . Cu ajutorul a două cicluri for se parcurg toate materiile posibile. funcŃie de valoarea din câmpul tip (0. Structura are un câmp.67 8 8 7. suma. – InstrucŃiunea switch decide.h> #include <stdlib. pe parcursul semestrului. – Variabilele nota şi suma sunt de tipul float. pot fi modificate la momentul atribuirii unui subcâmp al uniunii. Variabila suma se iniŃializează cu valoarea 0 la începutul celui de al doilea ciclu for. suma += nota. – Programul defineşte două enumerări. aceasta urmând să se adune la totalul din variabila suma. z. cum trebuie afişată variabila z. La finalul fiecărei materii. return 0. partial. parŃial sau examen) respectiv numele materiilor la care s-a efectuat examinarea (fizica. } system("PAUSE"). biologie şi chimie) utilizând tipul enumerat. 1 pentru întregi şi 2 pentru real). programul afişează media la materia respectivă. având ca membri tipul de examinare (laborator. u. u. respectiv la examenul final. chimie} materii. – La finalul ultimului ciclu for. activitate <= examen. respectiv toate probele. 1. activitate++) { scanf("%f". 2).83 DiscuŃie: – Programul anterior citeşte de la tastatură notele obŃinute de un student la diferite materii. ============================= P7. de tipul întreg. for(materie = fizica. examen} didactic. în cadrul unei structuri. chimie).0. în orice moment de timp se cunoaşte tipul stocat în câmpul u după valorile câmpului tip.5 Media = 7. materie++) { suma = 0. didactic activitate.

calculează şi afişează produsul complex al tuturor elementelor sale.2. octet6. Va trebui ca mai întâi să stabiliŃi ce tip de calculator folosiŃi şi apoi să parcurgeŃi octeŃii în ordinea corespunzătoare. ScrieŃi un program care implementează o agendă telefonică sub forma unei structuri cu următoarea definiŃie: typedef struct { char nume[20]. ScrieŃi un program care memorează scorurile obŃinute de cel mult 10 jucători împreună cu numele jucătorilor. 8. } punct. ModificaŃi programul P7. ci şi timpul efectuat sub forma: ore : minute : secunde. char prenume[20]. InformaŃiile se vor memora într-o matrice constituită din structuri definite astfel: typedef struct { char nume[20]. 4. y. unsigned int cod_postal. calculează şi afişează suma complexă a tuturor elementelor sale. 6. int scor. Exemplu: 3700 secunde reprezintă 1 ora. unsigned int numar. ScrieŃi un program care citeşte de la tastatură un vector de elemente complexe. − pentru a accesa octeŃii care formează un număr de tip double utilizaŃi uniunea: typedef union { char octet[8]. octet1. Precizări: − ordinea în memorie a octeŃilor depinde de platforma de calcul: există calculatoare de tip „BIG_ENDIAN”. 40 . şi octet0. 1 minut şi 40 de secunde adică „1:1:40”. − punctele se vor memora într-o matrice definită astfel: punct mase[MAX].8 astfel încât să memoreze numele materiilor şi notele obŃinute în structuri. unsigned int mobil. 5. 3. unsigned int prefix.7. − structura va putea fi alcătuită din cel mult 100 de puncte. 7. char adresa[20]. } valoare. unde octet7 este octetul cel mai semnificativ iar octet0 este octetul cel mai puŃin semnificativ. ScrieŃi un program care scrie octeŃii care formează o valoare de tip double sub formă zecimală în ordinea octet7. masa. octet5.3 astfel încât să nu mai afişeze numai numărul total de secunde. 1. octet2. 2. Precizări: − fiecare coordonată împreună cu masa asociată se va memora într-o structură definită astfel: typedef struct { float x. } intrare. octet4. Să se modifice programul P7. Probleme propuse ScrieŃi un program care citeşte de la tastatură un vector de elemente complexe. la care primul octet din memorie este cel mai puŃin semnificativ şi de tip „LITTLE_ENDIAN” la care primul octet este cel mai semnificativ. double numar. } jucator. octet3. ScrieŃi un program care citeşte de la tastatură un vector de coordonate ale unei structuri împreună cu masele plasate la coordonatele respective şi calculează centrul de greutate al structurii.

P8. i <= n.8.3f\n".h> float f(float x) { return (x * x .a) / n. scanf("%f". b] ale cărui limite se vor citi de la tastatura. Limitele intervalului vor fi specificate de utilizator.h> #include <stdlib. printf("b = "). for(i = 1.671 DiscuŃie: – Programul reprezintă implementarea directă a metodei dreptunghiurilor folosită la integrarea numerică a unei funcŃii pe un interval dat. i. scanf("%d". int n. eps. 41 . într-un interval [a. ============================= P8.2 ScrieŃi un program care afişează numerele pare dintr-un interval [a.1 FuncŃii simple.h> #include <stdlib. printf("Introduceti limita de inceput a intervalului: "). printf("Valoarea integralei este %. intg = f(a) * eps. printf("Introduceti limita de sfarsit a intervalului: "). intg. &a). Calculul valorii funcŃiei într-un punct se face cu ajutorul funcŃiei f(). intg += f(a + /* pasul integrarii */ /* primul dreptunghi */ i++) i*eps) * eps. scanf("%d". &a). #include <stdio. 8.1. printf("a = ").x + 1). &b). scanf("%d". system("PAUSE"). după compilare şi execuŃie: Introduceti limita de inceput a intervalului: 0 Introduceti limita de sfarsit a intervalului: 2 Introduceti numarul de subintervale de discretizare: 1000 Valoarea integralei este 2. else return 0. printf("Introduceti numarul de subintervale "). b. b] cu ajutorul unei funcŃii.h> int par(int k) { if(k % 2 == 0) return 1. return 0. #include <stdio. } int main() { int a. } Programul va afişa pe ecran. printf("de discretizare: "). eps = (b . b. Utilizatorul va specifica şi numărul de subintervale de discretizare. &b). recursivitate Probleme rezolvate ScrieŃi un program care calculează integrala unei funcŃii oarecare. scanf("%f". Metoda de integrare este metoda dreptunghiurilor. } int main() { float a. intg). &n). /* numarul de subintervale */ int i.

printf("%d! = %d\n". j. k = factorial(n). } Programul va afişa pe ecran. return 0. do { printf("Introduceti n: "). daca nu este par returnează 0. după compilare şi execuŃie: Introduceti n: 12 12! = 479001600 DiscuŃie: – Programul verifică valoarea introdusă deoarece o valoare eronată poate conduce la executarea la nesfârşit a funcŃiei factorial(). } int main() { int i. n. n. ============================= P8. n! =  n ⋅ (n − 1)! .m.. Cel mai mare divizor comun se va calcula recursiv astfel: 42 . i <= b. FuncŃia factorial() se auto-apelează până când se ajunge la factorial de 1. k). } Programul va afişa pe ecran.c. al celor două numere. pentru n > 1 Calculul factorialului se va realiza cu ajutorul unei funcŃii recursive.i). c.3 ScrieŃi un program care citeşte un număr natural n şi calculează şi afişează factorialul numărului n definit astfel: pentru n = 1 1. Pentru fiecare element din interval funcŃia par() verifică dacă acesta este par.1)).m. k. return 0. else return (n * factorial(n .h> #include <stdlib. printf("\n"). Daca este par funcŃia returnează 1. system("PAUSE"). ============================= P8. } while(n < 1).for(i = a. i++) if(par(i) == 1) printf("%d ". system("PAUSE").d. după compilare şi execuŃie: a = 1 b = 20 2 4 6 8 10 12 14 16 18 20 DiscuŃie: – Parcurgerea intervalului se face în programul principal. #include <stdio. &n).h> int factorial(int n) { if(n == 1) return 1. scanf("%d".4 ScrieŃi un program care citeşte două numere naturale a şi b şi calculează şi afişează cel mai mare divizor comun.

m.m.5 ScrieŃi un program care citeşte un număr şi stabileşte şi afişează dacă numărul este prim sau nu. if(a > b) a = cmmdc(a . k. b). j. printf("Introduceti un numar natural: "). b) = c. int i) { if(n % i == 0) return 0. &n). } 43 . scanf("%d". Se va scrie şi utiliza o funcŃie care verifică dacă un număr este prim. } int main() { int n. else return 1.dacă a = b a  c. int b) { if(a == b) return a. scanf("%d". else { i = n+1. b). #include <stdio.c.m. i) == 1) i++. if(a < b) a = cmmdc(a. b − a ) dacă b > a c. a.h> int divizibil(int n .c.m. ============================= P8.( a.m.h> #include <stdlib. printf("\n").( a − b.d.d. &b). } DiscuŃie: – Se remarcă faptul că funcŃia cmmdc() implementează exact definiŃia matematică formulată în enunŃ.c. i. system("PAUSE"). b. return 0.h> int cmmdc(int a. return 0. return a. } int main() { int i. scanf("%d". b . k = cmmdc(a.h> #include <stdlib. while(i < n) { if(divizibil(n. b) dacă b < a  #include <stdio. &a).b. system("PAUSE"). i = 2.} } if(i == n) printf("Este prim\n").m.a). printf("Nu este prim\n").(a . k). printf("%d".d. Programul principal nu face decât să citească cele două numere. să apeleze funcŃia cmmdc() şi să afişeze rezultatul.

7 ScrieŃi un program care calculează media aritmetică a elementelor unui vector cu ajutorul unei funcŃii.1). &p).Programul va afişa pe ecran.h> float medie(int x. } 44 .h> #include <stdlib. int p) { if(p == 1) return n. k = putere(n. ============================= P8. Valoarea expresie va fi afişată.6 ScrieŃi un program care citeşte două numere naturale n şi p şi calculează cu ajutorul unei funcŃii recursive valoarea expresiei np. int n) { s = s + z. p .h> #include <stdlib. Atunci când am găsit un divizor înseamnă că numărul nu este prim şi ieşim din ciclul while (i devine n + 1). FuncŃia divizibil verifică dacă contorul i care parcurge intervalul divide pe n. n. float s . Daca îl divide returnează 0 iar dacă nu îl divide returnează 1. după compilare şi execuŃie: Introduceti un numar natural: 397 Este prim DiscuŃie: – Pentru a verifica dacă un număr. } ============================= P8. system("PAUSE"). k). j. n. return n. FuncŃia np se va defini astfel: dacă p = 1 n np =  p −1 dacă p > 1 n ⋅ n #include <stdio. else { n = n * putere(n. &n). p). return 0. return n. if(x == n) s = s / n. int z. Ea se poate scrie mai compact astfel: int putere(int n. int p) { if(p != 1) n = n * putere(n. scanf("%d". p. #include <stdio. printf("Introduceti 2 numere naturale: "). scanf("%d".h> int putere(int n. return s. printf("%d\n". k.1). n) şi pentru fiecare număr din interval se verifică dacă acesta este divizor al lui n. } } int main() { int i. este prim se parcurge intervalul (1. } Programul va afişa pe ecran. după compilare şi execuŃie: Introduceti 2 numere naturale: 2 16 65536 DiscuŃie: – FuncŃia putere implementează direct definiŃia propusă. p .

i = 99. &v[i]). s = k. k. float s.8 ScrieŃi un program care verifică transferul unei structuri.h> #include <stdlib. temp. Această funcŃie calculează şi afişează diferenŃa dintre cele două câmpuri. v[10]. după compilare şi execuŃie: n = 4 v[1] = 1 v[2] = 2 v[3] = 3 v[4] = 4 Media este 2. } s = 0. return 0. } printf("Media este %f\n". scanf("%d". funcŃiei medie() i se transmit poziŃia curentă (i).500000 DiscuŃie: – La parcurgerea vectorului. system("PAUSE").i). } void f(struct strp2 temp) { printf("Diferenta dintre cele 2 elemente "). suma elementelor anterioare (s). i <= n. for(i = 1.d = 98. n). return 0.h> struct strp2 { int i.temp. i <= n. } var1. după compilare şi execuŃie: Diferenta dintre cele 2 elemente ale structurii este: -0. f(var1). n. double d. #include <stdio. i++) { printf("v[%d] = ". var1. către o funcŃie. FuncŃia medie() însumează elementele vectorului (s = s + z) până în momentul în care a însumat şi ultimul element. ============================= P8. printf("n = ").d . } Programul va afişa pe ecran. for(i = 1. i++) { k = medie(i. system("PAUSE"). s.int main() { int i. printf("ale structurii este: %lf\n". ============================= 45 . &n). int main() { var1. scanf("%d". În programul principal se atribuie valori celor două câmpuri ale structurii şi apoi se apelează funcŃia f. v[i].400000 DiscuŃie: – Pentru a face verificarea cerută s-a definit o structură cu marca strp2 care are două câmpuri: i de tip întreg şi d de tip fracŃionar cu precizie dublă. s). i).6. ca parametru. elementul curent (v[i]) şi lungimea vectorului (n). } Programul va afişa pe ecran. Atunci va împarŃi această sumă la numărul de elemente. void f(struct strp2 temp).

201. j. return sum. j. i++) sum += mat[i][i]. } int main() { char sir[201]. } float suma2(float mat[][10]. i++). Precizare: este vorba de reluarea problemei P6. int dim) { int i. Cea de a doua instrucŃiune elimină caracterul „newline” din şirul citit. sir[i] != '\0'.h> #include <stdlib. ============================= P8. int dim) { int i. printf("Lungimea sirului este de %d caractere\n". lungime(sir)). j. i++) for(j = 0. if(sir[strlen(sir)-1] == '\n') sir[strlen(sir)-1] = '\0'.h> #include <stdlib.P8. for(i = 0. #include <stdio. for(i = 0. int dim) { int i. #include <stdio.10 ScrieŃi un program care citeşte de la tastatură o matrice pătrată de dimensiune maximă 10 × 10 elemente reale împreună cu dimensiunea sa efectivă şi determină şi afişează suma elementelor de pe diagonala principală şi de pe diagonala secundară. i. i < dim.9 ScrieŃi un program care determină şi afişează lungimea unui şir de maxim 200 de caractere cu ajutorul unei funcŃii. calculul sumei de pe diagonala principală şi calculul sumei de pe diagonala secundară. i++) sum += mat[i][dim-i-1]. FuncŃia lungime() funcŃionează similar cu funcŃia standard strlen(). Se vor scrie şi utiliza funcŃii separate pentru: citirea matricei. return sum. float sum = 0. j). } 46 . return 0. Se remarcă utilizarea instrucŃiunii vide pentru ciclul for. după compilare şi execuŃie: Introduceti sirul dorit: Acesta este sirul a carui lungime o dorim. &mat[i][j]).h> int lungime(char sir[]) { int i. stdin). scrierea matricei. Pentru citirea şirului de caractere recomandăm utilizarea instrucŃiunilor: fgets(sir. j++) { printf("Introduceti mat[%d][%d]: ". for(i = 0. Lungimea şirului de caractere este determinat prin oprirea ciclului for la întâlnirea caracterului '\0'. } Programul va afişa pe ecran.6 dar cu utilizarea unor funcŃii. gets(sir). scanf("%f". float sum = 0. Lungimea sirului este de 42 caractere DiscuŃie: – Citirea şirului de caractere se realizează apelând funcŃia gets(). return i. printf("Introduceti sirul dorit:\n"). j < dim. – FuncŃia lungime() primeşte ca parametru un vector de caractere. Aşa cum am mai precizat în Capitolul 6. i < dim. for(i = 0. } } float suma1(float mat[][10]. system("PAUSE").h> void citeste(float mat[][10]. i < dim. folosirea acestei funcŃii este nerecomandabilă.

dim)). respectiv. printf("\nSuma elementelor de pe diagonala secundara"). j. print(matrice. for(i = 0.000 12.3f\n". do { printf("Introduceti dimensiunea matricei patrate: ").000 5.mat[i][j]). system("PAUSE"). FuncŃiile suma1() şi suma2() calculează suma elementelor de pe diagonala principală şi. de pe diagonala secundară. j++) { printf("%1. int dim) { int i.000 13. i++) { for(j = 0. suma1(matrice. &dim).000 7. } while(dim < 1 || dim > 10).000 Suma elementelor de pe diagonala secundara este 34.000 14.000 4.000 6. } Programul va afişa pe ecran. j < dim.000 11. citeste(matrice.void tip_mat(float mat[][10]. ============================= 47 . printf(" este %1. int dim. dim). } printf("\n").000 DiscuŃie: – FuncŃia citeste() realizează citirea efectivă a elementele matricei folosind proprietatea particulară a tablourilor de a putea fi modificate într-o funcŃie astfel încât modificările să fie permanente. printf("\nMatricea introdusa este:\n\n"). FuncŃia tip_mat() afişează matricea citită.000 3. suma2(matrice. printf(" este %1. după compilare şi execuŃie: Introduceti Introduceti Introduceti Introduceti Introduceti Introduceti Introduceti Introduceti Introduceti Introduceti Introduceti Introduceti Introduceti Introduceti Introduceti Introduceti Introduceti dimensiunea matricei patrate: 4 mat[0][0]: 1 mat[0][1]: 2 mat[0][2]: 3 mat[0][3]: 4 mat[1][0]: 5 mat[1][1]: 6 mat[1][2]: 7 mat[1][3]: 8 mat[2][0]: 9 mat[2][1]: 10 mat[2][2]: 11 mat[2][3]: 12 mat[3][0]: 13 mat[3][1]: 14 mat[3][2]: 15 mat[3][3]: 16 Matricea introdusa este: 1.000 10. dim)).000 16.3f\n".000 9. } } int main() { float matrice[10][10]. scanf("%d". Programul principal citeşte dimensiunea efectivă a matricei şi apelează funcŃiile definite anterior. i < dim.000 15.000 2.000 8. dim).3f\t".000 Suma elementelor de pe diagonala principala este 34. return 0. printf("\nSuma elementelor de pe diagonala principala").

Precizări: a. 48 . 6. dacă numărul este impar se adună 3 şi se adună 1. float suma_im(complex a. Probleme propuse ScrieŃi un program C care citeşte de la tastatură un vector de maximum 10 numere întregi împreună cu dimensiunea sa efectivă şi separă acest vector în doi vectori: primul vector va fi format din numerele pare din vectorul iniŃial iar cel de al doilea va fi format din numerele impare din vectorul iniŃial. Tabloul de numere complexe va fi declarat utilizând următoarele definiŃii: typedef struct { float re. 5. complex b). SecvenŃa Halberstam a unui număr se calculează astfel: dacă numărul este par el se împarte la 2. 1. ReluaŃi programul anterior. ScrieŃi o funcŃie care calculează suma de plată pentru o activitate primind numărul de ore lucrate şi salariul orar. citirea se repetă până când răspunsul este ‚d’ sau ‚n’.2. element cu element. sau ‚n’. c. 4. ScrieŃi câte o funcŃie care calculează partea reală şi. float im. int par_v[10]). Citirea vectorului se va face cu ajutorul unei funcŃii cu prototipul: void cit_vect(int v[10]. pentru „da”. ScrieŃi şi programul principal care verifică funcŃionarea funcŃiei. respectiv. Se vor forma. partea imaginară a sumei a două numere complexe. int impare(int v[10]. pentru „nu”. Pentru determinarea maximului de pe linii / coloane se va scrie şi utiliza o funcŃie cu prototipul: float max_vec(int dim. ScrieŃi apoi un program care verifică funcŃionarea corectă a funcŃiei. partea reală şi partea imaginară. Pentru orele care depăşesc 60 se plăteşte dublu. vectori din fiecare linie şi apoi din fiecare coloană. 2. Prototipurile acestor funcŃii sunt: float suma_re(complex a. dar pentru formarea vectorilor scrieŃi şi utilizaŃi două funcŃii având prototipurile: int pare(int v[10]. ScrieŃi o funcŃie care afişează o întrebare şi citeşte răspunsul utilizatorului care poate fi doar ‚d’. Dacă numărul de ore lucrate este mai mic decât sau egal cu 40 se plăteşte salariul orar. Precizare: Prototipul funcŃiei este: int ok(char s[]). ReluaŃi programul anterior dar pentru calculul sumei a două numere complexe scrieŃi şi utilizaŃi o funcŃie având prototipul: complex suma(complex a. int impar_v[10]).8. se reiau operaŃiile până când valoarea ajunge egală cu 1. 7. numărul valorilor impare. ScrieŃi un program C care citeşte de la tastatură o matrice de numere reale de dimensiuni maxime 100 × 100 împreună cu dimensiunile sale efective şi afişează elementele maxime de pe fiecare linie şi apoi de pe fiecare coloană. 8. Elementele tabloului se citesc de la tastatură. Pentru orele cuprinse între 40 şi 60 salariul orar creşte cu 50 %. pe rând. Calculul numărului următor al secvenŃei Halberstam se va face cu ajutorul unei funcŃii. b. 3. int dim). ScrieŃi un program C care calculează suma complexă a elementelor dintr-un tablou unidimensional de numere complexe. complex vector[10]. iar pentru fiecare element. Precizări: a. complex b). } complex. Suma globală cerută se va calcula folosind funcŃiile definite anterior. b. Precizări: a. ScrieŃi un program care citeşte un număr natural şi calculează şi afişează secvenŃa Halberstam a acestui număr. b. complex b). float vec[100]). FuncŃiile vor returna numărul valorilor pare şi respectiv.

Moment sosire. c. Prototipul funcŃiei este: int inlocuieste(char sir[]). ScrieŃi o funcŃie care determină şi returnează momentul sosirii primului tren într-o staŃie de cale ferată. Structura pentru memorarea programului de circulaŃie a unui tren va fi definită astfel: typedef struct moment { int ora. care are următorul prototip: int strlen(char s[]). FuncŃia va căuta primul tren care pleacă după ora indicată şi va afişa orele de plecare şi sosire. typedef struct program { Moment plecare. 49 . } Moment. Programul de circulaŃie între două staŃii este alcătuit dintr-un tablou format din structuri de tip Program_tren. „string length”. int minut.9. b. ScrieŃi şi programul principal care verifică funcŃionarea funcŃiei. ScrieŃi o funcŃie care caută toate spaŃiile dintr-un şir de caractere şi le înlocuieşte cu semnul ‚-’ returnând numărul de spaŃii înlocuit. FuncŃia primeşte ca argumente momentul plecării din staŃie şi o structură care conŃine orele de plecare şi de sosire. } Program_tren. ScrieŃi şi programul principal care verifică funcŃionarea funcŃiei. ScrieŃi şi programul principal care verifică funcŃionarea funcŃiei. 10. ScrieŃi o funcŃie care afişează şirul de caractere primit ca parametru şi apoi îl subliniază scriind numărul corespunzător de caractere ‚_’ pe rândul următor. 11. Pentru determinarea lungimii şirului de caractere se va folosi funcŃia standard strlen(). Precizări: a.

Pentru citirea matricei se va scrie şi utiliza o funcŃie care citeşte matricea împreună cu dimensiunile sale efective.2 ScrieŃi un program care determină suma elementelor de pe diagonala unei matrice pătrate formată din numere reale. după compilare şi execuŃie: Introduceti dimensiunea efectiva (<=10) :20 Introduceti dimensiunea efectiva (<=10) :2 mat[0][0] = 1 mat[0][1] = 2 mat[1][0] = 3 mat[1][1] = 4 Suma elementelor de pe diagonala este: 5. scanf("%i". Precizare: deşi problema pare identică cu problema 9. j.h> #include <stdlib. i. i++) sumdiag += mat[i][i]. i < *dim. 50 .h> #include <stdlib. i. } void citmat(float mat[][DIMMAX]. do { printf("Introduceti dimensiunea efectiva (<=10): "). return 0. system("PAUSE"). sumdiag. ============================= P9. 9.9. int main(void) { int dimef. Al doilea parametru al funcŃiei citmat() este un pointer prin intermediul căruia se transferă dimensiunea efectivă a metricei. int main(void) { int dimef.h> float **citmat(int *dim). j++) { printf("mat[%d][%d] = ". j < *dim. scanf("%f". float mat[DIMMAX][DIMMAX]. int *dim). citmat(mat. #include <stdio. j).1 nu este aşa. sumdiag. float **mat.1. for(i = 0. i < dimef. i.0.h> #define DIMMAX 10 void citmat(float mat[][DIMMAX]. printf("Suma elementelor de pe diagonala este: %f\n". i++) for(j = 0. de această dată programul trebuie să poată prelucra matrice oricât de mari. dim). Pentru citirea matricei se va scrie şi utiliza o funcŃie care citeşte matricea împreună cu dimensiunile sale efective. P9. #include <stdio. } while (*dim > 10 || *dim < 0). &mat[i][j]). &dimef). int *dim) { int i. sumdiag = 0.1 Pointeri Probleme rezolvate ScrieŃi un program care determină suma elementelor de pe diagonala unei matrice pătrate de dimensiune maximă 10 × 10 formată din numere reale. } } Programul va afişa pe ecran. sumdiag). for(i = 0.000000 DiscuŃie: – Acest program pune în evidenŃă utilizarea pointerilor la transferul unei valori dintr-o funcŃie.

return 1. } sumdiag = 0.if(!(mat = citmat(&dimef))) { printf("Matricea nu se poate citi!\n"). i++) sumdiag += mat[i][i]. system("PAUSE"). printf("Suma elementelor de pe diagonala este: %f\n". dim).000000 sau Introduceti dimensiunea efectiva: 123456 Matricea este prea mare! Matricea nu se poate citi! DiscuŃie: – Acest program pune în evidenŃă utilizarea pointerilor pentru alocarea dinamică a unei matrice. după compilare şi execuŃie: Introduceti dimensiunea efectiva: 2 mat[0][0] = 1 mat[0][1] = 2 mat[1][0] = 3 mat[1][1] = 4 Suma elementelor de pe diagonala este: 5. i. &mat[i][j]). } return mat. sumdiag). } Programul va afişa pe ecran. i < *dim. ============================= 51 .0. j < *dim. float **mat. /* Se aloca memorie pentru tabloul de pointeri care constituie matricea */ if(!(mat = (float **)malloc(*dim * sizeof(float *)))) { printf("Matricea este prea mare!\n"). } float **citmat(int *dim) { int i. for(i = 0. j++) { printf("mat[%d][%d] = ". } /* Se aloca memorie pentru fiecare linie a matricei */ for(i = 0. i < *dim. system("PAUSE"). printf("Introduceti dimensiunea efectiva: "). j). scanf("%f". } /* Se citesc elementele matricei */ for(i = 0. return NULL. return NULL. return 0. i < dimef. Se observă că matricea este declarată ca fiind de tip loat ** adică de tip „pointer la pointer”. Se observă că procedând astfel elementele matricei se pot adresa exact ca atunci când matricea a fost alocată static. În funcŃia citmat() se alocă mai întâi un vector de pointeri care reprezintă matricea propriu-zisă şi apoi se alocă câte un pointer către fiecare rând din matrice. j. i++) for(j = 0. i++) if(!(mat[i] = (float *)malloc(*dim * sizeof(float)))) { printf("Matricea este prea mare!\n"). scanf("%i".

int *ptr. } printf("\n"). Dacă se omite instrucŃiunea: ptr = &k.3 ScrieŃi un program care afişează pe ecran conŃinutul şi adresele a două variabile de tip întreg. #include <stdio. k. Programul va afişa apoi adresele elementelor din vector şi valorile lor. *ptr). &j).h> int main() { int j. /* sau ptr = tablou. i. cât şi utilizând pointeri. j = 1. tablou[i]). } Programul va afişa pe ecran. printf("\nk are valoarea %d si este stocat la adresa %p".P9. printf("\nValoarea int catre care arata pointerul este: %d".4 ScrieŃi un program care construieşte un vector şi îl afişează atât în mod obişnuit. Se va încerca şi depăşirea dimensiunilor tabloului. ptr = &tablou[0]. #include <stdio. i. ============================= P9. pointerului trebuie să i se atribuie o adresă validă. /* ptr contine adresa la care este stocata variabila k */ ptr = &k. printf("\tptr + %d = %d\n". 17. printf("\n"). &k). afişarea va arăta astfel: j are valoarea 1 si este stocat la adresa 0022FF6C k are valoarea 2 si este stocat la adresa 0022FF68 ptr are valoarea 004010C0 si este stocat la adresa 0022FF64 Valoarea int catre care arata pointerul este: 807409035 – Precizăm că adresele afişate pot diferi de cele de mai sus în funcŃie de spaŃiul de memorie alocat programului de către sistemul de operare precum şi faptul că în varianta eronată este posibil ca programul să nu funcŃioneze de loc. return 0. j. i++) { printf("tablou[%d] = %d". ptr.h> int main() { int tablou[] = {1. Se observă faptul că înainte de a fi utilizat. după compilare şi execuŃie: j are valoarea 1 si este stocat la adresa 0022FF6C k are valoarea 2 si este stocat la adresa 0022FF68 ptr are valoarea 0022FF68 si este stocat la adresa 0022FF64 Valoarea int catre care arata pointerul este: 2 DiscuŃie: – Programul pune în evidenŃă modul de utilizare a pointerilor. apoi atribuie adresa uneia dintre ele unui pointer şi reia afişarea utilizând pointerul. */ printf("\n"). /* declarare variabila de tip pointer */ int *ptr. /* Afisarea vectorului */ for(i = 0.h> #include <stdlib. printf("\nj are valoarea %d si este stocat la adresa %p ". printf("\nptr are valoarea %p si este stocat la adresa %p”. int i. *(ptr+i)). -5. k. 4.h> #include <stdlib. system("PAUSE"). 100}. 23. 52 . &ptr). k = 2. i < 6.

– Cel de al doilea ciclu afişează adresele de memorie la care sunt stocate elementele vectorului. se va alipi şi porŃiunea rămasă din strA la stringul final. Aşa cum se arată şi în comentariu. limbajul C nu verifică depăşirea dimensiunii vectorului. i < 6. printf("\n"). după compilare şi execuŃie: tablou[0] tablou[1] tablou[2] tablou[3] tablou[4] tablou[5] adresa adresa adresa adresa adresa adresa ptr ptr ptr ptr ptr ptr ptr + + + + + + + = = = = = = 1 23 17 4 -5 100 ptr ptr ptr ptr ptr ptr + + + + + + 0 1 2 3 4 5 = = = = = = 1 23 17 4 -5 100 pentru pentru pentru pentru pentru pentru 0 1 2 3 4 5 6 = = = = = = = tablou[0]: tablou[1]: tablou[2]: tablou[3]: tablou[4]: tablou[5]: 2293576 2293580 2293584 2293588 2293592 2293596 1 23 17 4 -5 100 2293664 DiscuŃie: – Prima instrucŃiune atribuie pointerului ptr adresa primului element din vectorul tablou. această instrucŃiune se poate scrie şi: ptr = tablou. i++) printf("adresa pentru tablou[%d]: %d\n". return 0. Din acest motiv atribuirea: tablou = ptr. Aşa cum se observă din rezultatul rulării programului. dar se depăşeşte dimensiunea vectorului. În acest mod programul rulează mult mai repede dar programatorul trebuie să fie foarte atent pentru a nu comite astfel de greşeli.h> 53 . i.5 ScrieŃi un program care concatenează două şiruri de caractere (stringuri) strA şi strB. Pentru copierile şi concatenările ulterioare se vor utiliza funcŃiile standard strcpy() şi strcat(). i <= 6. Prima concatenare se va realiza cu ajutorul pointerilor. ptr+i). i. nu este corectă. Programul caută apoi prima literă 'c' din strA şi o înlocuieşte cu secvenŃa "CCC".h> #include <string. } Programul va afişa pe ecran. system("PAUSE"). – În cel de al treilea ciclu se repetă afişarea. ============================= P9. ObservaŃie: Precizăm că un tablou nu este un vector./* Afisarea adreselor la care sunt stocate elementele vectorului */ for(i = 0. – Primul ciclu for afişează valorile memorate în vector utilizând atât direct vectorul cât şi pointerul. i++) { printf("ptr + %d = %d\n". Se observă că elementele vectorului sunt memorate în locaŃii succesive de memorie. În final.h> #include <stdlib. /* Afişare cu depasirea spatiului vectorului */ for(i = 0. *(ptr++)). } printf("\n"). rezultatul fiind depozitat în stringul strA. #include <stdio.

char aux[80]. strA). /* Pointerul pB va contine adresa stringului strB */ pB = strB. char strC[80] = "CCC". return 0. Mai intai verifica faptul ca s-a gasit litera 'c' */ if(*pB == 'c') { pB++. /* Concateneaza strB cu strA */ while (*pA != '\0') *pB++ = *pA++. } Programul va afişa pe ecran. pB). printf("Noul strB: '%s'\n". /* Avanseza pana la sfarsitul lui strB */ while(*pB != '\0') *pB++. /* Aduce inapoi la adresa lui 'c' */ } /* Copiaza strC in locul unde era litera 'c' */ (void)strcpy(pB. *pB. după compilare şi execuŃie: strA = 'Sir de caractere demonstrativ' Adresa stringului strA: 0022FE24 strB = 'SIR2' Concatenare stringuri: 'SIR2Sir de caractere demonstrativ' Inlocuire 'c' cu 'CCC' ====================== Noul strB: 'SIR2Sir de CCC' String final: 'SIR2Sir de CCCaractere demonstrativ' 54 . printf("Adresa stringului strA: %p\n". paux). char strB[80] = "SIR2". printf("strB = '%s'\n". pB--. *paux. /* Adauga sirul de caractere salvat */ (void)strcat(pB. strB).int main() { char strA[80] = "Sir de caractere demonstrativ". /* Pointerul pA va contine adresa stringului strA */ pA = strA. &pA). /* pB arata din nou catre inceputul stringului strB */ pB = strB. /* Declara pointeri catre tipul caracter */ char *pA. int i. strB). pB). printf("String final: '%s'\n". /* Afiseaza rezultatul concatenarii */ printf("Concatenare stringuri: '%s'\n\n". /* Avanseaza la caracterul de dupa 'c' */ paux = aux. /* Adauga caracterul NULL care marcheza sfarsitul stringului */ pB = '\0'. /* Copiaza caracterele de dupa litera 'c' intr-un string auxiliar. strC). (void)strcpy(paux. printf("======================\n"). /* Cauta primul caracter 'c' */ while((*pB != '\0') && (*pB != 'c')) pB++. /* Inlocuire 'c' cu 'CCC' */ printf("Inlocuire 'c' cu 'CCC'\n"). system("PAUSE"). strB). /* Afiseaza stringul strA */ printf("strA = '%s'\n".

DiscuŃie: – Modul în care se realizează concatenarea este similar codului din funcŃia standard strcat(). const char *)) { /* Utilizeaza printf pentru a lasa cursorul pe aceeasi linie */ printf("Verificarea egalitatii: "). /* Copiaza strA in strB inclusiv caracterul NULL */ while((*pB++ = *pA++) != '\0'). fgets(s2. system("PAUSE"). /* (*cmp)(a. puts("Introduceti al doilea argument:"). folosind pointeri. comparanum). – Pentru înlocuirea caracterului 'c' mai întâi acesta este localizat.6 ScrieŃi un program care. else return 1. const char *b) { /* atoi(x) converteste stringul catre care arata pointerul x intr-un numar intreg (atoi = ASCII to int) */ if(atoi(a) == atoi(b)) return 0. } puts("\n"). if(s2[strlen(s2)-1] == '\n') s2[strlen(s2)-1] = '\0'. s2.b)apeleaza functia de comparare a carei adresa se afla in cmp cu argumentele a si b */ if(!(*cmp)(a. /* Aduce inapoi la caracterul NULL */ pB--. #include <stdio. } else { puts("Argumente de tip numeric\n"). puts("Introduceti primul argument:"). s2[80]. else puts("Argumentele nu sunt egale"). /* Utilizeaza functia comparanum */ verifica(s1. 80. fgets(s1. char *b. } void verifica(char *a. } int comparanum(const char *a. ============================= P9. s2. Afişarea se va face utilizând funcŃia standard puts() şi citirea se va face cu fgets(). verifică egalitatea alfabetică sau numerică a argumentelor.h> void verifica(char *a. prin două funcŃii distincte. stdin). int main() { char s1[80]. return 0. /* Parametrii functiei apelate sunt 2 pointeri de tip caracter */ if(isalpha(*s1)) { puts("Argumente de tip caracter\n"). const char *)). /* Utilizeaza functia standard strcmp */ verifica(s1. 80. Această secŃiune se poate rescrie într-un mod mai compact astfel: /* Avanseza pana la sfarsitul lui strB */ while(*pB++ != '\0'). int (*cmp)(const char *. strcmp).h> #include <stdlib. } 55 . if(s1[strlen(s1)-1] == '\n') s1[strlen(s1)-1] = '\0'. Apoi se salvează restul şirului de caractere care urmează după acesta şi se compune noul şir de caractere prin două operaŃii succesive de concatenare.h> #include <string. int comparanum(const char *a. const char *b). stdin). int (*cmp)(const char *. char *b.b)) puts("Argumentele sunt egale").

8 ScrieŃi un program care schimbă între ele două linii ale unei matrice de dimensiuni 3 × 3 elemente reale şi apoi le schimbă la loc. i < 3. /* incarcare folosind pointerul */ strcpy(p->str. for(i = 0. i. j < 3. printf("%d %d %s". s. Se vor defini şi utiliza funcŃii diferite pentru citirea unei matrice.7 ScrieŃi un program care încarcă valori într-o structură folosind un pointer către aceasta. ============================= P9. } } } 56 . j++) { printf("Introduceti elem.h> void citeste(float mat[][3]) { int i.h> #include <stdlib. } Programul va afişa pe ecran. p->str). j. mat[%d][%d]: ". /* s este variabila de tip structura si p un pointer catre o astfel de structura */ int main() { p = &s. FuncŃia verifica() apelează funcŃia de verificare a egalităŃii prin intermediul pointerului la funcŃie. return 0. "tablou unidimensional de caractere"). după compilare şi execuŃie: Introduceti primul argument: str1 Introduceti al doilea argument: str2 Argumente de tip caracter Verificarea egalitatii: Argumentele nu sunt egale DiscuŃie: – Pentru verificarea tipului de valori citite se foloseşte funcŃia standard isalpha() care returnează „adevărat” dacă şirul de caractere este de tip alfanumeric (cuprinde şi litere) sau „fals” dacă este format doar din cifre. #include <stdio.Programul va afişa pe ecran. după compilare şi execuŃie: 10 10 tablou unidimensional de caractere DiscuŃie: – Programul pune în evidenŃă utilizarea operatorului ->. #include <stdio. printf("\n"). scanf("%f". /* pointerul arata catre adresa de inceput a structurii */ s. p->i. i++) { for(j = 0. afişarea unei matrice precum şi pentru schimbarea între ele a liniilor.h> struct strpoint { int i. j).i. system("PAUSE"). – Cel de al treilea argument al funcŃiei verifica() este un pointer către o funcŃie.h> #include <stdlib. } s.i = 10. char str[80]. *p.h> #include <string. ============================= P9. &mat[i][j]). /* incarcare obisnuita */ p->i = 10.

printf("Inainte de inversarea liniilor\n"). } printf("\n"). int i. citeste(m). schimba1(m. schimba2(m. afiseaza(m). while(i < 0 || i >= 3) { printf("Date incorecte\n"). } int i. float m[3][3]. k < 3. afiseaza(m). scanf("%d". i. 57 . *(mat[j] + k) = temp. &i). printf("Liniile inversate din nou\n"). j). } } void schimba2(float mat[][3]. } printf("***********************************************\n"). scanf("%d". printf("Liniile inversate\n"). j++) { printf("%f\t". int k. printf("***********************************************\n"). printf("Introduceti indicele primei linii (<3): "). &i). mat[i][j]). j. printf("***********************************************\n"). float temp. float temp. scanf("%d".void afiseaza(float mat[][3]) { int i. j. } } void schimba1(float mat[][3]. *(*(mat + j) + k). int j) { + k). j). i. printf("***********************************************\n"). j < 3. for(i = 0. k < 3. system("PAUSE"). i++) { for( j = 0. afiseaza(m). int j) { int k. temp. *(mat[i] + k) = *(mat[j] + k). printf("Introduceti indicele primei linii (<3): "). k++) { temp = *(*(mat + i) *(*(mat + i) + k) = *(*(mat + j) + k) = } } int main(void) { int i. printf( "Introduceti indicele celei de a doua linii (<3): "). while(j < 0 || j >= 3) { printf("Date incorecte\n"). return 0. scanf("%d". i < 3. k++) { temp = *(mat[i] + k). &j). for(k = 0. } printf("Introduceti indicele celei de a doua linii (<3): "). for(k = 0. &j).

stdin). poz). mat[1][1]: 5 Introduceti elem.000000 2. if(sir1[strlen(sir1)-1] == '\n') sir1[strlen(sir1)-1] = '\0'. printf("Introduceti sirul al doilea\n").000000 8. printf("Introduceti primul sir\n").Programul va afişa pe ecran. *q. poz = cauta(sir1.000000 7. } int main(void) { char sir1[200].000000 1. sir1). sir2).000000 *********************************************** Liniile inversate din nou 1.000000 3. sir2. else printf("Sirul '%s' nu se gaseste in '%s'\n". ============================= P9.sir1. #include <stdio.000000 7. 200.000000 5. sir1.000000 4. q++. FuncŃia schimba2() utilizează pointerii pentru accesul la valorile din matrice. mat[0][2]: 3 Introduceti elem. temp++).000000 2. char *sir2) { char *p. temp = p. p++) { for(q = sir2. stdin). mat[1][0]: 4 Introduceti elem. mat[1][2]: 6 Introduceti elem. fgets(sir2. if(sir2[strlen(sir2)-1] == '\n') sir2[strlen(sir2)-1] = '\0'. după compilare şi execuŃie: Introduceti elem. return 0.000000 3.000000 5. *temp.000000 6. mat[0][0]: 1 Introduceti elem.000000 9. if(poz != -1) printf("Sirul '%s' se gaseste in '%s' la pozitia %d\n". 200.000000 7.000000 8.h> #include <stdlib.000000 8.000000 5. mat[2][0]: 7 Introduceti elem.9 ScrieŃi un program care caută un subşir într-un şir de caractere.000000 4.h> int cauta(char *sir1.000000 6. int poz. *p != '\0'. *q != '\0' && *temp != '\0' && *temp == *q.000000 DiscuŃie: – Schimbarea între ele a liniilor matricei se face utilizând două funcŃii diferite. mat[2][1]: 8 Introduceti elem. mat[0][1]: 2 Introduceti elem. FuncŃia schimba1() pune în evidenŃă faptul că în limbajul C o matrice bidimensională este o matrice unidimensională formată din matrice unidimensionale. } 58 . Programul va afişa poziŃia subşirului în şir sau un mesaj de eroare dacă subşirul nu a fost găsit.000000 3. mat[2][2]: 9 *********************************************** Inainte de inversarea liniilor 1. fgets(sir1. system("PAUSE"). for(p = sir1.000000 9. if(*q == '\0') return p .000000 *********************************************** Introduceti indicele primei linii (<3): 0 Introduceti indicele celei de a doua linii (<3): 1 *********************************************** Liniile inversate 4.000000 9.000000 6.000000 2. } return -1. sir2. sir2[200].

construieşte. scanf("%d".Programul va afişa pe ecran. i < dim. int *vector.h> #include <stdlib. system("PAUSE"). i. vector + i). Cel de al doilea ciclu realizează căutarea propriu-zisă. free(vector). } Programul va afişa pe ecran. ============================= P9. for(i = 0. i). } printf("Citire\n"). după compilare şi execuŃie: Introduceti Citire vector[0] = vector[1] = vector[2] = Scriere vector[0] = vector[1] = vector[2] = dimensiunea vectorului: 3 1 2 3 1 2 3 59 . dim). Dacă la ieşirea din ciclul intern s-au epuizat caracterele din şirul căutat înseamnă că şirul a fost găsit. return 1. scanf("%d".h> int main(void) { int dim. return 0. i++) printf("vector[%d] = %d\n". la iniŃializarea ciclului. Ciclul cu contor exterior avansează poziŃia de căutare în şirul în care se caută. #include <stdio. la începutul celor două şiruri de caractere. *(vector + i)). for(i = 0. i++) { printf("vector[%d] = ".10 ScrieŃi un program care citeşte dimensiunea exactă a unui vector de numere întregi. if(!(vector = (int *)malloc(dim * sizeof(int)))) { printf("Dimensiunea %d este prea mare!\n". do { printf("Introduceti dimensiunea vectorului: "). &dim). Căutarea continuă cât timp mai există caractere în cele două şiruri şi caracterele din cele două şiruri sunt identice. i < dim. i. } printf("Scriere\n"). PoziŃia se determină prin diferenŃa dintre pointerul care indică începutul şirului în care se caută şi pointerul care indică începutul subşirului găsit. se aduc cei doi pointeri. system("PAUSE"). Mai întâi. citeşte şi afişează acest vector. printf("Vectorul nu are loc in memorie!\n"). } while(dim <= 0). după compilare şi execuŃie: Introduceti primul sir Unu doi trei Introduceti sirul al doilea doi Sirul 'doi' se gaseste in 'Unu doi trei' la pozitia 4 sau Introduceti primul sir Unu doi trei Introduceti sirul al doilea patru Sirul 'patru' nu se gaseste in 'Unu doi trei' DiscuŃie: – Se remarcă modul în care se face căutarea cu ajutorul a două cicluri cu contor.

k. "Catalin". printf("\nSirurile sortate sunt:\n"). j.1. j++) printf("%s\n". for(j = 0. system("PAUSE"). if(strcmp(p[i].1. } } } } int main() { char *p[] = {"Gabi". "Bebe". p[i] = p[j]. return 0. } Programul va afişa pe ecran. "Alina". j < 6. După citire şi scriere spaŃiul de memorie alocat este eliberat.h> #include <stdlib. i < nr . "Claudia". 6). k++) { for(i = 0. Dacă alocarea eşuează. int j. j++) printf("%s\n". Se verifică faptul că spaŃiul de memorie a putut fi alocat. ============================= P9. p[j]) > 0) { temp = p[i]. j < 6. int i. "Andrei"}. for(k = 0. sortează şi afişează un vector de şiruri de caractere implementând o procedură de tip bubble-sort şi comparând pointerii alăturaŃi.11 ScrieŃi un program care citeşte. după compilare şi execuŃie: Sirurile nesortate sunt: Gabi Bebe Alina Claudia Catalin Andrei Ana Sirurile sortate sunt: Alina Ana Andrei Bebe Catalin Claudia Gabi 60 . #include <stdio. printf("Sirurile nesortate sunt:\n").sau Introduceti dimensiunea vectorului: 1567311664 Dimensiunea 1567311664 este prea mare! Vectorul nu are loc in memorie! DiscuŃie: – Programul alocă spaŃiul de memorie necesar stocării vectorului. p[j]). sort(p. execuŃia programului se întrerupe. int nr) { char *temp. i++) { j = i + 1.h> void sort(char *p[]. for(j = 0. p[j]). k < nr . p[j] = temp.

2. ScrieŃi şi programul principal care testează funcŃia. Pentru ordonare / sortare se va utiliza funcŃia qsort() disponibilă în bibliotecile standard C şi declarată în stdlib. 5. elem1 şi elem2. int(*compar)(const void *elem1. int size. ScrieŃi un program care citeşte un text şi afişează doar ultimele 5 linii ale textului. 7. format din nmemb elemente de tip arbitrar şi de dimensiune size şi care sunt comparate de funcŃia compar(). int nmemb. O metodă de sortare presupune adăugarea valorilor dintr-un vector una câte una într-un vector nou. FuncŃia insort() va avea prototipul: void insort(void *base. Probleme propuse ScrieŃi un program care determină de câte ori un subşir de caractere se regăseşte într-un alt şir de caractere. IndicaŃie: se va generaliza soluŃia de la problema 9. ScrieŃi un program care citeşte trei variabile a. returnând o valoare întreagă mai mică decât. ScrieŃi şi programul principal care testează funcŃia.DiscuŃie: – Prin utilizarea pointerilor către şirurile de caractere sunt modificate adresele către care indică pointerii şi nu sunt mutate şirurile de caractere propriu-zise. - Prototipul este similar cu al funcŃiei qsort() realizând sortarea unui vector cu adresa de început indicată de base. ScrieŃi o funcŃie care primeşte ca argument un şir de caractere şi returnează un pointer către primul caracter care nu este spaŃiu din acest şir de caractere. dar este obŃinut cu un efort de calcul mult mai mic. 1. ============================= 9. Prototipul funcŃiei este: char *primul_caracter(char *sir). Valorile următoare sunt adăugate în poziŃia corespunzătoare ordinii sale prin deplasarea datelor adăugate deja pentru a face loc valorii care se adaugă. 61 . b -> c şi ScrieŃi un program care citeşte şi sortează în ordinea ascendentă dată de cuvant_cheie un vector format din înregistrări definite astfel: typedef struct { char cuvant_cheie[10]. int nmemb. } Inregistrare.9. size este dimensiunea în octeŃi a unui element din vector şi compar este un pointer către o funcŃie definită de utilizator care realizează comparaŃia între două elemente ale vectorului. c. const void *elem2)). ScrieŃi un program care citeşte un text. Prima valoare este adăugată la începutul vectorului. int(*compar)(const void *elem1. Precizări: a. nmemb reprezintă numărul de elemente din vector. int alte_date. IndicaŃie: funcŃia qsort() este declarată astfel: void qsort(void *base. sau mai mare decât zero după cum elem1 este mai mic. 2. const void *elem2)). egal cu. 6. îl desparte în cuvinte şi afişează cuvintele textului ordonate alfabetic. Această metodă poartă numele de „sortare prin inserare” („insertion sort”). sau mai mare decât elem2.h. 3. unde: base este adresa de început a vectorului. b şi c şi apoi le roteşte între ele astfel: a -> b. Se vor considera spaŃii caracterele ' ' („space”) şi '\t' („tab”). egală cu. Efectul rămâne cel dorit. int size. ScrieŃi o funcŃie denumită insort() care realizează astfel sortarea şi se comportă în acelaşi mod precum funcŃia qsort() descrisă în problema anterioară. c -> a. 4. b.

62 . Pentru calculul sumelor se va folosi o funcŃie cu următorul prototip: void suma(float A[][10]. suma numerelor pozitive. m pos neg este matricea de lucru. suma numerelor negative. int m. int n. produsul elementelor de pe diagonala secundară. 11. int m. unde: A[][10] n dprin dsec este matricea de lucru. struct lista *p_lista. float *neg). Dacă numărul nu reprezintă o lună. float *pos. Programul va semnala cazul special al împărŃirii prin zero. define MAX 4 struct lista { int numar. int n. împreună cu dimensiunile sale efective şi determină câtul împărŃirii modulului sumei numerelor negative din matrice la suma numerelor pozitive din matrice. sunt dimensiunile efective ale matricei. m pos neg este matricea de lucru. /) şi determină şi afişează valoarea expresiei. 3. }. funcŃia va returna un pointer către şirul de caractere „nici o luna”. produsul elementelor de pe diagonala principală. char nume[10]. 12. Pentru calculul sumelor se va folosi o funcŃie cu următorul prototip: void suma(float **A. ScrieŃi o funcŃie care primeşte ca parametru un număr întreg şi returnează un pointer către numele lunii calendaristice corespunzătoare. este dimensiunea efectivă a matricei. este mai mic decât 1 sau mai mare decât 12. împreună cu dimensiunile sale efective şi determină câtul împărŃirii modulului sumei numerelor negative din matrice la suma numerelor pozitive din matrice. float *dsec). ScrieŃi un program care citeşte o expresie matematică simplă formată din doi operanzi numerici şi un operator (+. Denumirile lunilor vor fi memorate într-o variabilă locală statică a funcŃiei definită astfel: static char *luna[] = { "nici o luna". suma numerelor pozitive.25 * 4 = 5 10. "Ion". suma numerelor negative. ReluaŃi problema anterioară şi scrieŃi un program care citeşte de la tastatură o matrice de numere reale de orice dimensiuni. Un exemplu de rulare a programului va arăta astfel: Introduceti expresia: 1. float *neg). -. 13. sunt dimensiunile efective ale matricei. unde: A[][10] n. float *dprin. 2. unde: A n. *. ScrieŃi un program care citeşte de la tastatură o matrice de numere reale de dimensiuni maxime 10 x 10. } data[MAX] = { 1. "Vasile". ScrieŃi un program care parcurge lista definită mai jos cu ajutorul pointerului p_lista şi afişează numărul şi numele. Programul va semnala cazul special al împărŃirii prin zero. Pentru calculul sumelor se va folosi o funcŃie cu următorul prototip: void prod_diag(float A[][10]. Programul va semnala cazul special al împărŃirii prin zero. "ianuarie".8. ScrieŃi un program care citeşte de la tastatură o matrice de numere reale de dimensiuni maxime 10 x 10. Precizări: a. "Gheorghe". 4. "Maria" 9. float *pos. int n. împreună cu dimensiunile sale efective şi determină câtul împărŃirii modulului produsului elementelor de pe diagonala principală a matricei la produsul elementelor de pe diagonala secundară a matricei.

"martie". ScrieŃi o funcŃie care citeşte cel mult n numere reale de tip float şi le plasează în memorie începând de la adresa indicată de pfloat. 14. De exemplu: funcŃia primeşte "15042004" şi returnează "15 aprilie 2004". b. "aprilie". Folosind funcŃia din exerciŃiul anterior scrieŃi o altă funcŃie care primind un şir de caractere de forma "zzllaaaa" returnează data scrisă sub forma "zi luna an". FuncŃia va returna numărul valorilor citite. ScrieŃi şi programul principal care verifică funcŃionarea funcŃiei. "septembrie"."februarie". float *pfloat). 63 . "august". "octombrie". "noiembrie". Prototipul funcŃiei este: int citeste_n_nr(int n. "mai". "decembrie" }. ScrieŃi şi programul principal care verifică funcŃionarea funcŃiei. ScrieŃi şi programul principal care verifică funcŃionarea funcŃiei. Prototipul funcŃiei este: char *denumire_luna(int numar). "iunie". "iulie". FuncŃia va verifica şi corectitudinea datei rejectând date cum ar fi "2902001" (anul 2001 nu a fost bisect) sau "31042005" (aprilie nu are 31 de zile). 15.

} while(scanf("%f".h> #define PI 3. Probleme recapitulative 10. ch = getche(). case 'Q': semnal=0. Circumferinta (C). Volumul (V). printf( "Volumul cilindrului este: %g\n\n". system("PAUSE"). char ch. case 'V': raspuns = PI * raza * raza * inaltimea. inaltimea. } while(scanf("%f". ch = toupper(ch). Volumul (V).14159265358979323846 int main() { float raza. printf( "Circumferinta bazei este: %g\n\n". printf("\n").1 Probleme rezolvate ScrieŃi un program care să calculeze şi să afişeze. break. raspuns). while(semnal) { printf("Alegeti una din optiunile:\n"). raspuns). break.1. if(ch == 'A' || ch == 'C' || ch == 'V') do { printf("Introduceti raza: "). dacă aceasta nu s-a făcut corect.159 Alegeti una din optiunile: Aria (A). &inaltimea) != 1). în funcŃie de opŃiunea utilizatorului. raspuns). } } printf("\n"). Iesire (Q): q ============================= 64 . if(ch == 'V') do { printf("Introduceti inaltimea: "). circumferinŃa cercului de bază şi volumul cilindrului. break. return 0. int semnal=1. Volumul (V). printf( "Aria (A). după compilare şi execuŃie: Alegeti una din optiunile: Aria (A). P10. printf("Aria bazei este: %g\n\n". programul va fi reluat până când utilizatorul doreşte terminarea sa şi se va cere repetarea opŃiunii. Iesire (Q): "). switch(ch) { case 'A': raspuns = PI * raza * raza. următoarele mărimi pentru un cilindru cu raza bazei şi înălŃimea date (numere reale): aria bazei. } Programul va afişa pe ecran. Iesire (Q): v Introduceti raza: 10 Introduceti inaltimea: 1 Volumul cilindrului este: 314.h> #include <stdlib. ch).10. break. break. double raspuns. &raza) != 1). case 'C': raspuns = 2 * PI * raza. default: printf( "Optiunea necunoscuta '%c' este ignorata!\n\n". #include <stdio. Circumferinta (C). Circumferinta (C).

printf("Introduceti nr. scanf("%d". /* pentru "diagonala principala". &d). scanf("%d". i++) for(j = 0. înălŃimea egală cu lăŃimea). } Programul va afişa pe ecran. '*' va apare cand r = c. /* dimensiunea */ int r. folosind simbolul ‚ * ’. c++) { if(r == c || c == d – r + 1) printf("*"). De exemplu. de linii: "). for(i = 0. i.3 Programul următor citeşte de la tastatură o matrice de maxim 10 × 10 numere întregi apoi determină elementele minime pe linii şi maxime pe coloane. for(j = 0.h> * * * * int main() { int d. scanf("%d". /* numarul liniei */ int c. j. j < m. i < n.P10. j < m. return 0. i++) { min = A[i][0]. r <= d. system("PAUSE"). j++) { 65 . pentru "diagonala secundara". &A[i][j]). for(i = 0. max. r++) { for(c = 1. n. i < n.h> #include <stdlib. &n). scanf("%d". desenul va trebui să arate astfel: * * * * * #include <stdio. i.2 ScrieŃi un program care să deseneze pe ecran un ‚X’ cu dimensiunea specificată de utilizator (număr natural ≤ 20. } printf("\n"). '*' va apare cand c=d–r+1 */ printf("Desenul cerut arata astfel:\n\n"). m. de coloane: "). j). min. } printf("Elementele minime pe linii: \n"). printf("Introduceti nr. for(r = 1. else printf(" "). dacă se introduce numărul 5. &m).h> int main() { int A[10][10]. c <= d.h> #include <stdlib. #include <stdio. /* numarul coloanei */ printf("Introduceti dimensiunea: "). după compilare şi execuŃie: Introduceti dimensiunea: 8 Desenul cerut arata astfel: * * * * * * ** ** * * * * * * ============================= P10. j++) { printf("A[%d][%d] = ". } printf("\n").

A[l2][j] = tmp. j++) { tmp = A[l1][j]. for(j = 0. } printf("Linia %d are minimul: %d\n". printf("Introduceti nr. i. i < n.4 Programul următor citeşte de la tastatură o matrice de maximum 10 × 10 numere întregi şi sortează crescător liniile matricei. de coloane: 3 A[0][0] = 1 A[0][1] = 2 A[0][2] = 3 A[1][0] = 4 A[1][1] = 5 A[1][2] = 6 A[2][0] = 7 A[2][1] = 8 A[2][2] = 9 Elementele minime pe linii: Linia 0 are minimul: 1 Linia 1 are minimul: 4 Linia 2 are minimul: 7 Elementele maxime pe coloane: Coloana 0 are maximul: 7 Coloana 1 are maximul: 8 Coloana 2 are maximul: 9 ============================= P10. tmp. } system("PAUSE"). return 0. } } int main() { int A[10][10]. i++) { if (A[i][j] > max) max = A[i][j]. int m. max). ind. j < m. min). } printf("Elementele maxime pe coloane: \n"). i++) for(j = 0. &m). int n. printf("Introduceti nr. de linii: "). j++) { 66 .h> /* functie care interschimba linia l1 cu l2 in matricea A */ void int_linii(int A[][10]. Precizare: prin convenŃie. m. #include <stdio. int l1. int l2) { int j. i. scanf("%d". scanf("%d".if (A[i][j] < min) min = A[i][j]. A[l1][j] = A[l2][j]. o linie este mai mare decât alta dacă primul element de pe o linie este mai mare decât primul element de pe a doua. j++) { max = A[0][j]. i < n. Dacă primele elemente sunt egale regula se aplică pentru următoarele perechi de elemente de pe liniile respective. for(j = 0. } printf("Coloana %d are maximul: %d\n". for(i = 0. &n). j.h> #include <stdlib. j < m. j. /* citirea matricii */ for(i = 0. j < m. de coloane: "). după compilare şi execuŃie: Introduceti nr. de linii: 3 Introduceti nr. n. } Programul va afişa pe ecran.

i++) for(j = 0. i < n. de coloane: 3 A[0][0] = 9 A[0][1] = 8 A[0][2] = 7 A[1][0] = 6 A[1][1] = 5 A[1][2] = 4 A[2][0] = 3 A[2][1] = 2 A[2][2] = 1 A[0][0] = 3 A[0][1] = 2 A[0][2] = 1 A[1][0] = 6 A[1][1] = 5 A[1][2] = 4 A[2][0] = 9 A[2][1] = 8 A[2][2] = 7 ============================= P10. m. de coloane: "). j < m. de linii: "). system("PAUSE"). scanf("%d". printf("Introduceti nr.printf("A[%d][%d] = ". &m). de linii: 3 Introduceti nr. /* setam indicatorul */ break. return 0. printf("Introduceti nr. j. &A[i][j]). else { /* se interschimba linia curenta cu urmatoarea */ int_linii(A.h> int main() { int A[10][10]. /* terminam parcurgerea liniei i */ } } /* afisare matrice */ for(i = 0. ind = 1. j < m. scanf("%d". /* setare indicator */ while(ind) { ind = 0. după compilare şi execuŃie: Introduceti nr. Precizare: indexul liniei ce se doreşte eliminată va fi citit tot de la tastatură. i. /* parcurgere matrice pe linii */ for(i = 0. } ind = 1. i++) for(j = 0. #include <stdio. j. ie.5 Programul următor citeşte de la tastatură o matrice de maximum 10 × 10 numere întregi apoi elimină o linie a matricei. j). i. i. scanf("%d". j < m. j++) { 67 . i+1). m. i++) for(j = 0. i < n. } Programul va afişa pe ecran. i < n. &n). i. n. j++) if(A[i][j] <= A[i+1][j]) /* s-a gasit un element mai mic pe linia urmatoare deci parcurgerea liniei i se incheie */ break. n. j++) printf("A[%d][%d] = %d\n". /* citirea matricii */ for(i = 0.h> #include <stdlib. A[i][j]).

#include <stdio. j < m. A[i][j]). i++) for(j = 0.h> #include <stdlib. j++) A[i][j] = A[i+1][j]. for(i = 0. după compilare şi execuŃie: Introduceti nr. return 0. &n). scanf("%d". j++) { printf("A[%d][%d] = ". } /* citirea corecta a indicelui ie al liniei ce se doreste eliminata */ while(1) { printf( "Introduceti indicele liniei ce se doreste eliminata: "). i. j). &ie). /* afisam matricea */ for(i = 0. scanf("%d". j++) printf("A[%d][%d] = %d\n". system("PAUSE"). j). de linii: 3 Introduceti nr. } Programul va afişa pe ecran. i < n. j. printf("Introduceti nr. &A[i][j]).6 Programul următor citeşte de la tastatură o matrice de dimensiuni n × m de numere întregi (maximum 10 × 10) şi înlocuieşte coloana k cu un vector de n elemente ce se va citi tot de la tastatură. k. } 68 . i < n. Precizare: poziŃia coloanei. i < n. } /* cu i de la ie la n se aduc liniile i+1 pe liniile i */ for(i = ie.printf("A[%d][%d] = ". printf("Introduceti nr. &A[i][j]). de coloane: 3 A[0][0] = 1 A[0][1] = 2 A[0][2] = 3 A[1][0] = 4 A[1][1] = 5 A[1][2] = 6 A[2][0] = 7 A[2][1] = 8 A[2][2] = 9 Introduceti indicele liniei ce se doreste eliminata: 1 A[0][0] = 1 A[0][1] = 2 A[0][2] = 3 A[1][0] = 7 A[1][1] = 8 A[1][2] = 9 ============================= P10. n. i.h> int main() { int A[10][10]. j. de linii: "). scanf("%d". se va citi tot de la tastatură. scanf("%d". j < m. /* decrementam numarul total de linii */ n--. i++) for(j = 0. i. j < m. &m). scanf("%d". else printf("Indice incorect\n"). k. i++) for(j = 0. i. if ((ie >= 0) && (ie <= n)) break. de coloane: "). v[10]. m.

i++) { printf("A[%d][%d] = ". j. i < n. } /* citim in vectorul v noua coloana a matricii A */ printf("Acum introduceti noile elemente ale coloanei:\n"). scanf("%d". /* tiparim noua matrice */ printf("Noua matrice are elementele:\n"). printf("doreste inlocuita: "). x. #include <stdio. k). else printf("Indice incorect\n"). m. i++) { x = (float)(i-12).1.h> #include <stdlib. de linii: 3 Introduceti nr. /* functia ce se afiseaza */ v[i] = sin(2 * 3. Terminalul alfanumeric se va considera de 80 coloane şi 25 linii. if ((k >= 0) && (k <= m)) break. i < n.while(1) { printf("Introduceti indicele coloanei ce se "). i. M. j++) printf("A[%d][%d] = %d\n". for(i = 0. } Programul va afişa pe ecran. j < m. q. } 69 . i. for(i = 0. A[i][j]).h> #define NC 40 /* numarul de coloane */ #define NL 25 /* numarul de linii */ main() { float v[NL-1]. for(i = 0. i < n.7 Programul următor afişează graficul unei funcŃii (de exemplu sin(x) pe o perioadă) în format ASCII.h> #include <math. i++) for(j = 0. j. Programul scalează funcŃia în intervalul ce se doreşte afişat şi tipăreşte un singur caracter '*' pe poziŃia corespunzătoare valorii funcŃiei. system("PAUSE"). int i. } /* parcurgem coloana k si inlocuim elementele sale */ for(i = 0. &v[i]). &k). i < NL . de coloane: 3 A[0][0] = 1 A[0][1] = 2 A[0][2] = 3 A[1][0] = 4 A[1][1] = 5 A[1][2] = 6 A[2][0] = 7 A[2][1] = 8 A[2][2] = 9 Introduceti indicele coloanei ce se doreste inlocuita: 1 Acum introduceti noile elemente ale coloanei: A[0][1] = 1 A[1][1] = 2 A[2][1] = 3 Noua matrice are elementele: A[0][0] = 1 A[0][1] = 1 A[0][2] = 3 A[1][0] = 4 A[1][1] = 2 A[1][2] = 6 A[2][0] = 7 A[2][1] = 3 A[2][2] = 9 ============================= P10.1415926535 * x / NL). scanf("%d". return 0. i++) A[i][k] = v[i]. după compilare şi execuŃie: Introduceti nr.

nr2.1. return 0. for(i = 0.8 ScrieŃi un program care să implementeze un calculator de buzunar foarte simplu (doar cele 4 operaŃii elementare). char op. op = +-x/)\n"). după compilare şi execuŃie: * * * * * * * * * * * * * * * * * * * * * * * * ============================= P10. i++) if(v[i]<m) m=v[i].1. 70 . i < NL . j < NC. #include <stdio./* Se gasesc maximumul.h> int main(int argc.1. &nr2). &nr1. m. si minimul.h> #include <stdlib. M. scanf("%f %c %f". j++) { if(j == ceil((v[i] . /* tipareste spatiu */ } system("PAUSE"). i++) if(v[i] > M) M = v[i]. /* parcurge terminalul alfanumeric linie cu linie */ for(i = 0. for(i = 0. printf("Introduceti expresia (nr op nr.1) / (M . } Programul va afişa pe ecran. /* iese de ciclul for ce parcurge liniile daca s-a tiparit ’*’*/ } else printf(" "). i < NL . i < NL . rez. char *argv[]) { float nr1.m). break.nr2. case '-': rez = nr1 . /* tipareste '*' si trece pe linia urmatoare */ break. switch(op) { case '+': rez = nr1 + nr2. i++) for(j = 0. &op.m) * q)) { printf("*\n"). functiei */ M = m = v[0]. /* gaseste pasul minim */ q = (NC .

9. nr2. ScrieŃi un program care citeşte un număr întreg pozitiv n < 50 000 reprezentând numărul de zile care au trecut de la 1 ianuarie 1900 şi determină şi afişează data calendaristică corespunzătoare. 71 . Exemplu: 145 = 1! + 4! + 5! Numărul n va fi citit de la tastatură. ScrieŃi un program care determină care este numărul natural maxim care se poate construi din cifrele distincte ale unui număr natural în baza 10 cu maxim 80 de cifre care se citeşte de la tastatură. ScrieŃi un program care citeşte un număr natural n cu maxim 50 de cifre zecimale şi determină şi afişează secvenŃa maximă de cifre consecutive care se repetă de cel puŃin 2 ori în scrierea numărului n. ScrieŃi un program care citeşte de la tastatură un număr natural n cu cel mult 9 cifre şi determină numărul natural k < n care are numărul maxim de divizori primi.75 x 3.75 x 3. 1. 4.break. 7.14 = 80. op = +-x/) 25. după compilare şi execuŃie: Introduceti expresia (nr op nr. break. au cel mai mic divizor comun un alt număr dat. } else rez = nr1 / nr2. ScrieŃi un program care citeşte ecuaŃiile a n drepte din plan şi determină şi afişează dreptele care aparŃin aceleiaşi clase de paralelism. Se vor lua în consideraŃie şi anii bisecŃi (1900 a fost an bisect iar 2000 nu a fost an bisect). două drepte aparŃin aceleaşi clase de paralelism dacă au aceeaşi pantă. n. } Programul va afişa pe ecran. exit(4). nr1. ScrieŃi un program care citeşte într-un şir de caractere care reprezintă o expresie care conŃine mai multe numere complexe şi operaŃii între acestea apoi calculează şi afişează rezultatul expresiei. system("PAUSE").855 ============================= 10. break.out” pătratul acestui număr. d. 3. system("PAUSE"). case 'x': rez = nr1 * nr2. system("PAUSE"). exit(5). 10. Programul va afişa perechile de numere obŃinute. case '/': if(nr2 == 0) { printf("Impartire la 0!\n"). Probleme propuse – Teme de casă ScrieŃi un program care citeşte un număr întreg reprezentat în baza 10 şi îl converteşte şi afişează reprezentat în baza 16. 2. return 0. ScrieŃi un program care citeşte din fişierul „nr.2. 5. EcuaŃia unei drepte este dată de formula: a ⋅ x + b ⋅ y + c = 0. rez).in” un număr natural cu minim 2 cifre şi maxim 5000 de cifre zecimale şi apoi calculează şi scrie în fişierul „nr. ScrieŃi un program care determină câte perechi de numere naturale care nu depăşesc un număr dat. op. 8. ScrieŃi un program care citeşte perechi de numere reale care reprezintă coordonatele carteziene ale unui poligon convex şi apoi calculează şi afişează aria poligonului. } printf("%g %c %g = %g\n". 11.14 25. ScrieŃi un program care determină toate numerele naturale i < n care au proprietatea că sunt egale cu suma factorialelor cifrelor care le conŃin. default: printf("Eroare: operator necunoscut\n"). 6.

Restul textului se va alinia pe aceeaşi coordonată cu cele două acolade corespunzătoare. 3) (3. ScrieŃi un program care estimează cu 6 zecimale numărul π (3. y < 1.. 18. cele din interior se vor deplasa faŃă de cele din exterior. În cazul mai multor acolade imbricate.. 19. 22. m > 0.0 -3.44 0 10. se memorează gradul şi coeficientul.67 4.33 5. Exemplu: 4273 2734 7342 3427 Problema va fi rezolvată în trei moduri: − folosind unul sau mai multe tablouri cu elemente de tip numeric.14 0 -1. m < 3001. precum şi raza cercului. y) cu 0 < x.1415926535.TXT” . unde pentru fiecare monom. 16. 20. să calculeze matricea produs şi să o tipărească într-un al treilea fişier.67 3. ScrieŃi un program care citeşte coordonatele unui graf orientat şi îi ordonează vârfurile astfel încât toate arcele să aibă aceeaşi orientare. ScrieŃi un program care citeşte un arbore n-ar (n este un număr natural) şi îi scrie reprezentarea fiu – frate. ^ Exemplu: (2 + 3 * i) ^ 3 + (7 + 9 * i) * (10 – 4 * i) 12. b) Se vor număra câte perechi de astfel de numere pseudo-aleatoare cad în interiorul sfertului de cerc situat în cadranul 1 al planul (x. Precizare: această operaŃie.frate un arbore n-ar este reprezentat ca un arbore binar astfel încât pentru un vârf x legătura stânga reprezintă primul fiu iar legătura dreapta reprezintă fratele. ce are pe prima linie valoarea lui n.01 72 .Precizări: OperaŃii: + . valori reale. este foarte importantă în afişarea grafică a informaŃiei. ScrieŃi un program care citeşte n puncte din plan (n ≤ 100) date prin coordonatele lor carteziene şi determină în care dintre aceste puncte putem alege centrul cercului de rază minimă ce conŃine în interior toate cele n puncte date. ScrieŃi un program care citeşte un număr natural n (cu maxim 10 cifre) şi determină toate numerele ce pot fi obŃinute mutând pe rând prima cifră a numărului n şi a celor obŃinute pe parcurs pe ultima poziŃie. iar pe următoarele n linii coordonatele carteziene ale punctelor. n şi m întregi). Se va afişa un mesaj de eroare dacă înmulŃirea matricelor nu este posibilă.) în modul următor: a) Se vor genera perechi de numere pseudo-aleatoare de tipul (x. Precizări: Matricea va fi structurată în primul fişier pe linii şi coloane astfel: 1. Exemplu: Dacă avem (1. y). dintr-un fişier ASCII. denumită în limba engleză „clipping”. c) se va evalua pi ca 4 × <numărul_de_puncte_din_interiorul_sfertului_de_cerc> / <numărul_total_de_puncte>. ScrieŃi un program care citeşte coordonatele a trei figuri geometrice formate doar din linii drepte şi determină şi afişează doar segmentele care se înscriu în suprafaŃa unui dreptunghi ale cărui coordonate vor fi şi ele citite de la tastatură. specificate ca parametru. câte două pe linie (x respectiv y). 23. 14. fiecare dintr-un fişier. ScrieŃi un program care citeşte fişierul text „TEST. 15. ScrieŃi un subprogram care să calculeze valoarea 2 la puterea 3000.au fost aşezate una sub alta. codul ASCII corespunzător precum şi frecvenŃa lor de apariŃie..IN” care conŃine un text scris pe mai multe linii şi afişează toate caracterele folosite. ScrieŃi un program care citeşte polinoame rare şi le memorează sub forma unei liste simplu înlănŃuite. Programul va semnala dacă acest lucru nu este posibil. ScrieŃi un program care să citească elementele a două matrice. calculează matricea transpusă şi o tipăreşte într-un alt fişier. 1) nu este posibilă ca toate arcele să aibă aceeaşi orientare. − folosind tipul şir de caractere. TransformaŃi apoi subprogramul pentru calculul oricărei puteri adică: n la puterea m (n < 10.‚{‘ respectiv ‚}’ . ScrieŃi un program care citeşte elementele unei matrice pătrate. 21. . Precizare: în reprezentarea fiu . Matricele vor fi structurate în fişiere pe linii şi coloane. * . ScrieŃi o funcŃie pentru suma a două polinoame rare. 17. ScrieŃi un program care citeşte un fişier reprezentând un program C şi scrie la ieşire acelaşi program în care acoladele corespunzătoare . Precizări: datele vor fi citite din fişierul text „PUNCTE. − folosind metode aritmetice. 2) (2. 13.

Exemplu: fişier1. luna. ScrieŃi un program care citeşte două fişiere ASCII structurate astfel: a. n.TXT” astfel: − pe primele două linii programul va scrie numărul de cuvinte din fiecare propoziŃie.txt CONSTANTIN Ioana VASILESCU Costin POPESCU George 8 Ianuarie 1978 16 Octombrie 1978 27 August 1980 73 . ScrieŃi un program care citeşte fişierul „AMENZI. Fiecărui conducător auto i se alocă 4 linii: prima linie va conŃine numele. structurat pe linii. Apoi programul: − va afişa suma de bani rezultată din amenzi.txt CONSTANTIN Ioana POPESCU George VASILESCU Costin fişier2.66 7.txt 8. 26. ScrieŃi un program care citeşte două fişiere ASCII structurate astfel: a. prenumele.24. Programul va citi mai întâi numărul de înregistrări. Programul va concatena cele trei câmpuri (numele. al doilea fişier va conŃine. − numele şoferilor care nu au plătit amenda/amenzile ordonate alfabetic. 1 .66 9.89 28. media la examenul de admitere. − va verifica dacă ultimul cuvânt din prima propoziŃie este o anagramă (are aceleaşi litere) a ultimului cuvânt din cealaltă propoziŃie. structurat pe linii. 25.txt 8 Ianuarie 1978 27 August 1980 16 Octombrie 1978 fişier3.89 fişier3. 27. primul fişier va conŃine.plătită). cea de a doua numărul de înmatriculare al maşinii.TXT” care conŃine evidenŃa amenzilor de circulaŃie pe o perioadă dată. Programul va asocia numele şi prenumele persoanei de la linia i din primul fişier cu data naşterii de la aceeaşi linie din al doilea fişier. prenumele şi nota).TXT” două propoziŃii scrise fiecare pe câte o linie. primul fişier va conŃine. − procentul de amenzi neîncasate. Programul va concatena cele cinci câmpuri (numele. Precizări: Rezultatele se vor scrie în fişierul „OUTPUT. Pentru verificarea cuvintelor scrieŃi şi folosiŃi o funcŃie recursivă. structurat pe linii. − pe ultima linie va scrie mesajul „DA” sau „NU” pentru cazurile în care ultimele cuvinte sunt sau nu anagrame.52 8. le va sorta în ordinea crescătoare a mediei şi va scrie rezultatul într-un al treilea fişier ASCII. ScrieŃi un program care citeşte din fişierul „INPUT. Programul va crea o listă de premiere care să cuprindă abonaŃii al căror numere de telefon cuprind doar cifre pare iar prima şi ultima cifră sunt proporŃionale. precum şi numele şoferilor şi numărul maşinii care a plătit amenzile cele mai mari. în formatul <zi> <luna> <an>. ScrieŃi un program care citeşte lista abonaŃilor telefonici dintr-un oraş dintr-un fişier care conŃine numărul de telefon şi numele abonatului pe câte o linie. data naşterii. separate prin unul sau mai multe spaŃii. al doilea fişier va conŃine.txt CONSTANTIN Ioana POPESCU George VASILESCU Costin fişier2.txt POPESCU George CONSTANTIN Ioana VASILESCU Costin 9. în formatul <nume> <prenume>. numele şi prenumele angajaŃilor unei firme. structurat pe linii. ce de a treia suma de bani corespunzătoare amenzii şi cea de a patra dacă amenda a fost sau nu plătită (0 – neplătită. b. Programul va asocia numele şi prenumele persoanei de la linia i din primul fişier cu nota de la linia i din al doilea fişier. Programul: − va afişa numărul de cuvinte din fiecare propoziŃie. numele şi prenumele candidaŃilor la un concurs de admitere. Orice alt caracter este considerat separator. b. an). Exemple de fişiere: fişier1. zi. le va sorta în ordinea descrescătoare a vârstei şi va scrie rezultatul într-un al treilea fişier ASCII. în formatul <nume> <prenume>. PropoziŃiile conŃin cuvinte formate din literele alfabetului englez. separate prin unul sau mai multe spaŃii.52 7.

RescrieŃi programul pentru a putea prelucra un text oricât de mare şi în care cuvintele sunt despărŃite prin orice tip de spaŃiu sau semn de punctuaŃie.1415 int main() { printf("pi = %f". Lungimea unei linii „ln” şi dimensiunea unei pagini „lp” se citesc de la tastatură.h> #define PI 3.h> #include <stdlib. Programul va construi un fişier ordonat care conŃine reuniunea celor două fişiere iniŃiale şi va elimina duplicatele din fişier. 32. } fişier2. − se va folosi sortarea prin inserŃie. interclasarea a două fişiere ordonate conform punctului anterior. PI). − numărul de cuvinte din text este cel mult 100.TXT” care conŃine un text ce se încheie cu o linie goală. Să se afişeze toate cuvintele textului în ordine alfabetică. return 0. Exemplu: fişier1. 3. iar pentru acelaşi autor. introducerea unei înregistrări noi în bibliotecă. Numele fişierelor se citesc de la tastatură. ştergerea unei înregistrări din bibliotecă. ScrieŃi un program care construiască un fişier cu înregistrări de tip bibliotecă cu următoarele câmpuri: Numele autorului Titlul cărŃii Editura Anul apariŃiei Lista cuvintelor cheie Programul va permite următoarele operaŃii: a. sortarea fişierului în ordinea crescătoare a numelor autorilor (ordine lexicografică). 74 . RescrieŃi programul extinzându-l pentru a putea împărŃirea textul în k coloane.IN” care conŃine un text scris pe mai multe linii şi rescrie textul pe pagini formate din două coloane cu linii de lungime egală.29. b.h> int main() { printf("pi = %f". } 30.1415). c.c #include <stdio.h> #include <stdlib. ScrieŃi un program care citeşte fişierul text „INTRARE. 31. ScrieŃi un program care citeşte fişierul „TEXT. extragerea într-un fişier nou a înregistrărilor în funcŃie de valoarea unui anumit câmp: Numele autorului Titlul cărŃii Editura Anul apariŃiei ExistenŃa unui anumit cuvânt în lista cuvintelor cheie d. ScrieŃi un program care să recunoască într-un fişier sursă C directiva de preprocesare „#define” şi care să genereze un alt fişier preprocesat. Precizări: − lungimea unui cuvânt este de maxim 25 caractere. înregistrările se ordonează în funcŃie de anul apariŃiei.c #include <stdio. − cuvintele sunt despărŃite printr-un spaŃiu. e. return 0.

Sign up to vote on this title
UsefulNot useful

Master Your Semester with Scribd & The New York Times

Special offer for students: Only $4.99/month.

Master Your Semester with a Special Offer from Scribd & The New York Times

Cancel anytime.