Caiet de Laborator

Caiet de laborator pentru clasa a IX-a 1
CUPRINS
CAP.1 FUNCŢII DE CITIRE/SCRIERE.........................................................................2
1.1 Funcţii de citire/scriere pentru caractere şi şiruri de caractere.......................................2

A. Probleme rezolvate...............................................................................................................2
B. Probleme propuse.................................................................................................................4
1.2 Funcţiile de citire/scriere cu format....................................................................................5

A. Probleme rezolvate...............................................................................................................5
B. Probleme propuse.................................................................................................................9
CAP.2 OPERATORII LIMBAJULUI C.......................................................................11

A. Probleme rezolvate.............................................................................................................11
B. Probleme propuse...............................................................................................................22
CAP.3 STRUCTURI DE CONTROL..........................................................................26
3.1 Structura secvenţială şi alternativă...................................................................................26

3.2 Structura repetitivă (iterativă)..........................................................................................31

CAP.4 TABLOURI.................................................................................................... 74
4.1 Tablouri unidimensionale (vectori)...................................................................................74

B. Probleme propuse.............................................................................................................106
2 Caiet de laborator pentru clasa a IX-a
Cap.1 Funcţii de citire/scriere
1.1 Funcţii de citire/scriere pentru caractere şi şiruri de

caractere
A. Probleme rezolvate
Caiet de laborator clasa a IX-a 3
1. Citiţi fără ecou un caracter imprimabil sau alb, tastat la terminalul standard şi apoi afişaţi-l pe
ecranul acestuia.
#include<conio.h>
void main()
{ int c;
clrscr();
//caracterul citit fără ecou se memorează în c
c=getch();
//se afişează caracterul; pe ecran apare o singură
//dată
putch(c);
getch();
}
2. Citiţi cu ecou un caracter imprimabil sau alb şi afişaţi-l pe ecran precedat de un spaţiu.
#include<conio.h>
void main()
{ int c;
clrscr();
c=getche(); //citirea caracterului cu ecou
putch(‘ ‘); //afişarea spaţiului care îl precede
putch(c); //afişarea caracterului
getch();
}
3. Citiţi un caracter alb sau imprimabil folosind macrourile getchar şi putchar .

#include<stdio.h>
#include<conio.h>
void main()
{ int c;
clrscr();
c=getchar(); //citirea bufferată a caracterului
putchar(c); //afişarea caracterului
getch();
}
4. Citiţi cu ecou o litera mică şi afişaţi-o ca literă mare .

#include<conio.h>
void main()
{ int lit;
clrscr();
lit=getche(); //citirea literei cu ecou
//transformarea în literă mare şi afişarea
putch(lit-‘a’+’A’);
getch();
}
Observaţie: Dacă caracterului citit nu este o literă mică, programul anterior nu poate afişa o
literă mare ci un caracter ASCII care are codul obţinut după calculul anterior.
5. Rezolvaţi problema anterioară folosind macrourile getchar şi putchar .

#include<stdio.h>
#include<conio.h>
void main()
{ clrscr();
putchar(getchar()-‘a’+’A’);
getch();
}
6. Citiţi de la terminalul standard o succesiune de caractere imprimabile şi reafişaţi-o pe ecran,

după ce l-aţi şters .
#include<stdio.h>
#include<conio.h>
4 Caiet de laborator clasa a IX-a
void main()
{ char tab[255];
clrscr();
gets(tab); //citeşte şirul de caractere
clrscr(); //curăţă ecranul
puts(tab); //reafişează şirul de caractere
getch();
}
Observaţie: Rulaţi acest program pentru şiruri care conţin caractere albe (blancuri şi tab-uri) şi
studiaţi comportamentul funcţiei gets() pentru astfel de şiruri.
7. Să se afişeze pe câte un rând fiecare cuvânt al textului : INVAT LIMBAJUL C.
#include<stdio.h>
#include<coio.h>
void main()
{ clrscr();
puts(“INVAT”);
puts(“LIMBAJUL”);
puts(“C”);
getch();
}
Observaţie: Reamintim că funcţia puts() scrie un caracter newline după şirul pe care îl are drept
argument, mutând cursorul la începutul liniei următoare.
B. Probleme propuse
1. Citiţi cu ecou un caracter imprimabil sau alb, tastat la terminalul standard şi apoi afişaţi-l pe
ecran.
2. Citiţi cu ecou o literă mare şi apoi afişaţi-o ca literă mică.
3. Rezolvaţi problema anterioară folosind macrourile getchar() şi putchar().
4. Rezolvaţi problemele A.3 şi A.4 fără a folosi o variabilă intermediară în care să memoraţi
caracterul citit.
5. Scrieţi un program care să citescă un caracter de control(ex.F1,F2) şi afişaţi “imaginea”
acestuia. Studiaţi modul în care trebuie utilizată funcţia getch() pentru aceste caractere.
6. Scrieţi un program care să se afişeze antetul de mai jos :
linia 1 Notele la disciplina
linia 4 LIMBAJUL C
linia 6 8 Noiembrie 2000
linia 10 Nr.crt. Nume Prenume Nota
unde :
- cuvântul "Notele" se afişează începând cu coloana 15 din linia 1
- cuvântul "LIMBAJUL" se afişează începând cu coloana 30 din linia 4
- data calendaristică se afişează începând tot cu coloana 30 din linia 6
- in linia 10 , cuvintele încep după cum urmează :
Nr.crt. începe în coloana 2
Nume începe în coloana 18
Prenume începe în coloana 37
Nota începe în coloana 50
1.2 Funcţiile de citire/scriere cu format
1. Citiţi un caracter şi afişaţi-l pe ecran precedat de un spaţiu .
#include<stdio.h>
#include<conio.h>
void main()
{ char c;
clrscr();
scanf("%c",&c); //citirea caracterului
printf("%2c",c); //afişarea pe un câmp de lungime 2

getch();
}
2. Citiţi un caracter şi afişaţi-l pe ecran precedat şi urmat de câte un asterisc.

#include<stdio.h>
#include<conio.h>
void main()
{ char c;
clrscr();
printf("*%c*",c); //afişarea in formatul cerut
getch();
}
3. Citiţi un caracter şi afişaţi-l într-un câmp de 3 caractere, aliniat la dreapta, câmpul fiind
precedat şi urmat de câte un asterisc.
#include<stdio.h>
#include<conio.h>
void main()
{ char c;
clrscr();
//afişarea pe un câmp de lungime 3 şi
//încadrat de asterisc
printf("*%3c*",c);
getch();
}
4. Citiţi o cifră zecimală ca şi caracter şi afişaţi-o precedată de 3 zerouri nesemnificative .

#include<stdio.h>
#include<conio.h>
void main()
{ char c;
clrscr();
scanf("%c",&c); //citirea unui caracter
//afişarea caracterului precedat de 3 zerouri
printf("000%c",c);
getch();
}
5. Citiţi un şir de maxim 50 de caractere şi afişaţi-l pe ecran pe o linie nouă.

#include<stdio.h>
#include<conio.h>
void main()
{ char t[51];
clrscr();
scanf("%s",t); //citirea şirului
printf("\n%s",t); //afişarea pe o linie nouă
getch();
}
6. Citiţi un număr întreg de 4 cifre şi afişaţi-l pe ecran folosind următorii specificatori de format :
%d, %o, %x, %X, %7d, %-7d, %07d. Câmpul va fi precedat şi urmat de un asterisc. Analizaţi
valoarea afişată pentru fiecare specificator în parte şi justificaţi-o teoretic.
#include<stdio.h>
#include<conio.h>
void main()
{ int i;
clrscr();
scanf("%4d",&i); //citirea unui întreg de 4 cifre
printf("*%d*\n",i);
printf("*%o*\n",i);
printf("*%x*\n",i);
printf("*%X*\n",i);
printf("*%7d*\n",i);
printf("*%-7d*\n",i);
printf("*%07d*\n",i);
getch();
}
7. Citiţi un caracter şi scrieţi-l pe o linie nouă urmat de codul său ASCII .
#include<stdio.h>
#include<conio.h>
void main()
{ char car;
clrscr();
scanf("%d",&car); //citirea caracterului
printf("caracterul: %c are codul ASCII:
%d\n",car,car);
getch();
}
Observaţie: Reamintim că în limbajul C tipul char este tratat ca un întreg scurt. Specificatorul
%c va trata valoarea ca pe un caracter, în timp ce specificatorul %d ca pe un întreg, adică va
afişa codul său ASCII.
8. Citiţi o literă mare şi afişaţi-o ca literă mică .

#include<stdio.h>
#include<conio.h>
void main()
{ char c;
clrscr();
//afişarea ca literă mică
printf("%c\n",c-'A'+'a');
getch();
}
9. Citiţi numele şi prenumele unei persoane de la tastatură şi apoi afişaţi datele respective pe o
linie nouă separate printr-un tabulator. Se presupune că atât numele cât şi prenumele nu
depăşesc fiecare 50 de caractere şi se separă prin caractere albe la tastare .
#include<stdio.h>
#include<conio.h>
void main()
{ char nume[51] ;
char prenume[51];
clrscr();
//citirea celor două şiruri de caractere
scanf("%s%s",nume,prenume);
//afişarea lor separate prin tab
printf("%s\t%s\n",nume,prenume);
getch();
}
Observaţie: Reamintim că, în lipsa unui scanset adecvat, funcţia scanf() nu poate citi şiruri de
caractere ce conţin spaţii. Astfel, primul specificator %s va citi caracterele tastate până la primul
spaţiu şi le va stoca în variabila nume. Deasemenea, funcţia scanf() lucrează în mod bufferat,
adică preia datele nu direct de la tastatură ci din zona tampon (buffer-ul) asociată acesteia.
Bufferul de intrare se goleşte atunci când se citesc toate caracterele până la întâlnirea caracterului
newline (generat la apăsarea tastei Enter). Astfel, al doilea specificator %s va citi restul
caracterelor aflate în buffer după spaţiu şi le va stoca în variabila prenume. Această citire se face
corect numai dacă datele de intrare sunt tastate conform cerinţelor din program (pe aceeaşi linie
separate prin spaţii).
10. Citiţi un întreg zecimal de cel mult 4 cifre şi afişaţi-l ca întreg în baza 10, 8 şi 16. Cele trei
numere vor fi afişate pe o linie nouă separate printr-un tabulator.
#include<stdio.h>
#include<conio.h>
void main()
{ int n;
clrscr();
//citirea unui întreg de 4 cifre
scanf("%4d",&n);
//afişarea valorii în cele 3 baze
printf("%d\t%o\t%x\n",n,n,n);
getch();
}
11. Citiţi 4 cifre zecimale şi afişaţi-le precedate de câte un spaţiu fiecare .

#include<stdio.h>
#include<conio.h>
void main()
{ int i1,i2,i3,i4;
clrscr();
//citirea a patru întregi de câte o cifră fiecare
scanf("%1d %1d %1d %1d",&i1,&i2,&i3,&i4);
//afişarea valorilor precedate de spatii
printf("%2d%2d%2d%2d",i1,i2,i3,i4);
getch();
}
12. Citiţi o dată calendaristică tastată sub forma zzllaa (două cifre pentru zi, două cifre pentru lună
şi două pentru an). Afişaţi data respectivă sub forma 19aallzz.
#include<stdio.h>
#include<conio.h>
void main()
{ int zi,luna,an;
clrscr();
//citirea celor 3 întregi de câte două cifre
//fiecare
scanf(“%2d%2d%2d”,&zi,&luna,&an);
//afişarea celor 3 întregi precedaţi de 19, pe câte
//un câmp de 2 caractere cadrat la dreapta şi
//completat cu zerouri
printf(“19%02d%02d%02d\n”,an,luna,zi);
getch();
}
B. Probleme propuse
1. Citiţi un caracter şi afişaţi-l într-un câmp de 3 caractere cadrat la stânga, câmpul fiind precedat
şi urmat de câte un asterisc .
2. Pentru o dată calendaristică se introduce de la tastatură un şir care are forma: "zz.ll.aa".
Scrieţi un program care citeşte o dată în acest format şi apoi afişează pe câte o linie ziua, luna
şi anul citite.
3. Citiţi un text de 16 caractere şi afişaţi-l pe ecran, pe câte o linie nouă, folosind următorii
specificatori de format : %s, %20s, %-20s, %10s, %10.5s, %-10.5s. Câmpul în care se
afişează textul este precedat şi urmat de un asterisc.
4. Citiţi un număr întreg cu maxim 9 cifre şi afişaţi-l pe ecran folosind specificatorii de format :
%ld, %lo, %lx, %lX, %15ld, %-15ld, %015ld. Câmpul va fi precedat şi urmat de un asterisc.
5. Citiţi inversul lui PI cu 14 zecimale (0.31830988618379) şi afişaţi-l folosind următorii
specificatori de format : %.15f, %.14f, %.13f, %.12f, %.11f, %.10f, %f, %.15e, %.14e, %.13e,
%.12e, %.11e, %.10e, %e. Pe fiecare linie se vor tipări câte trei valori separate prin câte două
spaţii.
6. Citiţi numărul 1234567890 şi afişaţi-l cu exponent .
7. Afişaţi numărul float f=123.672 folosind specificatorii : %10f, %10.1f, %10.0f, %e, %.1Ef, %g,
%10.1g, %10.0g, fiecare valoare pe câte o linie , câmpul fiind precedat şi urmat de un
asterisc.
8. Citiţi un întreg zecimal de cel mult 9 cifre şi afişaţi-l ca întreg în baza 10, 8 si 16 . Cele trei
valori vor fi afişate pe o linie nouă separate printr-un tabulator .
9. Citiţi 4 cifre zecimale şi afişaţi-le urmate fiecare de câte un zero.
10. Citiţi o succesiune de 4 cifre care reprezintă o zi din luna octombrie pe primele două cifre şi
anul pe ultimile două (zzaa). Afişaţi data calendaristică respectivă sub forma : 19aa
Octombrie zz .
11. Scrieţi un program care, utilizând un scanset adecvat, să permită citirea şi afişarea şirurilor de
caractere care conţin spaţii.
12. Scrieţi un program care, utilizând un scanset adecvat, să permită citirea şirurilor de caractere
care nu conţin cifre zecimale, respectiv litere mici.
Cap.2 Operatorii limbajului C
1. Ţinând seama de regulile de precedenţă pentru calculul expresiilor, indicaţi rezultatele pe care
le afişează programul următor, explicaţi obţinerea acestor rezultate şi apoi verificaţi rulând
programul.
#include<stdio.h>
#include<conio.h>
void main()
{
int x=2, y=7, z,u;
clrscr();
u=x*(y-2)%3;
printf("\n u=%d",u);
z=u+=x*=y;
printf("\n x=%d\ty=%d\tu=%d\tz=%d",x,y,u,z);
x=-y*z%3+u;
printf("\n x=%d",x);
z=(x-y)*(u-x);
printf("\n z=%d",z);
getch();
}
Rezolvare:
Pentru prima expresie, mai întâi se efectuează scăderea, întrucât parantezele
au prioritate mai mare; se obţine valoarea 5; operaţiile de înmulţire şi împărţire cu rest au aceeaşi
precedenţă şi se efectuează de la stânga la dreapta; se înmulţeşte x cu 5 şi după aceea se face
împărţirea lui 10 cu 3, restul obţinut fiind 1.
În a doua expresie operatorii cu atribuiri se evaluează de la dreapta la stânga;
mai întâi se înmulţeşte x cu y, x devenind 14 ; mai apoi se adună la u valoarea lui x, u devenind
15; în final valoarea lui u este atribuită lui z care devine astfel egal cu 15.
În a treia expresie operatorul unar minus schimbă semnul lui y întrucât are o
precedenţă mai mare decât toate celelalte operaţii; se execută de la stânga spre dreapta
înmulţirea şi împărţirea cu rest obţinându-se zero; ultima operaţie înainte de atribuire este
adunarea; după atribuire x devine 15.
În ultima expresie se evaluează parantezele de la stânga la dreapta, x-y şi
apoi u-x, apoi înmulţirea şi ultima operaţie este atribuirea, rezultatul fiind zero. Se afişează :
u=1; x=14 y=7 u=15 z=15; x=15; z=0
2. Având în vedere modul de evaluare a expresiilor de atribuire, să se indice rezultatele afişate

de programul următor, să se explice aceste rezultate şi apoi să se verifice rulând programul.
#include<stdio.h>
#include<conio.h>
void main()
{
int a=1, b=2, c=3, d=4;
clrscr();
d/=(a*=(b+=c)%3)-10; //1
printf("\n a=%d b=%d c=%d d=%d",a,b,c,d);
a=1 , b=2, c=3, d=4;
d/=a*=b+=c%3-10; //2
printf("\n a=%d b=%d c=%d d=%d",a,b,c,d);
getch();
}
Rezolvare:
Pentru prima instrucţiune, se execută întâi b=b+c şi b devine 5, apoi b%3=2, apoi a=a*2 şi a
devine 2, apoi d=d/(2-10)=d/(- 8)=0. Valorile afişate sunt: a=2 b=5 c=3 d=0.
Pentru a doua instrucţiune, se execută mai întâi b=b+c%3-10=2+0-10 şi b devine –8, apoi
a=a*(-8) şi a devine –8, apoi d=d/(- 8) şi d devine 0. Variabila c rămâne 3 şi se afişează: a=- 8
b=- 8 c=3 d=0
3. Programul următor ilustrează modalităţile de utilizare a operatorilor unari +,-,++,-- şi a

operatorilor binari + şi -. Precizaţi rezultatele afişate de program, explicaţi aceste rezultate şi
apoi verificaţi-le rulând programul.
#include<stdio.h>
#include<conio.h>
void main()
{
int a=1, b=10;
clrscr();
printf("\n a+++b=%d",a+++b); //1
printf(" a=%d b=%d",a,b);
a=1, b=10;
printf("\n a+ ++b=%d",a+ ++b); //2
a=1, b=10;
printf("\n a +++b=%d",a +++b); //3
a=1, b=10;
printf("\n a+++ b=%d",a+++ b); //4
a=1, b=10;
printf("\n a++ +b=%d",a++ +b); //5
printf("\n a++-b=%d",a++-b); //6
a=1, b=10;
printf("\n a---b=%d", a---b); //7
a=1, b=10;
printf("\n a+++++b=%d", a+ + + + +b); //8
a=1, b=10;
printf("\n a++ + ++b=%d", a++ + ++b); //9
getch();
}
Rezolvare:
Aceşti operatori se grupează de la stânga la dreapta. Instrucţiunea (1), execută a+b,
apoi a++ (postincrementare) şi se afişează:
a+++b=11 a=2 b=10
Instrucţiunea (2) preincrementează b (operatorul de preincrementare este legat
explicit de b) şi apoi a+b. Se afişează:
a+ ++b=12 a=1 b=11
Instrucţiunea (3), pentru că cei trei operatori + sunt legaţi de b, face gruparea lor de la
stânga la dreapta astfel încât se calculează a+b şi apoi se postincrementează a ( ca la
instrucţiunea 1). Se afişează:
a +++b=11 a=2 b=10
Instrucţiunea (4) lucrează exact ca (3), cei trei operatori + fiind legaţi de a. Se
afişează:
a+++ b=11 a=2 b=10
Instrucţiunea (5) se execută la fel ca (3) şi (4) operatorul de postincrementare fiind
scris explicit, legat de a şi separat prin spaţiu de operatorul binar de adunare. Se afişează:
a++ +b=11
Instrucţiunea (6) lucrează cu valorile obţinute după instrucţiunea (5), adică a=2 şi
b=10. Se execută întâi a-b, apoi a se postincrementează. Se afişează:
a++-b=-8 a=3 b=10
Instrucţiunea (7) lucrează ca instrucţiunea (1), dar cu operatori de scădere şi
postdecrementare. Întâi se execută a-b, apoi a--. Se afişează:
a---b=-9 a=0 b=10
În cazul instrucţiunii (8), compilatorul nu poate stabili care operatori sunt de
incrementare şi care de adunare. Îi execută de la stânga la dreapta sub forma a+(+(+(+
(+b))))=a+b. Cele două variabile nu îşi schimbă valoarea şi se afişează:
a+++++b=11 a=1 b=10

În cazul instrucţiunii (9) operatorii de pre şi postincrementare sunt legaţi explicit de
variabile şi separaţi prin spaţii de operatorul binar de adunare. Se execută în ordine ++b, a+b,
a++ şi se afişează:
a++ + ++b=12 a=2 b=11
4. Să se arate care sunt rezultatele pe care le afişează programul de mai jos şi să se

argumenteze aceste rezultate pe baza regulilor de precedenţă. Să se verifice apoi rezultatele
rulând programul.
#include<stdio.h>
#include<conio.h>
void main()
{
int x=3, y=7, z=9;
clrscr();
printf("\n %d", x>y&&y>z);
printf("\n %d", x<y&&y<z);
printf("\n %d", x>y||x<z);
printf("\n %d", !(x>y));
printf("\n %d", x==3);
printf("\n %d", x==3&&y==7&&z==y+2);
printf("\n %d", x!=y&&z!=y);
getch();
}
Rezolvare:
Întrucât operatorii de comparare au precedenţe mai mari decât operatorii logici, se
evaluează mai întâi expresiile relaţionale ale căror rezultate sunt 1 sau 0. După cum au
atribuite valori, x nu este mai mare decât y şi y nu este mai mare ca z; cele două comparaţii
au ca rezultat 0; operatorul && va conduce în final tot la rezultatul 0.
În a doua expresie ambele comparaţii sunt adevărate şi conduc fiecare la un rezultat
1, iar operatorul logic && conduce la valoarea 1 pentru expresie, valoare care se afişează.
În acelaşi mod se continuă evaluarea celorlalte expresii.
5. Având în vedere semnificaţia pe care o are compunerea diferiţilor operatori cu operatorul de

atribuire, să se indice care sunt rezultatele afişate de programul de mai jos, apoi să se verifice
aceste rezultate rulând programul.
#include<stdio.h>
#include<conio.h>
void main()
{
int x1,x2,x3,x4,x5,x6,x7,x8,x9;
clrscr();
x1=x2=x3=x4=x5=x6=x7=x8=x9=17;
x1+=2; printf("\n x1=%d",x1);
x2-=2; printf("\n x2=%d",x2);
x3*=2; printf("\n x3=%d",x3);
x4/=2; printf("\n x4=%d",x4);
x5%=2; printf("\n x5=%d",x5);
x6<<=2; printf("\n x6=%d",x6);
x7>>=2; printf("\n x7=%d",x7);
x8+=++x8; printf("\n x8=%d",x8);
x9+=--x9; printf("\n x9=%d",x9);
getch();
}
Rezolvare:
Se adaugă 2 la x1; se scade 2 din x2; se înmulţeşte x3 cu 2; se împarte x4 prin 2; în x5 se va
afla restul împărţirii lui x5 prin 2; x6 se înmulţeşte cu 4 şi x7 se împarte la 4; x8 este
incrementat cu 1 şi se adaugă lui însuşi, devenind 36; x9 este decrementat şi noua lui
valoare, 16 se adaugă lui x9 devenind 32. Rezultatele tipărite de program sunt :
x1=19 x2=15 x3=34 x4=8 x5=1 x6=68 x7=4 x8=36 x9=32
6. Expresiile care apar în lista de parametri la apelul funcţiei printf() se evaluează înainte de
apelarea funcţiei, după regulile de precedenţă cunoscute. Explicaţi rezultate afişate de
programul următor şi apoi verificaţi aceste rezultate rulând programul.
#include<stdio.h>
#include<conio.h>
void main()
{
int a=1, b=3, c=5, d=7;
clrscr();
printf("\n a<b==d>b este: %d",a<b==d>b);
printf("\n (a<c)?d:b este: %d",(a<c)?d:b);
printf("\n -a+b*c/d este: %d",-a+b*c/d);
printf("\n a+d%%b+c este: %d",a+d%b+c);
printf("\n b<d+c este: %d",b<d+c);
printf("\n a==b+d==c+2 este: %d",a==b+d==c+2);
printf("\n ++b * --c * d++ este: %d",++b*--c*d++);
printf("\n a++ + ++b este: %d",a++ + ++b);
printf("\n (a<<3)-++d%%b este: %d",(a<<3)-++d%b);
printf("\n b+=c+d+a este: %d",b+=c+d+a);
getch();
}
Rezolvare:
Se compară mai întâi a cu b, apoi d cu b; întrucât inegalităţile sunt adevărate,
rezultatele comparării asignează celor două subexpresii valoarea 1; cele două valori 1 sunt
comparate prin operatorul de egalitate şi expresia fiind adevărată se va tipări 1.
În a doua expresie se compară a cu c; rezultatul este 1, ceea ce determină tipărirea
lui d.
În a treia expresie , mai întâi a devine -1, se înmulţeşte b cu c şi apoi se împarte la d;
-1+2=1.
În a patra expresie, se calculează întâi d%b=7%3=1 şi apoi se fac adunările
1+1+5=7.
În a cincea expresie b=3 este într-adevăr mai mic decât d+c=12 şi se afişează
valoarea expresiei relaţionale adică 1.
În a şasea expresie evaluarea se face de la stânga la dreapta şi a=1 este diferit de
b+d=10, deci valoarea primei expresii relaţionale este 0. Apoi acest 0 este diferit de c+2=7 şi
se afişează valoarea expresiei relaţionale adică 0.
Pentru a şaptea expresie prin decrementare b devine 4; prin decrementare c devine
4 ; 4*4*7=112 ; postincrementarea lui d are efect ulterior şi d devine 8.
În a opta expresie folosim valorile obţinute la paşii anteriori adică a=1 şi b=4. Întâi se
preincrementează b (devine 5), apoi se adună cu a şi se afişează valoarea 6, apoi se
postincrementează a care devine 2.
În a noua expresie folosim valorile obţinute la paşii anteriori adică a=2, d=8, b=5. Se
preincrementează d (devine 9), apoi se afectuează d%b=9%5=4. Această valoare se scade
din a<<3=2*23=16 şi se afişează 12.
În ultima expresie la valoarea lui b=5 se adună c=4, d=9 şi a=2 şi se afişează 20 care
este şi noua valoarea a lui b.
Rezultatele afişate sunt:
a<b==d>b este: 1
(a<c)?d:b este : 7
-a+b*c/d este : 1
a+d%b+c este: 7
b<d+c este: 1
a==b+d==c+2 este : 0
++b*--c*d++ este : 112
a++ + ++b este : 6
(a<<3)-++d%b este : 12
b+=c+d+a este : 20
7. Operatorul condiţional se poate utiliza individual sau compus, chiar cu el însuşi. Explicaţi
modul în care este folosit acest operator în programul următor pentru a determina maximul a
trei numere întregi.
#include<stdio.h>
#include<conio.h>
void main()
{
int a,b,c,d;
clrscr();
printf("a,b,c=");
scanf("%d %d %d",&a,&b,&c);
d=a>b? a>c? a:c:b>c? b:c; //1
printf("\ maximul=%d",d);
getch();
}
Rezolvare: Înstrucţiunea (1) are descrierea algoritmică următoare:
dacă a>b
atunci dacă a>c
atunci da
altfel dc
sfarsit_daca
altfel daca b>c
atunci db
altfel dc
sfarsit_daca
sfarsit_daca
Evident, acesta este algoritmul de determinare a maximului dintre 3 valori.
8. Ţinând seama de regulile de precedenţă ale operatorilor pe biţi şi de semnificaţia acestora, să

se indice care sunt rezultatele pe care le tipăreşte programul următor şi să se verifice apoi
aceste rezultate rulând programul.
#include<stdio.h>
#include<conio.h>
void main()
{
int a=03, b=04, c=05, d=01;
clrscr();
printf("\n ~a: %o",~a); //(1)
printf("\n ~a: %d",~a);
printf("\n aâ|d: %o",aâ|d); //(2)
printf("\n aâ|d: %d",aâ|d);
printf("\n a&c^b: %o",a&c^b); //(3)
printf("\n a&c^b: %d",a&c^b);
printf("\n a|b: %o", a|b); //(4)
printf("\n a|b: %d", a|b);
printf("\n a|b&c|d: %o",a|b&c|d); //(5)
printf("\n a|b&c|d: %d",a|b&c|d);
printf("\n a^b: %o", a^b); //(6)
printf("\n a^b: %d", a^b);
printf("\n ~a|~b: %o", ~a|~b); //(7)
printf("\n ~a|~b: %d", ~a|~b);
printf("\n a|(b|c)&d: %o",a|(b|c)&d); //(8)
printf("\n a|(b|c)&d: %d",a|(b|c)&d);
getch();
}
Rezolvare:
Cele trei variabile sunt întregi cu semn scrise în baza 8 (încep cu cifra 0). Pentru evaluarea
expresiilor vom considera tipul int reprezentat intern pe 2 octeţi. În cazul în care lucraţi cu int
pe 4 octeţi, modul de evaluare se extinde pe 32 de biţi.
Pentru instrucţiunile (1), reprezentarea internă binară a lui a este 00000000
00000011, ~a=11111111 11111100 care în baza 8 (cu specificatorul %o) este 177774. Dacă
folosim specificatorul %d, numărul zecimal corespunzător se calculează astfel: bitul de semn
este 1, deci numărul este negativ, reprezentat în complement faţă de 2. Scădem din
~a=11111111 11111100 valoarea 1 şi obţinem 11111111 11111011, apoi negăm bit cu bit şi
obţinem 00000000 00000100 care este 4 în baza 10. Numărul fiind negativ, se afişează –4.
Pentru instrucţiunile (2) evaluăm astfel: aâ=0, indiferent de valoarea lui a, iar 0|d=d
indiferent de valoarea lui d. Cum d=1, se va afişa 1 cu ambii specificatori de format.
Pentru instrucţiunile (3) evaluăm astfel: întâi se evaluează a&c, adică (00000000
00000011)&(00000000 00000101)=00000000 00000001, adică 1 şi în baza 10 şi în baza 8. În
continuare, se evaluează (00000000 00000001)^(00000000 00000100)=00000000 00000101
care este 5. Cu ambii specificatori de format se tipăreşte valoarea 5.
Pentru instrucţiunile (4) se evaluează a|b=(00000000 00000011)|(00000000
00000100)=00000000 00000111 care este 7 în ambele baze. Cu ambii specificatori de format
se tipăreşte valoarea 7.
Pentru instrucţiunile (5) evaluarea se face astfel: întâi se evalueză b&c=(00000000
00000100)&(00000000 00000101)=00000000 00000100 adică 4. În continuare se evaluează
a|4=(00000000 00000011)|(00000000 00000100)=00000000 00000111 adică 7. În final se
evaluează 7|d=7|1=7. Cu ambii specificatori de format se afişează valoarea 7.
Pentru instrucţiunile (6), se procedează ca în exemplele anterioare şi se obţine
a^b=00000000 00000111=7 care se afişează cu ambii specificatori de format.
Pentru instrucţiunile (7) evaluarea se face astfel: întâi se execută ~a=11111111
11111100 (vezi (1)), apoi se execută ~b=11111111 11111011 şi în final se execută
(11111111 11111100)|(11111111 11111011)=11111111 11111111 care este un număr
negativ pentru că are bitul de semn 1. Cu specificatorul de format %o se afişează 177777. În
cazul specificatorului %d, valoarea se calculează astfel: scădem din valoarea binară anterioră
1 şi obţinem 11111111 11111110 care negat bit cu bit este 00000000 00000001 adică 1. Cum
numărul este negativ, se va afişa –1.
Pentru instrucţiunile (8) se procedează astfel: se evaluează întâi b|c pentru că
parantezele au prioritate maximă, şi obţinem 00000000 00000101=5. În continuare se
execută 5&d=5&1=1. În final se execută a|1=3|1=3. Cu ambii specificatori de format se
afişează valoarea 3.
9. Fie declaratia : int i,x,y;

Să se verifice dacă utilizarea următoarelor expresii este corectă; argumentaţi răspunsul apoi
verificaţi pe calculator, pentru diferite valori ale variablelor citite de la intrare.
a) (i+1)++ b) i+++ 1 c) --x+y d) ++i++
e) &x+1 f) &(x+1) g) -x&1
Rezolvare:
a) incorectă; (i+1) nu este o variabilă posibilă în stânga operatorului
b) este corectă; se efectuează întâi i+1 şi apoi i++, fiind o postincrementare
c) este corectă; se decrementează x şi apoi se adună cu y
d) incorectă
e) corectă; rezultatul este o adresă mai mare cu sizeof(x)
f) incorectă; x+1 nu este nume de variabilă
g) corectă
10. Precizaţi efectul operaţiilor :

int x,y,z; scanf("%d",&x); y-=(z=x,x<0);
Justificaţi răspunsul, apoi verificaţi pe calculator. Pentru obţinerea rezultatului erau necesare
parantezele rotunde ?
Rezolvare:
Instrucţiunea de atribuire realizează, în ordine, următoarele operaţii :
- z=x
- x<0 , cu rezultat 0 sau 1
- y=y-(x<0) , cu rezultat numeric
Fără paranteze, se realizează,în ordine, următoarele operaţii :
- z=x
- y=y-x
- x<0
În concluzie, pentru obţinerea rezultatului corect, este necesară folosirea parantezelor
rotunde.
11. Fie declaraţia : unsigned n=359; Care din expresiile următoare determină octetul inferior
al variabilei n ? Justificaţi răspunsul pentru fiecare caz în parte (cu ajutorul reprezentării
interne) şi apoi verificaţi fiecare variantă rulând pe calculator.
a) n%256 b) n>>4 c) n & 0xFF
d) (n<<4)>>4 e) n>>8 f) (n<<8)>>8
Rezolvare:
Expresia a) foloseşte teorema împărţirii cu rest şi obţinem 359%256=93 deci este
corectă, pentru că restul împărţirii unui număr natural la 256 este o valoare din mulţimea
0...255, deci chiar octetul inferior al acestuia.
Expresia b) deplasează reprezentarea internă a lui n care este 00000001 01011101
cu 4 poziţii spre dreapta. Obţinem valoarea 00000000 00010101 care este în baza 10 egală
cu 21 deci este greşită.
Expresia c) foloseşte o mască pe biţi egală cu 00000000 11111111 şi care cu
operatorul & extrage exact octetul inferior al variabilei n. Într-adevăr, 00000001 01011101 &
00000000 11111111=00000000 01011101=93 adică octetul inferior al lui n, deci este corectă.
Expresia d) deplasează întâi reprezentarea internă a lui n cu 4 poziţii spre stânga şi
obţinem 00010101 11010000, apoi deplasează acest număr cu 4 poziţii spre stânga şi
obţinem 0000001 01011101 adică valoarea n de la care am plecat. În concluzie este greşită.
Expresia e) deplasează reprezentarea internă a lui n cu 8 poziţii spre stânga, adică
elimină complet octetul inferior şi obţinem 00000000 00000001, deci este greşită.
Expresia f) deplasează reprezentarea internă a lui n cu 8 poziţii spre stânga,
eliminând octetul superior, şi obţinem 01011101 00000000, apoi deplasează această valoare
înapoi cu 8 poziţii spre dreapta şi obţinem 00000000 01011101 adică chiar octetul inferior al
lui n, deci este corectă.
12. Evaluaţi rezultatul şi corectitudinea următoarelor secvenţe de operaţii, apoi verificaţi răspunsul
cu ajutorul calculatorului :
int i=1, j=2, k=-7;
double x=0.0, y=2.5;
a) -i-5*j>=k+1 b) 3<j<5 c) i+j+k==-2*j
d) x/!!y e) x && i || j-3
Rezolvare:
a) corectă : E=0
b) corectă : E=1
c) corectă : E=1
d) corectă : E=0 (face !y=0; !0=1; x/1=0/1=0 )
e) corectă : E=1 (face x&&i=0; j-3=-1; 0||-1=1)
13. Să se determine care din următoarele expresii sunt corecte. Argumentaţi răspunsul şi apoi
verificaţi fiecare variantă cu ajutorul calculatorului.
a) z=x++==4 || y--<5;
b) a=x==y==z;
Rezolvare:
a) corect : face , în ordine, z=x==4||y<5; x++; y--;
b) corect : face a=(x==y)==z;
14. Să se stabilească valoarea şi tipul expresiilor de mai jos, apoi să se verifice rezultatele cu
ajutorul calculatorului:
int i,j,k; float fa,fb,fc; double da,db,dc;
long la,lb; unsigned ua,ub; char ca;
Valorile iniţiale ale variabilelor :
i=10; j=5; k=4; fa=10.0; fb=5.0; da=10.0; db=5.0;
la=1000000000; ua=40000; ca=’3’;
Operaţiile:
a) i+j*k g) i*fa/4 m) la/i t) k*10+ca-‘0’
b) i/k+j h) fa/4 n) la/fb u) fc=fa/fb
c) –i-j+20 i) 4/fa o) la/db v) dc=da/db
d) i*-k+100 j) i*da-k p) ua/la x) dc=la*da
e) i/4.0 k) da/4 r) i+ca y) dc=(double)la*ua
f) i/k-8.0 l) la-i*1000 s) ca-‘0’
z) ub=((double)la*ua)/1e9
Expresiile de mai jos au rezultate eronate. Să se motiveze acest fapt.
er1) i=ua er2) la=1e20 er3) ua*2 er4) ca*ua
er5) ca*la
Rezolvare:
Reamintim că în C tipul unei expresii este dat de cel mai mare tip (ca domeniu de valori şi
reprezentare internă) care intervine în expresie.
a) tipul int , valoarea 30
b) tipul int , valoarea 7
c) tipul int , valoarea 5
d) tipul int , valoarea 60
e) tipul float , valoarea 2.5
f) tipul float , valoarea –6.0
g) tipul float , valoarea 25.0
h) tipul float , valoarea 2.5
i) tipul float , valoarea 0.4
j) tipul double , valoarea 96.0
k) tipul double , valoarea 2.5
l) tipul long , valoarea 999990000
m) tipul long , valoarea 100000000
n) tipul float , valoarea 200000000.0
o) tipul double , valoarea 200000000.0
p) tipul long , valoarea 0
r) tipul int , valoarea 61
s) tipul char , valoarea ‘3’
t) tipul int , valoarea 43
u) tipul float , valoarea 2.0
v) tipul double , valoarea 2.0
x) tipul double , valoarea 10000000000.0
y) tipul double , valoarea 40000000000000.0
z) tipul unsigned , valoarea 40000
În privinţa expresiilor eronate, toate depăşesc domeniul de reprezentare corespunzător tipului.
15. Să se depisteze erorile existente în expresiile de mai jos, să se argumenteze şi să se verifice

cu ajutorul calculatorului.
a) a+b~(a+c)
b) ((a+)b*c)*3
c) ~a=b+c
d) a<=b
e) a|(~b||^d)<x
Rezolvare:
a) ~ este operator unar
b) + este operator binar
c) ~a nu este nume de variabilă
d) corect
e) ^ este operator binar
B. Probleme propuse
1. Fie definiţiile :
unsigned m=0xF0F , n=0xF0F0;
char format[]="\n n=%4x";
Să se precizeze care vor fi valorile afişate după fiecare dintre următoarele operaţii, apoi să se
verifice răspunsurile cu ajutorul calculatorului.
a) printf(format,m);
b) printf(format,n);
c) printf(format,~m);
d) printf(format,~n);
e) printf(format,m|n);
f) printf(format,m&n);
g) printf(format,m^n);
2. Realizaţi cu ajutorul operatorului condiţional "?" şi/sau a operaţiilor de atribuire următoarele

operaţii. Pentru fiecare scrieţi un program, valorile variabilelor care intervin fiind citite de la
tastatură.
a) determinarea valorii absolute a unui număr real x

b) determinarea minimului în valoare absolută a două numere reale a şi b
c) determinarea maximului a trei numere întregi a, b şi c
d) y=2x3-8x2+7x-1
e) y=(ax+b)/(cx+d)
f) a=max(x+y,x-y)
g) m=max(3x2+1 ,6x-20)
h) x=1,5a3-2,8a2+3,7a-1
i) x=a*b*c-(a-b)(a-c)+(b-c)
j) dacă (x+y)!=0 atunci z=x/(x+y) altfel z=0
k) y=|2x+10|
l) dacă x>y şi x>z atunci u=v , altfel u=v/2
m) dacă x>y sau x>z, atunci p=a+b, altfel p=a-b
n) dacă nici una din condiţiile i>j,i>k,i>n nu are loc, atunci x=a, altfel x=b
o) dacă c are ca valoare codul ASCII al unui caracter alb (spaţiu sau tab), atunci i se
măreşte cu 1, altfel se micşorează cu 1
p) dacă a>b>1 şi a<10, atunci x=a/b, altfel x=100
q) dacă c are ca valoare un cod ASCII diferit de codul caracterelor albe, atunci i=x+y, altfel
i=x-y
r) dacă valorile variabilelor a,b şi c pot reprezenta lungimile laturilor unui triunghi, atunci x
are ca valoare perimetrul acestui triunghi, altfel are valoarea 0.
3. Sa se determine valorile expresiilor de mai jos, apoi să se verifice rezultatele cu ajutorul

calculatorului:
int i==0xabcd, j; unsigned ua=0xabcd;
a)i>>3 e)-~i g)~-!im)~0<<8 l)ua>>1&i
b)i<<1 f)~-i h)j=iî m)~0>>4 c)ua<<1|I
i)~i n)!~-i
d)j=++~i j)ua<<1 o)ua<<1î
e)-i k)~!-i p)j=~i++
f)ua>>3
4. Scrieţi un program care citeşte doi întregi de la intrarea standard şi afişează media lor
aritmetică cu 2 zecimale.
5. Scrieţi un program care citeşte două numere întregi de la intrarea standard şi afişează 1 dacă
suma celor două numere este nenegativă şi 0 în caz contrar.
6. Scrieţi un program care citeşte două numere reale simplă precizie de la intrarea standard şi
afişează valoarea 2 dacă produsul numerelor citite este mai mare decât suma lor şi 1 în caz
contrar.
7. Să se scrie un program care afişează valoarea 1 dacă primul număr citit de la tastatură este
pătratul celui de-al doilea număr citit de la tastatură şi 0 în caz contrar. Numerele care se
citesc sunt întregi fără semn.
8. Să se scrie un program care citeşte de la intrarea standard un întreg şi afişează 1 dacă
întregul respectiv aparţine intervalului [-1000,1000] şi 0 în caz contrar.
9. Să se scrie un program care citeşte un întreg de la intrarea standard şi afişează 1 dacă este
multiplu de 4 şi 0 în caz contrar.
10. Să se scrie un program care citeşte un întreg şi afişează valoarea 1 dacă numărul respectiv
este multiplu de 4, dar nu este multiplu de 100.
11. Să se scrie un program care citeşte un întreg de la intrarea standard şi afişează 1 dacă
numărul citit este multiplu de 4 şi nu este multiplu de 100 sau este multiplu de 400, şi 0 în caz
contrar.
12. Să se scrie un program care citeşte valoarea lui x, calculează şi afişează valorile expresiilor:
x10, x20, x40. Pentru a calcula puterea folosim funcţia putere care are prototipul double
pow(double a,double b) în fişierul header math.h şi returnează ab.
13. Scrieţi un program care citeşte valoarea variabilei double x, calculează valoarea expresiei
3,5x2+4,6x+0,8 şi afişează partea întreagă a valorii expresiei respective.
14. Să se scrie un program care citeşte valoarea variabilei double x, calculează şi afişează
valoarea expresiilor: 7[x]*[x]-3[x]+10 şi 7(x-[x])2-3(x-[x])+10, unde [x] notează partea
întreagă a lui x.
15. Să se scrie un program care citeşte un număr întreg diferit de 0, îl atribuie variabilei n şi
afişează cu 15 zecimale valoarea expresiei (n-1)/n.
16. Să se citescă un întreg în variabila x şi să se afişeze valoarea expresiei x3+32145x+1. Întrucât

valorile pot depăşi limitele valorilor întregi, programul va realiza calculele în virgulă flotantă
dublă precizie.
17. Să se scrie un program care citeşte două numere întregi şi afişează maximul dintre ele.
18. Să se scrie un program care citeşte două numere, primul întreg iar celălalt double, şi afişează
maximul dintre ele.
19. Să se scrie un program care citeşte doi întregi şi afişează maximul dintre valorile lor absolute.
20. Să se scrie un program care citeşte valoarea variabilei x şi afişează valoarea funcţiei f(x)
definită ca mai jos:
f(x)=3x2+7x-10 pentru x<0
f(x)=2 pentru x=0
f(x)=4x2-8 pentru x>0
21. Să se scrie un program care citeşte trei numere întregi şi afişează maximul dintre ele.
22. Să se scrie un program care citeşte valoarea lui x de tip double şi calculează valoarea
funcţiei f(x) definită ca mai jos:
f(x)=(3x8+2x4-x2+10)/(3x8+2x4-x2-10) dacă abs(3x8+2x4-x2-10)>=EPS
f(x)=1 altfel
unde EPS=1e-10 şi abs este funcţia modul cu prototipul în math.h.
Cap.3 Structuri de control
3.1 Structura secvenţială şi alternativă
1. Să se calculeze şi să se afişeze media aritmetică a două numere reale citite de la tastatură.

#include<stdio.h>
#include<conio.h>
void main()
{
float a,b,ma;
printf("primul numar: "); scanf("%f",&a);
printf("al doilea numar: "); scanf("%f",&b);
ma=(a+b)/2;
printf("media aritmetica=%.2f\n",ma);
getch();
}
2. Să se interschimbe valorile a două variabile întregi citite de la tastatură.

#include<stdio.h>
#include<conio.h>
void main()
{
int a,b,aux;
printf("primul numar: "); scanf("%d",&a);
printf("al doilea numar: "); scanf("%d",&b);
//folosim regula celor trei pahare
printf("\ninitial a=%d\tb=%d\n",a,b);
aux=a; a=b; b=aux;
printf("\ndupa interschimbare a=%d\tb=%d\n",a,b);
getch();
}
3. Scrieţi un program care stabileşte relaţia de ordine dintre două numere reale citite de la
tastatură.
#include<stdio.h>
#include<conio.h>
void main()
{
float a,b;
printf("primul numar: "); scanf("%f",&a);
printf("al doilea numar: "); scanf("%f",&b);
if(a<b)
printf("\na<b\n");
else
if(a==b)
printf("\na=b\n");
else
printf("\na>b\n");
getch();
}
4. Se citesc trei numere întregi a,b,c. Să se tipărească maximul dintre ele folosind doar două
comparaţii.
#include<stdio.h>
#include<conio.h>
void main()
{
int a,b,c,max;
printf("numarul a="); scanf("%d",&a);
printf("numarul b="); scanf("%d",&b);
printf("numarul c="); scanf("%d",&c);
//presupunem că a este maximul
max=a;
//comparăm cu b si c şi actualizăm maximul
if(max<b)
max=b;
if(max<c)
max=c;
printf("\n\tmaximul=%d\n",max);
getch();
}
5. Să se rezolve ecuaţia de gradul unu ax+b=0 pentru coeficienţii a,b reali citiţi de la tastatură.
#include<stdio.h>
#include<conio.h>
void main()
{
double a,b,x;
printf("coeficientul a="); scanf("%lf",&a);
printf("coeficientul b="); scanf("%lf",&b);
if(a) //coeficientul lui x nenul;soluţie unică
{
x=-b/a;
printf("\n\tx=%g\n",x);
}
else
if(b)
printf("\n\tecuatia nu admite
solutie\n");
else
printf("\n\tecuatie nedeterminata,
infinitate de solutii\n");
getch();
}
6. Să se calculeze valoarea absolută a unui număr real citit de la tastatură.

#include<stdio.h>
#include<conio.h>
void main()
{
float x,abs;
printf("numarul real x="); scanf("%f",&x);
if(x<0)
abs=-x;
else
abs=x;
printf("\n\tvaloarea absoluta este %.3f\n",abs);
getch();
}
7. Să se calculeze valoarea expresiei

E= A+B, dacă C>=0
A-B, dacă C<0
unde A,B,C sunt trei variabile întregi citite de la tastatură.
#include<stdio.h>
#include<conio.h>
void main()
{
int a,b,c,e;
printf("valoarea A="); scanf("%d",&a);

printf("valoarea B="); scanf("%d",&b);
printf("valoarea C="); scanf("%d",&c);
if(c>=0)
e=a+b;
else
e=a-b;
printf("\n\tE=%d\n",e);
getch();
}
8. Să se calculeze valoarea funcţiei

f(x)= x2, dacă x<0
2x+1, dacă x>=0
unde valoarea reală a lui x se citeşte de la tastatură
#include<stdio.h>
void main()
{
double x,f;
printf("x="); scanf("%lf",&x);
if(x<0)
f=x*x;
else
f=2*x+1;
printf("\n\tf(x)=%.4lf\n",f);
}
B. Probleme propuse
1. Cunoscând numărul natural n să se calculeze suma 1+2+3+...+n.

2. Cunoscând k şi n (k<=n) numere naturale, să se calculeze suma k+(k+1)+...+n.
3. Să se determine ultima cifră a sumei x+y, unde x şi y sunt numere naturale date de la
tastatură.
4. Se citesc de la tastaură două numere naturale nenule. Să se calculeze media aritmetică,
media geometrică şi media armonică a celor două numere cu trei zecimale.
5. Se consideră a,b,c trei variabile de tip real ale căror valori se citesc de la tastatură. Se cere să
se interschimbe circular de la stânga la dreapta valorile lor şi apoi să se afişeze. Exemplu:
pentru a=2,b=17,c=4.3, după interschimbare avem a=4.3, b=2, c=17.
6. Să se determine ultimele două cifre ale produsului a*b, pentru a şi b numere întregi cu maxim
cinci cifre fiecare citite de la tastatură.
7. Să se rezolve ecuaţia de gradul doi ax2+bx+c=0 pentru coeficienţii reali a,b,c citiţi de la
tastatură.
8. Se citesc patru numere întregi oarecare. Să se verifice dacă ele alcătuiesc o mulţime în sens
matematic, adică valorile sunt distincte.
9. Să se rezolve sistemul de ecuaţii cu coeficienţi reali
ax+by=c
dx+ey=f
pentru a,b,c,d,e,f numere reale oarecare date.
10. Să se calculeze valoarea expresiei E=A+1/B pentru valorile reale A,B citite de la tastatură.
11. Să se calculeze valoarea expresiei
E= A+B+C dacă C<=-1
C/(A+B) dacă –1<C<1
(A+B)/C dacă C>=1
pentru A,B,C numere întregi citite de la tastatură.
12. Să se calculeze valoarea expresiei E=A2/(A2+B)1/2, unde puterea ½ înseamnă radical ordin
doi, iar A şi B sunt numere reale citite de la tastatură.
13. Să se calculeze valoarea expresiei P(x)=a4x4+a3x3+a2x2+a1x+a0, unde a4,a3,a2,a1,a0 şi x sunt
numere întregi citite de la tastatură (atenţie la depăşirea limitelor valorilor întregi).
14. Dându-se două numere întregi a şi b, a>b, testaţi dacă cele două numere se divid. În caz
afirmativ afişaţi un mesaj, în caz contrar afişaţi câtul şi restul împărţirii lui a la b.
15. Se citesc trei numere întregi a,b şi c. Să se afişeze numerele în ordine crescătoare.
16. Fiind date numere reale a,b,c,d afişaţi cel mai mic dintre ele.
17. Fie a,b şi c salariile a trei persoane. Să se precizeze câte dintre acestea sunt cel puţin egale
cu o valoare dată x reprezentând salariul mediu pe economie.
18. Citindu-se o literă mică, să se precizeze dacă aceasta este vocală sau consoană.
19. Pe baza datei curente exprimată prin trei valori naturale nenule (zi,lună,an), să se calculeze
data zilei următoare.
20. Se citesc trei numere naturale nenule a,b,c. Să se verifice dacă cele trei valori pot fi laturile
unui triunghi şi, în caz afirmativ, să se calculeze aria lui cu formula lui Heron. De asemenea să
se specifice şi dacă este un triunghi particular (isoscel sau echilateral).
21. Să se determine ultima cifră a numărului 2x, pentru x număr natural dat.
22. Folosind o singură comparaţie, să se verifice dacă trei numere naturale cu cel mult trei cifre
fiecare sunt pitagoreice. Se va afişa un mesaj corespunzător.
23. Se citeşte de la tastatură un număr natural cu exact patru cifre. Să se verifice dacă numărul
este palindrom, adică citindu-l de la sfârşit spre început se obţine acelaşi număr.
24. Se dau două numere de tip întreg. Să se verifice dacă ele sunt numere consecutive.
25. Să se verifice dacă o fracţie a/b, pentru a şi b numere naturale nenule cu maxim 5 cifre, se
simplifică prin k. În caz afirmativ se va afişa şi fracţia simplificată. Numerele a,b,k se citesc de
la tastatură în această ordine.
3.2 Structura repetitivă (iterativă)
1. Să se calculeze suma S=1+2+....+n, respectiv produsul P=1*2*...*n pentru n număr natural

nenul citit de la tastatură.
#include<stdio.h>
#include<conio.h>
void main()
{
int n,s=0,i;
double p=1; //n! poate depăşi limitele întregi
printf("n="); scanf("%d",&n);
for(i=1;i<=n;i++)
{
s+=i;
p*=i;
}
printf("\n\tsuma=%d\n",s);
printf("\tprodusul=%.0lf\n",p);
getch();
}
2. Să se calculeze media aritmetică a n valori întregi citite pe rând de la tastatură, unde n este
un număr natural nenul dat.
#include<stdio.h>
#include<conio.h>
void main()
{
int n,x,s=0,i;
double ma;
printf("numarul de numere,n="); scanf("%d",&n);
printf("\t Introduceti numerele intregi\n");
for(i=1;i<=n;i++)
{
printf("a%d=",i); scanf("%d",&x);
s+=x;
}
ma=(double)s/n;
//cast-ul este necesar,în caz contrar se obţine
//partea întreagă a mediei aritmetice prin
//împărţirea a 2 numere întregi
printf("\n\tmedia aritmetica=%g\n",ma);
getch();
}
3. Să se realizeze înmulţirea a două numere întregi a şi b date de la tastatură, prin adunări

repetate.
#include<stdio.h>
#include<conio.h>
void main()
{
int a,b;
double p=0;
//produsul poate depăşi limitele întregi
printf("a="); scanf("%d",&a);
printf("b="); scanf("%d",&b);
//folosim relaţia a*b=a+a+.....+a, de b ori
for(int i=1;i<=b;i++) p+=a;
printf("\n\t%d * %d = %g\n",a,b,p);
getch();
}
4. Fiind dată funcţia f:NN, f(n)=n+1, dacă n este par, respectiv f(n)=n-1, dacă n este impar, să
se calculeze valorile funcţiei pentru n=1,2,…,10.
#include<stdio.h>
#include<conio.h>
void main()
{
int n=10,i;
printf("\nValorile functiei sunt:\n");
for(i=1;i<=n;i++)
if(i&1) //i este impar
printf("\tf(%d)=%d\n",i,i-1);
else
printf("\tf(%d)=%d\n",i,i+1);
getch();
}
5. Să se determine şi să se afişeze divizorii proprii ai unui număr natural nenul n dat de la

tastatură.
#include<stdio.h>
#include<conio.h>
void main()
{
int n,i;
printf("numarul natural nenul,n="); scanf("%d",&n);
//divizorii proprii ai lui n se găsesc în mulţimea
//{2,3,...,[n/2]}
printf("\n\tDivizorii proprii ai lui %d
sunt:\n\n",n);
for(i=2;i<=n/2;i++)
if(!(n%i)) //echivalent cu n%i==0
printf("%d ",i);
printf("\n");
getch();
}
6. Se defineşte şirul lui Fibonacci (legea creşterilor organice) astfel:

F(n)= 0, dacă n=0
1, dacă n=1
F(n-1)+F(n-2), dacă n>=2
adică termenii şirului sunt 0,1,1,2,3,5,8,13,21,....Să se afişeze primii n termeni ai şirului pentru
n natural nenul citit de la tastatură.
#include<stdio.h>
#include<conio.h>
void main()
{
int n,a,b,c,i;
printf("numarul de termeni,n="); scanf("%d",&n);
a=0; //primul termen
b=1; //al doilea termen
printf("\n\t Termenii sirului Fibonacci sunt:\n");
printf("0 1 ");
for(i=2;i<=n;i++)
{
c=a+b; //următorul termen egal cu suma
//precedenţilor 2
a=b; b=c;
printf("%d ",c);
}
printf("\n");
getch();
}
7. Se citesc pe rând n numere reale nenule (n natural nenul dat). Să se afişeze media aritmetică
a câte două numere citite succesiv.
Observaţii:
Pentru a calcula media aritmetică avem nevoie la fiecare pas de două valori: valoarea citită la
pasul anterior şi valoarea citită la pasul curent. Vom memora cele două valori în două variabile x
şi, respectiv, y. Pentru a avea valoarea y disponibilă pentru calculul următoarei medii, înainte de a
trece la pasul următor vom transfera această valoare în x. Prima valoare din cele n se citeşte în
variabila x în afara ciclului de calcul efectiv al mediilor.
#include<stdio.h>
#include<conio.h>
void main()
{
int n,i;
float x,y;
printf("numarul de valori reale,n=");
scanf("%d",&n);
printf("\n\t Introduceti %d valori reale:\n",n);
printf("x1="); scanf("%f",&x); //primul număr
for(i=2;i<=n;i++)
{
printf("x%d=",i); scanf("%f",&y);
//y este numărul curent
printf("\t media=%.3f\n",(x+y)/2);
x=y;
}
getch();
}
8. Se citesc pe rând n numere întregi (n natural nenul dat). Să se verifice dacă numerele apar
sau nu în ordine crescătoare.
Observaţii:
Se observă că un şir de valori este ordonat crescător dacă oricare două valori consecutive sunt
bine ordonate, adică ak-1<=ak, pentru k=2,3,..,n. Este suficient ca o singură pereche de valori
consecutive să nu respecte relaţia şi şirul nu mai este ordonat. Ca şi în problema precedentă,
avem nevoie de valoarea citită la pasul precedent şi de valoarea citită la pasul curent, deci vom
lucra cu două variabile, x şi y. Deoarece toate cele n numere trebuiesc citite, indiferent dacă în
final şirul este ordonat sau nu, vom folosi o variabilă sem iniţializată cu 1 pe care o vom schimba
în 0 dacă găsim o pereche neordonată. Testând la sfârşit valoarea acestei variabile putem lua o
decizie corectă asupra naturii şirului.
#include<stdio.h>
#include<conio.h>
void main()
{
int n,i,x,y,sem=1;
printf("numarul de numere,n="); scanf("%d",&n);
printf("\n\tIntroduceti %d numere intregi\n",n);
printf("x1="); scanf("%d",&x);
for(i=2;i<=n;i++)
{
printf("x%d=",i); scanf("%d",&y);
if(y<x) sem=0; //pereche neordonată
x=y;
}
if(sem) //echivalent cu sem==1
printf("\n\tsirul este ordonat crescator\n");
else
printf("\n\tsirul nu este ordonat
crescator\n");
getch();
}
9. Fie expresia P(x)=anxn+an-1xn-1+.....+a1x+a0. Să se calculeze valoarea expresiei pentru x real

dat, n natural nenul dat şi numerele ai reale date, în două cazuri: valorile ai se introduc în
ordinea an,an-1,....,a0 şi, respectiv în ordinea a0,a1,...,an.
Observaţii:
Expresia de mai sus se numeşte polinom, x fiind argumentul polinomului. Gradul maxim al lui x (n
în notaţia de mai sus) se numeşte gradul polinomului, iar numerele a0,a1,......,an se numesc
coeficienţii polinomului. Există două metode diferite pentru calculul valorii polinomului în punctul x
dat, după cum coeficienţii polinomului se citesc în ordinea crescătoare sau descrescătoare a
puterilor lui x.
a) Dacă coeficienţii se citesc în ordinea descrescătoare a puterilor lui x, adică în ordinea an,an-
1,....,a1,a0, facem următoarele observaţii:
-dacă n=0, atunci P0(x)=an
-dacă n=1, atunci P1(x)=anx+an-1=P0(x)*x+an-1
-dacă n=2, atunci P2(x)=anx2+an-axn-1+an-2=(anx+an-1)*x+an-2=P1(x)*x+an-2
-generalizând, Pk(x)=Pk-1(x)*x+an-k, iar modul de calcul se numeşte „gruparea lui Horner”
#include<stdio.h>
#include<conio.h>
void main()
{
int n,k;
double x,a,p=0;
printf("gradul polinomului,n="); scanf("%d",&n);
printf("valoarea x="); scanf("%lf",&x);
printf("\n\tIntroduceti coeficientii in ordinea
descrescatoare a puterilor lui x\n");
for(k=n;k>=0;k--)
{
printf("a%d=",k); scanf("%lf",&a);
p=p*x+a;
}
printf("\n\tP(%g)=%g\n",x,p);
getch();
}
b) Dacă coeficienţii se citesc în ordinea crescătoare a puterilor lui x, adică în ordinea a0,a1,...,an,
facem următoarele observaţii:
-dacă n=0, atunci P0(x)=a0
-dacă n=1, atunci P1(x)=a0+a1x=P0(x)+a1x
-dacă n=2, atunci P2(x)=a0+a1x+a2x2=P1(x)+a2x2
-generalizând, Pk(x)=Pk-1(x)+akxk
Se observă că trebuie să calculăm puterile succesive ale lui x şi să le adăugăm la valoarea
anterioară a polinomului. Pentru calculul acestor puteri vom folosi relaţia iterativă xk=xk-1*x.
#include<stdio.h>
#include<conio.h>
void main()
{
int n,k;
double x,a,p=0,q=1; //q=x0
printf("gradul polinomului,n="); scanf("%d",&n);
printf("valoarea x="); scanf("%lf",&x);
crescatoare a puterilor lui x\n");
for(k=0;k<=n;k++)
{
printf("a%d=",k); scanf("%lf",&a);
p+=a*q; q*=x; //următoarea putere a lui x
}
printf("\n\tP(%g)=%g\n",x,p);
getch();
}
10. Să se verifice dacă un număr natural nenul dat este „perfect”, adică este egal cu suma
divizorilor săi proprii, inclusiv 1. Exemplu, 6=1+2+3 este număr perfect.
Observaţii:
Determinăm pe rând divizorii proprii ai numărului şi-i însumăm plecând de la valoarea 1. Dacă
suma obţinută este egală cu numărul dat, acesta este perfect.
#include<stdio.h>
#include<stdio.h>
void main()
{
int n,d,s=1;
printf("numarul n="); scanf("%d",&n);
for(d=2;d<=n/2;d++)
if(!(n%d)) //echivalent cu n%d==0
s+=d; //suma divizorilor
if(s==n)
printf("\n\t%d este numar perfect\n",n);
else
printf("\n\t%d nu este numar perfect\n",n);
getch();
}
11. Se citesc pe rând n numere reale, n număr natural nenul dat. Să se determine numărul
valorilor pozitive, numărul valorilor negative şi, respectiv, numărul valorilor nule introduse.
#include<stdio.h>
#include<conio.h>
void main()
{
int n,i,poz=0,neg=0,nule=0;
double x;
//poz este numărul valorilor pozitive citite
//neg este numărul valorilor negative citite
//nule este numărul valorilor egale cu 0 citite
printf("numarul valorilor,n="); scanf("%d",&n);
printf("\n\tIntroduceti %d numere reale\n",n);
for(i=1;i<=n;i++)
{
printf("x%d=",i); scanf("%lf",&x);
if(x>0)
poz++;
else
if(!x)
nule++;
else
neg++;
}
printf("\nS-au introdus:\n");
printf("\t%d valori pozitive\n",poz);
printf("\t%d valori nule\n",nule);
printf("\t%d valori negative\n",neg);
getch();
}
12. Se citesc pe rând n numere reale. Să se determine minimul (maximul) dintre ele.
Observaţii:
Pentru a rezolva problema vom generaliza algoritmul de determinare a maximului/minimului dintre
3 valori.
#include<stdio.h>
#include<conio.h>
void main()
{
int n,i;
double x,max;
printf("\n\tIntroduceti %d valori reale\n",n);
printf("x1="); scanf("%lf",&x);
max=x;
//presupunem că prima valoare citită este maximă
for(i=2;i<=n;i++)
{
if(max<x)
max=x; //actualizarea maximului
}
printf("\n\tmaximul=%g\n",max);
getch();
}
13. Se citesc pe rând n numere reale. Să se determine media aritmetică a valorilor strict pozitive
citite.
#include<stdio.h>
#include<conio.h>
void main()
{
int n,i,nr=0;
double x,s=0;
//nr=numărul valorilor strict pozitive citite
//s=suma valorilor strict pozitive citite
printf("\n\tIntroduceti %d valori reale\n",n);
for(i=1;i<=n;i++)
{
if(x>=0)
{
s+=x; nr++;
//însumăm şi numărăm val. strict pozitive
}
}
if(nr) //am găsit valori strict pozitive
printf("\n\tmedia aritmetica=%g\n",s/nr);
else
printf(“\nsirul nu contine valori strict
pozitive\n”);
getch();
}
14. Fie funcţia f:R-{3}R, f(x)=(x2-7)/(x-3). Să se calculeze funcţia pentru mai multe valori ale lui
x din domeniul de definiţie. Citirea datelor se încheie la introducerea valorii 3.
Observaţii:
Deoarece numărul valorilor lui x este necunoscut, vom utiliza un ciclu cu test iniţial care încheie
citirea şi afişarea la introducerea valorii 3 pentru care funcţia nu este definită.
#include<stdio.h>
#include<conio.h>
void main()
{
double x,f;
while(x!=3)
{
f=(x*x-7)/(x-3);
printf("\tf(%g)=%g\n",x,f);
}
getch();
}
15. Fiind date două numere naturale nenule a şi b, să se determine câtul şi restul împărţirii întregi
a lui a la b prin scăderi repetate.
Observaţii:
Câtul împărţirii întregi a două numere reprezintă de câte ori „încape” împărţitorul în deîmpărţit. Ce
rămâne din deîmpărţit în urma acestor scăderi repetate reprezintă restul.
#include<stdio.h>
#include<conio.h>
void main()
{
int a,b,cat=0;
do{
}while(!a); //nu poate fi nul
do{
}while(!b); //nu poate fi nul
while(a>=b)
{
a-=b; //scădem împărţitorul
cat++; //incrementăm câtul
}
printf("\n\tcat=%d\trest=%d\n",cat,a);
getch();
}
16. Fiind date două numere naturale nenule a şi b să se determine c.m.m.d.c. al lor prin două
metode.
Observaţii:
Unul din cei mai cunoscuţi algoritmi pentru rezolvarea acestei probleme este algoritmul lui Euclid.
Pentru a înţelege modul de calcul vom considera două exemple:
a=72, b=60
72%60=12; 60%12=0 => cmmdc=12 (ultimul rest nenul)
a=45, b=27
45%27=18; 27%18=9; 18%9=0 => cmmdc=9 (ultimul rest nenul)
Prima variantă de program este:
#include<stdio.h>
#include<conio.h>
void main()
{
int a,b,rest;
rest=a%b; //primul rest
while(rest) //cât timp rest diferit de 0
{
a=b; b=rest;
rest=a%b; //noul rest
}
printf("\n\tcmmdc=%d\n",b); //ultimul rest nenul
getch();
}
Pentru a doua variantă folosim metoda scăderilor repetate: din numărul mai mare scădem
numărul mai mic până când cele două numere devin egale şi ambele reprezintă cmmdc.
#include<stdio.h>
#include<conio.h>
void main()
{
int a,b;
while(a!=b) //numerele diferă
if(a>b)
a-=b;
else
b-=a;
printf("\n\tcmmdc=%d\n",a); //sau b
getch();
}
17. Fiind dat un număr n natural nenul să se verifice dacă este prim sau nu.
Observaţii:
Singurul număr par şi prim este 2. Pentru n=2 nu are sens să-i verificăm divizorii. Orice alt număr
par diferit de 2 este compus fiind multiplu de 2. Numerele impare nu pot avea decât divizori impari
din mulţimea 3,5,7,....Conform teoremei lui Euclid, dacă un număr natural nu are divizori proprii în
mulţimea {2,3,….,√n} atunci este număr prim.
#include<stdio.h>
#include<stdlib.h>
#include<math.h>
#include<conio.h>
void main()
{
int n,d;
printf("numarul natural n="); scanf("%d",&n);
if(n==2)
{
printf("\n\t2 este numar prim\n");
exit(0); //oprirea forţată a programului
}
if(!(n%2)) //număr par
{
printf("\n\t%d este numar compus\n",n);
exit(0);
}
d=3;
while(d<=(int)sqrt(n)+1)
if(!(n%d)) //n se divide cu d
{
printf("\n\t%d este numar compus\n",n);
exit(0);
}
else
d+=2; //următorul divizor impar
printf("\n\t%d este numar prim\n",n);
getch();
}
18. Fiind dat un număr n natural nenul cu maxim 8 cifre, să se determine suma cifrelor sale.
Observaţii:
Ultima cifră a unui număr natural este restul împărţirii numărului la 10. Pentru a determina
următoarele cifre, trebuie să eliminăm această ultimă cifră din număr. Numărul obţinut prin
eliminarea ultimei cifre este de fapt câtul împărţirii numărului la 10. Repetăm procedeul până
când, prin împărţiri succesive, numărul devine egal cu 0, deci nu mai conţine nici-o cifră.
#include<stdio.h>
#include<conio.h>
void main()
{
long n;
int cifra,s=0; //s=suma cifrelor
printf("numarul natural nenul,n=");
scanf("%ld",&n);
do{
cifra=n%10; //ultima cifră
n/=10; //eliminăm ultima cifră
s+=cifra; //însumăm cifra
}while(n); //echivalent cu n!=0
printf("\n\tsuma cifrelor=%d\n",s); getch();
}
19. Să se verifice dacă un număr natural nenul n dat este „palindrom”, adică citit de la dreapta la
stânga şi de stânga la dreapta reprezintă aceeaşi valoare.
Observaţie:
Pentru a verifica proprietatea, vom extrage pe rând cifrele numărului şi vom construi simultan
numărul zecimal cu cifrele în ordine inversă. Dacă obţinem aceeaşi valoare, numărul iniţial este
palindrom.
#include<stdio.h>
#include<conio.h>
void main()
{
long n,t,inv=0;
int cifra;
scanf("%ld",&n); t=n; //facem o copie a lui n
//deoarece numărul devine egal cu 0
do{
cifra=t%10; //extragem ultima cifră
t/=10; //o eliminăm din număr
inv=inv*10+cifra;
//o introducem în numărul invers
}while(t);
if(n==inv)
printf("\n\t%d este palindrom\n",n);
else
printf("\n\t%d nu este palindrom\n",n);
getch();
}
20. Să se descompună un număr natural nenul n dat în factori primi, afişând pentru fiecare factor
prim şi puterea corespunzătoare.
Observaţii:
Algoritmul este cel folosit în aritmetică la descompunerea în factori primi. Se împarte numărul la 2
cât timp împărţirea se face exact. Numărul împărţirilor efectuate reprezintă puterea lui 2. Se
împarte apoi la 3 (dacă împărţirea se face exact), la 5 etc., până când, prin împărţiri repetate
numărul devine egal cu 1.
#include<stdio.h>
#include<conio.h>
void main()
{
int n,d=2,p;
scanf("%d",&n);
printf("\n\t\tDescompunerea lui %d este:\n",n);
do{
p=0; //puterea factorului prim d
while(!(n%d)) //împărţirea la d se face exact
{
n/=d; p++;
}
if(p) //puterea lui d este nenulă
printf("\tfactor=%d\tputerea=%d\n",
d,p);
if(d==2)
d=3;
else
d+=2;
}while(n>1);
getch();
}
21. Să se treacă un număr natural nenul n cu maxim 8 cifre din baza 10 în baza p dată
(2<=p<=9).
Observaţii:
Algoritmul de trecere din baza 10 într-o altă bază este cel din aritmetică. Se împarte numărul la
baza p obţinându-se un cât şi un rest. Câtul obţinut se împarte la p şi aşa mai departe, până când
se obţine câtul 0. Se scriu resturile în ordine inversă, numărul rezultat fiind echivalentul în baza p.
Exemplu: n=47, p=2
47:2 => cat=23, rest=1
23:2 => cat=11, rest=1
11:2 => cat=5, rest=1
5:2 => cat=2, rest=1
2:2 => cat=1, rest=0
1:2 => cat=0, rest=1
Numărul obţinut este 1011112. Problema care apare este afişarea numărului obţinut pentru că
resturile se obţin în ordinea inversă a scrierii lor în număr. În plus, pentru calculator, numărul afişat
este văzut ca un număr zecimal obişnuit. Simultan cu determinarea resturilor trebuie să calculăm
numărul zecimal care trebuie afişat. Pentru aceasta vom utiliza a doua metodă de calcul de la
polinoame, deoarece resturile reprezintă coeficienţii unui polinom pentru x=10, coeficienţi furnizaţi
în ordinea crescătoare a puterilor lui 10 (101111=1*100+1*101+1*102+1*103+0*104+1*105).
Deoarece se pot obţine numere zecimale foarte mari vom folosi o variabilă double.
#include<stdio.h>
#include<conio.h>
void main()
{
int n,p,rest;
double baza=0, putere=1;
//baza=numărul afişat în baza p
//putere=100
printf("numarul in baza 10,n=");
scanf("%d",&n);
printf("baza p="); scanf("%d",&p);
do{
rest=n%p; //restul împărţirii la baza p
n/=p; //noul cât
baza+=rest*putere;
//compunerea numărului ce trebuie afişat
putere*=10; //următoarea putere a lui 10
}while(n);
printf("\n\tnumarul in baza %d este %g\n",p,baza);
getch();
}
22. Se citeşte un număr scris în baza p dată (2<=p<=9). Să se determine echivalentul zecimal al
numărului respectiv.
Observaţie:
Folosim formula de calcul a echivalentului zecimal al unui număr dat într-o bază oarecare p: (cncn-
0 1 n
1….c1c0)p=c0*p +c1p +……+cnp , unde ck, 0<=k<=n, reprezintă cifrele numărului scris în baza p.
Se observă că trebuie să extragem pe rând cifrele numărului şi să le înmulţim cu puterile
corespunzătoare ale bazei. Practic, se combină algoritmul pentru determinarea cifrelor unui număr
cu cel pentru calculul valorii unui polinom în punctul x=p (baza) prin a doua metodă.
#include<stdio.h>
#include<conio.h>
void main()
{
long n,baza=0,putere=1;
int cifra,p;
//baza este echivalentul zecimal
//putere=p0
printf("baza p="); scanf("%d",&p);
printf("numarul in baza p, n=");
scanf("%ld",&n);
do{
cifra=n%10; //extragem cifra
n/=10; //eliminăm cifra
baza+=cifra*putere;
//introducem cifra în echiv. zecimal
putere*=p; //următoarea putere a bazei p
}while(n);
printf("\n\techiv. zecimal este %ld\n",baza);
getch();
}
23. Să se treacă un număr scris în baza p dată (2<=p<=9), în baza q dată (2<=q<=9).
Observaţii:
Folosim metoda de la prob. 22 şi trecem numărul din baza p în baza 10, apoi metoda de la prob.
21 şi trecem numărul obţinut anterior din baza 10 în baza q.
#include<stdio.h>
#include<conio.h>
void main()
{
long n,b10=0,putere=1,m=0;
int p,q,cifra;
//n este numărul dat in baza p
//b10 este echivalentul său în baza 10
//m este numărul echivalent în baza q
//putere=p0
printf("baza initiala p="); scanf("%d",&p);
printf("numarul initial in baza p, n=");
scanf("%ld",&n);
//trecem n în baza 10
printf("baza q="); scanf("%d",&q);
do{
cifra=n%10; //extragem cifra
n/=10; //eliminăm cifra
b10+=cifra*putere;
//introducem cifra în echiv. zecimal
putere*=p; //următoarea putere a bazei p
}while(n);
//trecem b10 în baza q
putere=1; //puterile lui 10
do{
cifra=b10%q; //obţinem restul

b10/=q; //obţinem noul cât
m+=cifra*putere;
//compunem numărul de afişat
putere*=10; //următoarea putere a lui 10
}while(b10);
printf("\n\tnumarul in baza %d este %ld\n",q,m);
getch();
}
24. Să se treacă un număr din baza 16 în baza 10. Citirea numărului hexazecimal se face cifră cu
cifră, de la stânga la dreapta, până la apăsarea tastei Enter.
Observaţii:
La scrierea unui număr în baza 16 se folosesc cifrele 0..9, literele ‘a’..’f’ sau ‘A’..’F’. Scrierea
numărului fiind practic o combinaţie de litere şi cifre, vom trata numărul ca pe un şir de caractere.
Fiecare caracter citit va fi transformat în valoarea lui zecimală pe baza codurilor ASCII asociate.
Citirea făcându-se caracter cu caracter de la stânga spre dreapta, pentru a calcula echivalentul
zecimal, vom folosi prima metodă de calcul de la polinoame, cifrele numărului constituind
coeficienţii polinomului pentru x=16.
#include<stdio.h>
#include<stdlib.h>
#include<conio.h>
void main()
{
double b10=0; //echivalentul zecimal
char c;
printf("\n\tIntroduceti un numar in baza 16
incheiat cu Enter\n");
c=getchar();
while(c!='\n')
{
if(c>='0' && c<='9') b10=b10*16+c-'0';
else
if(c>='a' && c<='f')
b10=b10*16+c-'a'+10;
else
if(c>='A'&& c<='F')
b10=b10*16+c-'A'+10;
else
{
printf("\nnumar
eronat!\n");
exit(0);
}
c=getchar();
}
printf("\n\techiv. zecimal=%g\n",b10); getch();
}
25. Să se găsescă perechile de numere naturale a şi b care satisfac relaţia a+b=1000, 17 divide a
şi 19 divide b.
Observaţii:
Relaţia se mai poate scrie 17a1+19b1=1000. Cea mai mare valoare pentru a1 se obţine când b1=1
şi este n=[(1000-19)/17]. Formăm toţi multiplii de 17, adică a=i*17, pentru i=1,2,…n şi calculăm b
ca diferenţa 1000-a. Dacă valoarea obţinută este multiplu de 19 am găsit o pereche de numere cu
proprietatea cerută.
#include<stdio.h>
#include<conio.h>
int a,b,n;
void main()
{
n=(1000-19)/17;
for(int i=1;i<=n;i++)
{
a=i*17;
b=1000-a;
if(!(b%19)) printf("%d %d\n",a,b);
}
getch();
}
26. Se citesc triplete de numere reale până la introducerea valorii 0. Să se determine pentru
fiecare triplet de numere dacă constituie laturile unui triunghi, iar în caz afirmativ să se
precizeze tipul acestuia.
Observaţii:
Deoarece citirea se încheie la introducerea valorii 0, vom citi numerele unul câte şi unul şi, în
cazul în care valoarea citită este 0, întrerupem execuţia programului cu funcţia exit(). Dacă
valorile citite sunt nenule, ele formează un triunghi dacă fiecare este mai mică decât suma
celorlalte două. Restul verificărilor folosesc proprietăţile triunghiurilor echilaterale, respectiv
isoscele.
#include<stdio.h>
#include<stdlib.h>
#include<conio.h>
void main()
{
float a,b,c;
while(1)
{
printf("a="); scanf("%f",&a);
if(!a) exit(0);
printf("b="); scanf("%f",&b);
if(!b) exit(0);
printf("c="); scanf("%f",&c);
if(!c) exit(0);
if(a<b+c && b<c+a && c<a+b)
{
printf("numerele formeaza un
triunghi ");
if(a==b && b==c)
printf("echilateral\n");
else
if(a==b || b==c || c==a)
printf("isoscel\n");
else
printf("scalen\n");
}
else
printf("numerele nu formeaza un
triunghi\n");
}
getch();
}
27. Se citesc perechi de numere naturale până când unul dintre ele este 0. Să se determine dacă
cele două numere ale fiecărei perechi sunt prime între ele.
Observaţii:
Două numere sunt prime între ele dacă au cmmdc=1. Pentru determinarea cmmdc folosim
metoda scăderilor repetate. Pentru a păstra valorile iniţiale ale variabilelor a şi b, lucrăm cu copiile
c şi d.
#include<stdio.h>
#include<conio.h>
void main()
{
int a,b,c,d;
printf("a,b="); scanf("%d %d",&a,&b);

while(a && b) //ambele valori nenule
{
c=a; d=b;
while(c!=d)
if(c>d) c-=d;
else d-=c;
if(c==1)
printf("\t%d si %d sunt prime intre
ele\n",a,b);
else
printf("\t%d si %d nu sunt prime intre
ele\n",a,b);
printf("a,b="); scanf("%d %d",&a,&b);
}
getch();
}
28. Să se determine toate perechile de numere gemene până la o anumită valoare n. Două
numere sunt gemene dacă ambele sunt prime şi diferenţa lor în valoare absolută este 2.
Observaţii:
Nu putem căuta numerele gemene decât printre numerele prime impare, cel mai mic astfel de
număr fiind 3. Pentru fiecare pereche impară (a,b=a+2), cu b<=n, verificăm pe rând dacă cele
două numere sunt prime. Fiind vorba de numere impare, care nu pot avea decât divizori impari,
cele două for-uri folosite pentru căutarea divizorilor proprii au fost proiectate corespunzător.
#include<stdio.h>
#include<math.h>
#include<conio.h>
void main()
{
int n,a,b,ok1,ok2,i;
a=3; b=a+2;
while(b<=n)
{
ok1=1;
for(i=3;i<=sqrt(a);i+=2)
if(!(a%i))
{
ok1=0; break;
}
if(ok1)
{
ok2=1;
for(i=3;i<=sqrt(b);i+=2)
if(!(b%i))
{
ok2=0; break;
}
if(ok1 && ok2) printf("%d %d\n",a,b);
}
a=b; b=a+2;
}
getch();
}
29. Se citesc numere naturale, până la introducerea unui număr real. Să se calculeze suma
numerelor citite, precum şi câtul şi restul împărţirii sumei numerelor la suma cifrelor sumei.
Obsevaţii:
Nu putem citi numerele decât într-o variabilă reală datorită modului în care lucrează funcţia scanf
(dacă folosim specificatorul %d şi introducem o valoare reală, ea este automat convertită la int
prin trunchiere). Un număr real este întreg (nu are zecimale) dacă este egal cu partea lui
întreagă. Pentru a verifica acest lucru folosim, de exemplu, funcţia ceil() care rotunjeşte un număr
real la cel mai apropiat întreg prin lipsă. Suma numerelor reale fără zecimale citite o convertim
apoi la tipul int folosind operatorul cast şi extragem cifrele.
#include<stdio.h>
#include<math.h>
#include<conio.h>
void main()
{
float x,s=0;
int c,sc=0;
printf("x="); scanf("%f",&x);
while(x==ceil(x)) //x nu are zecimale,este întreg
{
s+=x;
printf("x="); scanf("%f",&x);
}
printf("suma numerelor citite este %d\n",(int)s);
int s1=(int)s; //convertim suma la int
while(s1)
{
c=s1%10; s1/=10; sc+=c; //suma cifrelor
}
printf("catul=%d\t restul=%d\n",
(int)s/sc,(int)s%sc);
getch();
}
30. Se citesc numere naturale până la introducerea valorii 17. Să se afişeze toate tripletele de
numere citite consecutiv, în care al treilea număr este restul împărţirii primului la al doilea.
Observaţii:
La fiecare pas avem nevoie de trei valori: valoarea curentă şi precedentele două valori citite.
Pentru aceasta vom folosi trei variabile a,b,c. Primele două valori din şir le citim în afara ciclului
while în variabilele a şi b. Dacă valorile citite sunt diferite de 17, citim în c valoarea curentă,
verificăm proprietatea cerută, apoi transferăm în a valoarea lui b, în b valoarea lui c, iar în c citim
următoarea valoare din şir.
#include<stdio.h>
#include<conio.h>
void main()
{
int a,b,c;
while(a!=17 && b!=17)
{
printf("c="); scanf("%d",&c);
if(c==17) break;
if(c==a%b) printf("%d %d %d\n",a,b,c);
a=b; b=c;
}
getch();
}
31. Să se determine cel mai mic număr de cinci cifre care începe şi se termină cu aceeaşi cifră
nenulă şi pentru care restul împărţirii la un număr p este un număr r, numerele p şi r naturale
nenule date.
Observaţii:
Conform teoremei împărţirii cu rest, trebuie să determinăm cel mai mic număr de cinci cifre de
forma x=nr*p+r, unde cel mai mic cât posibil este nr=[10000/p]+1. Vom genera pe rând numerele
de această formă şi vom verifica dacă au prima şi ultima cifră egală. Primul număr cu acestă
proprietate este şi cel mai mic. Dacă numărul curent nu are proprietatea cerută, următorul număr
verificat este x=(nr+1)*p+r.
#include<stdio.h>
#include<conio.h>
void main()
{
int p,r,c1,c2,x,z,nr;
printf("p,r="); scanf("%d %d",&p,&r);
nr=10000/p+1;
while(1)
{
x=nr*p+r; z=x; c1=z%10; z/=10;
while(z)
{
c2=z%10; z/=10;
}
if(c1==c2)
{
printf("numarul cautat este %d\n",x);
break;
}
nr++;
}
getch();
}
32. Să se calculeze cifra de control a unui număr întreg. Cifra de control a unui număr întreg se
obţine prin efectuarea sumei cifrelor sale, apoi suma cifrelor acestei sume etc., până când se
obţine o sumă formată dintr-o singură cifră, numită cifră de control.
#include<stdio.h>
#include<conio.h>
void main()
{
unsigned long int n;
int s,c;
do{
s=0; //suma cifrelor numărului curent
while(n){
c=n%10; n/=10; s+=c;
}
n=s; //noul număr egal cu suma precedentă
}while(n>10);
//până obţinem un număr de o singură cifră
printf("cifra de control este %d\n",n);
getch();
}
33. Să se determine câte dintre numerele formate din n cifre, n dat, au cifra de control k, k dat.
Observaţii:
Toate cifrele de control pentru numere succesive parcurg circular mulţimea {1,2,..,9}. Numerele de
n cifre sunt cele aflate între 10n-1 şi 10n-1. Cifra de control a numărului 10n-1 este 1, a lui 10n-1 este
9 şi există 10n-10n-1=10n-1*9 astfel de numere. Dintre acestea 10 n-1*9/10 vor avea cifra de control
egală cu k. Deci răspunsul este 10n-2*9, adica se tipăreşte un 9 urmat de n-2 cifre de 0. Cazul n=1
se analizează separat.
#include<stdio.h>
#include<conio.h>
void main()
{
int n,i;
if(n==1) printf("1\n");
else
{
printf("9");
for(i=1;i<=n-2;i++) printf("0");
printf("\n");
}
getch();
}
34. Să se afişeze primele n numere prime (n<999) care citite invers sunt tot numere prime.
#include<stdio.h>
#include<conio.h>
void main()
{
int n,x,i,y,z,nr,ok,c;
//primele 4 numere prime le putem afişa direct
printf("2\t3\t5\t7\t");
nr=4; x=11;
//căutăm numerele prime >=11
while(nr<n)
{
ok=1; //verificăm dacă x este număr prim
for(i=2;i<=x/2;i++)
if(!(x%i)) {ok=0; break;}
if(ok) //x este număr prim
{
y=x; z=0;
//formăm în z numărul cu cifrele în
//ordine inversă
while(y)
{ c=y%10; y/=10; z=z*10+c; }
//verificăm dacă z este prim
for(i=2;i<=z/2;i++)
if(!(z%i))
{ ok=0; break;}
if(ok) //şi numărul invers este prim
{
printf("%d\t",x); //îl afişăm
nr++; //îl numărăm
}
}
x+=2; //trecem la următorul număr impar şi
//reluşm verificarea
}
getch();
}
35. Se citeşte un număr natural n care reprezintă numărul de valori naturale ce vor fi citite ulterior.
Să se determine cu câte zerouri se sfârşeşte produsul celor n numere, fără a efectua produsul
respectiv.
Observaţii:
Ştim că un număr se încheie cu 0 dacă este multiplu de 10, adică de 2 şi de 5 simultan. Este
suficient să determinăm la ce putere apare 2, respectiv 5, în cele n numere şi să considerăm
minimul dintre cele două valori. Acest minim va reprezenta numărul zerourilor cu care se încheie
produsul celor n numere.
#include<stdio.h>
#include<conio.h>
void main()
{
int n,x,nr2=0,nr5=0,i;
//nr2 este puterea lui 2, nr5 puterea lui 5
for(i=1;i<=n;i++)
{
printf("x%d=",i); scanf("%d",&x);
//determinăm puterea lui 2 în nr.ul curent x
while(!(x%2))
{ x/=2; nr2++; }
//determinăm puterea lui 5 în nr.ul curent x
while(!(x%5))
{ x/=5; nr5++; }
}
int min=nr2<nr5 ? nr2 : nr5;
printf("produsul celor %d numere se termina cu %d
zerouri\n",n,min);
getch();
}
36. Se citesc întâi două numere naturale n şi k şi apoi n numere reale. Să se verifice dacă, în
ordinea citirii, cele n numere sunt ordonate crescător până la al k-lea număr citit şi apoi
descrescător până la ultimul număr citit. Se va afişa un mesaj corespunzător.
#include<stdio.h>
#include<conio.h>
void main()
{
int n,k,i,x,y,ok=1;
printf("k="); scanf("%d",&k);
//citim primul număr din şir separat,în x
//citim următoarele k-1 numere
for(i=2;i<=k;i++)
{
//numărul curent se citeşte în y
if(y<x) ok=0; //nu sunt în ordine cresc.
x=y; //păstrăm y în x pentru pasul următor
}
//citim restul numerelor
for(i=k+1;i<=n;i++)
{
//numărul curent se citeşte în y
if(y>x) ok=0; //nu sunt în ordine descresc.
x=y; //păstrez y în x pentru pasul următor
}
if(ok)
printf("numerele au proprietatea ceruta\n");
else
printf("numerele nu au proprietatea
ceruta\n");
getch();
}
37. Să se scrie un program care să afişeze un meniu de forma:

1.suma numerelor
2.produsul numerelor
3.diferenţa numerelor
şi apoi să permită citirea a câte două numere întregi şi prelucrarea acestora conform opţiunii
introduse de utilizator, cât timp utilizatorul doreşte acest lucru.
Observaţii:
Pentru prelucrarea opţiunilor din meniu utilizăm o instrucţiune switch(). În cazul
împărţirii trebuie să verificăm dacă împărţitorul nu este nul. Ieşirea din bucla de
citire şi prelucrare se face cu un break atunci când introducem o opţiune de ieşire.
#include<stdio.h>
#include<conio.h>
void main()
{
int a,b;
char opt; //opţiunea utilizatorului
do{
printf("\n\t\tMeniu:\n");
printf("1- Adunarea numerelor\n");
printf("2- Inmultirea numerelor\n");
printf("3- Impartirea numerelor\n");
printf("4- Iesire\n");
printf("\nIntroduceti optiunea: ");
scanf("%d",&opt);
if(opt==4) break; //oprirea programului
printf("\nIntroduceti valorile a,b=");
scanf("%d %d",&a,&b);
switch(opt)
{
case 1: printf("\n\tsuma=%d\n",a+b);
break;
case 2: printf("\n\tprodusul=%d\n",
a*b);
break;
case 3: if(b)
printf("\n\tcatul=%.3f\n",
(float)a/b);
else
printf("\n\tImpartire
la 0!\n");
break;
}
}while(1);
getch();
}
38. Să se citească un număr întreg şi să se scrie acesta fără zerouri (în cazul în care printre
cifrele lui sunt şi zerouri).
#include<stdio.h>
#include<conio.h>
void main()
{
unsigned long n,inv=0;
char cifra;
printf("numarul n="); scanf("%lu",&n);
//extragem cifrele lui n şi formăm numărul invers
//fără zerouri
while(n)
{
cifra=n%10; n/=10;
if(cifra) //cifră nenulă
inv=inv*10+cifra;
}
//extragem cifrele din inv şi refacem numărul n
while(inv)
{
cifra=inv%10; inv/=10;
n=n*10+cifra;
}
printf("\nnumarul fara zerouri este %lu\n",n);
getch();
}
39. Să se găsească numărul de elemente din şirul lui Fibonacci cuprinse într-un interval [a,b] dat.
#include<stdio.h>
#include<conio.h>
void main()
{
int a,b,x=0,y=1,z,nr;
//nr=numarul termenilor din interval
//x=primul termen,y=al doilea termen Fibonacci
printf("intervalul [a,b]=");
scanf("%d %d",&a,&b);
if(a<=x) nr=2; //termenii 0 si 1
else
if(a<=y) nr=1; //termenul 1
else nr=0;
z=x+y; //următorul termen Fibonacci
while(z<=b)
{
if(z>=a) nr++; //termenul este în interval
x=y; y=z;
z=x+y;
}
printf("\n\tnumarul termenilor este %d\n",nr);
getch();
}
40. Se citesc pe rând n numere întregi. Să se determine valoarea maximă din şir şi să se
precizeze dacă este unică. În cazul în care nu este unică, să se determine numărul ei de
apariţii.
Observaţii:
Presupunem că prima valoare din şir este maximă, deci are o apariţie. Comparăm pe rând acest
maxim cu următoarele valori citite. Dacă valoarea citită este mai mare, am găsit un alt maxim.
Actualizăm valoarea maximă şi reiniţializăm numărul ei de apariţii cu 1. Dacă valoarea citită este
egală cu cea maximă, incrementăm numărul ei de apariţii.
#include<stdio.h>
#include<conio.h>
void main()
{
int n,x,max,nr; //nr=număr apariţii maxim
printf("numarul valorilor, n=");
scanf("%d",&n);
max=x; nr=1;
{
printf("x%d=",i); scanf("%d",&x);
if(max<x) //am găsit un nou maxim
{
max=x; nr=1;
}
else
if(max==x) nr++;
}
printf("\nmaximul este %d si ",max);
if(nr==1)
printf("este singular\n");
else
printf("apare de %d ori\n",nr);
getch();
}
41. Se citesc pe rând cifrele zecimale ale unui număr natural cu cel puţin 12 cifre. Să se
determine lungimile platourilor care apar în număr. Prin platou se înţelege o succesiune de
cifre egale. Spre exemplu, numărul 12333799025 conţine două platouri: 333 de lungime 3 şi
99 de lungime 2.
Observaţii:
Prima problemă care se ridică este modul de citire a datelor de intrare. Deoarece numărul cifrelor
este mare, valoarea nu poate fi stocată într-o variabilă de tip întreg. Vom trata cifrele numărului ca
pe un şir de caractere şi le vom citi în mod bufferat cu funcţia getchar(). Acest mod de citire ne
permite să afişăm rezultatele abia după ce am citit toate caracterele şi am apăsat Enter (bufferul
de intrare se goleşte). Citim prima cifră din şir separat. Ea face parte dintr-un platou a cărui
lungime k va fi cel puţin 1. Restul cifrelor le citim până la apăsarea tastei Enter (caracterul citit
fiind ‘\n’). Fiecare cifră y citită o comparăm cu cifra precedentă, păstrată în x. Dacă sunt egale
lungimea platoului curent creşte. Dacă sunt diferite, tocmai s-a încheiat un platou de lungime k
pentru cifra x şi începe un nou platou cu lungimea iniţială 1 pentru cifra y.
#include<stdio.h>
#include<conio.h>
void main()
{
char x,y,k;
//k este lungimea unui platou
//x este cifra citită la pasul anterior
//y este cifra curentă
printf("\tIntroduceti numarul:\n");
x=getchar(); //prima cifră
k=1;
while(x!='\n')
{
y=getchar(); //următoarea cifră
if(x==y)
k++;
//lungimea platoului curent creşte
else //s-a încheiat platoul precedent
{
if(k>1)
//are cel puţin două elemente
printf("\tplatou de lungime %d
pentru cifra %c\n",k,x);
k=1;
//începe un nou platou de lungime 1
}
x=y; //pentru pasul următor
}
if(k>1) //pentru ultima cifră
printf("\tplatou de lungime %d pentru cifra
%c\n",k,x);
getch();
}
42. Se citesc pe rând n numere întregi. Să se determine numărul maxim de elemente consecutive
aflate în ordine strict crescătoare.
Observaţii:
Algoritmul este asemănător cu cel de la problema anterioară. Primul element se citeşte separat. El
face parte dintr-o secvenţă crescătoare cu lungimea k cel puţin 1, care momentan este şi lungime
maximă. La fiecare pas se compară valoarea curentă citită y cu valoarea anterioară x. Dacă y>x
atunci lungimea secvenţei curente creşte. În caz contrar tocmai s-a încheiat o secvenţă strict
crescătoare (ultima ei valoare este x) de lungime k şi începe o nouă secvenţă (prima ei valoare
este y) de lungime 1. Pentru secvenţa anterioară verificăm dacă are lungimea k mai mare decât
maximul curent. În caz afirmativ actualizăm acest maxim. Pentru ultma valoare citită trebuie făcută
separat aceeaşi verificare.
#include<stdio.h>
#include<conio.h>
void main()
{
int n,x,y,max,k;
//x este valoarea citită la pasul anterior
//y este valoarea citită la pasul curent
//k este lungimea secvenţei strict crescătoare curentă

//max este lungimea maximă a unei astfel de secvenţe
printf("numarul valorilor, n=");
scanf("%d",&n);
k=max=1; //prima secvenţă conţine primul element
{
printf("x%d=",i);
scanf("%d",&y);
if(y>x)
k++;
//creşte lungimea secvenţei curente
else //s-a încheiat secvenţa anterioară
{
if(k>max) //o secvenţă mai lungă
max=k;
k=1; //noua secvenţă conţine elem. y
}
x=y; //pentru pasul următor
}
if(k>max) //pentru ultima valoare citită
printf("\n\tlungimea maxima este %d\n",k);
else
printf("\n\tlungimea maxima este %d\n",max);
getch();
}
43. Se citeşte de la tastatură un text, caracter cu caracter, până la apăsarea tastei Enter. Textul
este format din cuvinte separate prin unul sau mai multe spaţii. Să se numere cuvintele din
text.
Observaţii:
Considerăm un text corect sintactic, adică începe şi se termină cu un cuvânt. Citirea textului se
face caracter cu caracter, în mod bufferat, cu funcţia getchar(). Când se citeşte ‘\n’ (s-a apăsat
tasta Enter), citirea se încheie şi se afişează rezultatul. Ştiind că spaţiul separă două cuvinte, când
citim un spaţiu numărăm cuvântul care tocmai s-a încheiat. Deoarece pot fi mai multe spaţii între
cuvinte, le citim fără să le numărăm până când ajungem fie la prima literă din următorul cuvânt, fie
s-a apăsat Enter. Deoarece ultimul cuvânt se încheie cu Enter şi nu se mai numără, numărul real
al cuvintelor este mai mare cu 1.
#include<stdio.h>
#include<conio.h>
void main()
{
char c,nr=0;
printf("\tIntroduceti textul incheiat cu
Enter:\n");
while(1)
{
c=getchar();
if(c=='\n') break;
if(c==' ') nr++;
while(c==' ') c=getchar();
}
printf("\n\ttextul contine %d cuvinte\n",nr+1);
getch();
}
44. Se citesc mai multe caractere până la întâlnirea caracterului ')'. Verificaţi dacă expresia
formată din înlănţuirea acestor caractere reprezintă un număr zecimal periodic. În caz
afirmativ să se determine două numere întregi prime între ele al căror raport este chiar
numărul zecimal dat.
Observaţii:
Se reţin prin citirea caracter cu caracter trei numere importante: numărul reprezentând partea
întreagă (nr), numărul reprezentând partea zecimală neperiodică (zec) şi numărul reprezentând
partea zecimală periodică (per). Formula matematică de transformare a unui număr zecimal în
fracţie este:
unde cifra 9 apare de l ori şi cifra 0 de n ori.

#include<stdio.h>
#include<stdlib.h>
#include<conio.h>
void main()
{
unsigned char ok,c,n,l,j;
unsigned long nr,zec,per,f,nmr,nmt,deimp,imp,rest;
printf("\n\tIntroduceti un numar zecimal:\n");
nr=zec=per=n=l=0;
ok=1;
//citim partea întreagă a numărului
do{
c=getchar();
if(c>='0' && c<='9')
nr=nr*10+c-'0';
else
if(c=='.')
; //instrucţiune vidă
else
ok=0;
}while(c!='.' && c!=')');
if(!ok)
{
printf("\nexpresia nu este corecta!\n");
exit(0);
}
//citim partea zecimală neperiodică
do{
c=getchar();
if(c>='0' && c<='9')
{
zec=zec*10+c-'0'; n++;
//numărăm cifrele
}
else
if(c=='(')
else
ok=0;
}while(c!='(' && c!=')');
if(!ok)
{
exit(0);
}
//citim partea zecimală periodică
do{
c=getchar();
if(c>='0' && c<='9')
{
per=per*10+c-'0'; l++;
//numaram cifrele
}
else
if(c==')')
else
ok=0;
}while(c!=')');
if(!ok)
{
exit(0);
}
printf("\n\texpresia este corecta\n");
//nmt=numitorul nmr=numărătorul
f=1;
for(j=1;j<=l;j++) f*=10;
nmt=zec*f+per;
nmt-=zec; nmr=0;
for(j=1;j<=l;j++) nmr=nmr*10+9;
for(j=1;j<=n;j++)nmr*=10;
nmt+=nr*nmr; //introducerea întregilor în fracţie
deimp=nmt; imp=nmr; //alg. Euclid
rest=deimp%imp;
while(rest)
{
deimp=imp; imp=rest;
rest=deimp%imp;
}
nmt/=imp; nmr/=imp; //simplificarea
printf("%lu si %lu\n",nmt,nmr);
getch();
}
45. Se introduce de la tastatură un număr natural. Să se determine numărul minim şi numărul

maxim care se obţin prin eliminarea unei singure cifre din numărul dat.
Observaţii:
Pentru minim eliminăm prima cifră care este urmată de o cifră cu valoare mai mică (de la stânga
spre dreapta), iar pentru maxim pe cea urmată de o cifră mai mare (de la stânga la dreapta). În
cazul în care nu există o astfel de cifră, se elimină ultima cifră. Perechile de cifre se extrag şi se
studiază de la dreapta la stânga folosind cifra_curenta,cifra_prec.
#include<stdio.h>
#include<conio.h>
void main()
{
unsigned long n,nn,f;
unsigned char nr_cif,pmin,pmax,
i,cifra_curenta,cifra_prec;
do{
printf("introduceti un numar format din mai
multe cifre: ");
scanf("%lu",&n);
}while(n<=9);
nr_cif=0; nn=n;
//calculează numărul de cifre ale lui n
do{
nr_cif++; nn/=10;
}while(nn);
pmin=pmax=i=0; //rangul ultimei cifre
nn=n;
cifra_curenta=n%10;
cifra_prec=n%100/10;
while(nn>9)
{
if(cifra_curenta<cifra_prec)
pmin=i+1;
else
pmax=i+1;
nn/=10;
cifra_curenta=cifra_prec;
cifra_prec=nn%100/10;
i++;
}
f=1; for(i=1;i<=pmax;i++) f*=10;
printf("\nnumarul maxim este
%lu\n",n/(f*10)*f+n%f);
f=1; for(i=1;i<=pmin;i++) f*=10;
printf("\nnumarul minim este
%lu\n",n/(f*10)*f+n%f);
getch();
}
46. Se consideră două numere întregi. Să se stabilească dacă acestea sunt termeni consecutivi
în şirul Fibonacci.
Observaţii:
Plecăm de la numerele date şi calculăm elementele şirului înapoi după formula termen=diferenţa-
termenilor-imediat-următori. Dacă obţinem doi termeni succesivi
egali cu 1, răspunsul este DA, altfel este NU.
#include<stdio.h>
#include<conio.h>
void main()
{
long a,b,c;
printf("numarele a,b: ");
scanf("%ld %ld",&a,&b);
if(a>b)
{
c=a; a=b; b=c;
}
while(b>1)
{
c=b-a; b=a; a=c;
}
if(a==1 && b==1)
printf("\nDA\n");
else
printf("\nNU\n");
getch();
}
47. Se consideră un număr n scris în baza 10. Să se determine diferenţa dintre suma pătratelor
cifrelor ce constituie partea sa întreagă şi suma pătratelor cifrelor zecimale.
Observaţii:
Metoda de citire şi validare a corectitudinii numărului introdus este asemănătoare cu cea de la
problema 44.
#include<stdio.h>
#include<stdlib.h>
#include<conio.h>
void main()
{
unsigned s1=0,s2=0;
char c;
printf("\n\tIntroduceti un numar zecimal:\n");
c=getchar();
while(c!='.') //citim partea întreagă
{
if(c>='0' && c<='9')
s1+=(c-'0')*(c-'0');
else
{
printf("\nnumar eronat\n");
exit(0);
}
c=getchar();
}
c=getchar();
while(c!='\n') //citim partea zecimală
{
if(c>='0' && c<='9')
s2+=(c-'0')*(c-'0');
else
{
printf("\nnumar eronat\n");
exit(0);
}
c=getchar();
}
printf("\ndiferenta dintre %u si %u este
%d\n",s1,s2,s1-s2);
getch();
}
48. Se citesc pe rând de la tastatură mai multe caractere ce pot fi numai cifre nenule,unul din
operatorii '+','-','*','/' sau semnul '=', citirea făcându-se până la întâlnirea semnului '='. Se
consideră că şirul de caractere reprezintă o expresie corectă din punct de vedere matematic şi
că operaţiile se fac în ordinea în care sunt scrise. Să se afişeze valoarea acestei expresii.
#include<stdio.h>
#include<conio.h>
void main()
{
double val;
char c1,c2;
printf("\tIntroduceti expresia:\n");
//primul caracter trebuie sa fie o cifră
c1=getchar();
val=c1-'0'; //valoarea expresiei
while(1)
{
c1=getchar();
if(c1=='=') break;
c2=getchar();
switch(c1){
case '+': val+=c2-'0'; break;
case '-': val-=c2-'0'; break;
case '*': val*=c2-'0'; break;
case '/': val/=c2-'0'; break;
}
}
printf("\nvaloarea expresiei este %g\n",val);
getch();
}
B. Probleme propuse
1. Să se calculeze:
a) S=1+3+5+…+nr, unde nr este un număr impar mai mic sau cel mult egal cu n, n
număr natural nenul dat
b) P=1*3*5*….*nr, unde nr este un număr impar mai mic sau cel mult egal cu n, n
număr natural nenul dat
c) S=1+1/2+1/3+...+1/n, n număr natural nenul dat
d) S=1+1*2+1*2*3+….+1*2*..*n, n număr natural nenul dat

e) S=1+22+32+....+n2, n număr natural nenul dat
f) S=1+1/22+1/32+...+1/n2, n număr natural nenul dat
g) S=1+1/(1*2)+1/(1*2*3)+....+1/(1*2*...*n), n număr natural nenul dat
h) R=(1*2*...*n)/(1+2+...+n), n număr natural nenul dat
i) P=2*4*6*.....*nr, unde nr este un număr par mai mic sau cel mult egal cu n, n număr
natural nenul dat
2. Se dau două numere naturale a şi n. Să se calculeze an prin înmulţiri repetate.
3. Se citesc pe rând de la tastatură numere întregi nenule într-o variabilă x, până la introducerea
valorii 0. Să se calculeze suma numerelor pozitive introduse şi produsul celor negative.
4. Se consideră şirul 1,4,7,10,13,....Să se calculeze suma primilor n termeni, n număr natural
nenul dat.
5. Se citesc pe rând n numere dintr-un interval (a,b) dat. Să se determine media aritmetică a
valorilor strict pozitive introduse. Programul va valida încadrarea valorilor în intervalul deschis
(a,b) dat.
6. Se citesc pe rând n numere întregi şi apoi o valoare întreagă a. Să se determine numărul de
apariţii ale valorii a printre numerele citite.
7. Dându-se un număr natural n şi o valoare p, să se determine cifra aflată în număr pe poziţia
p, de la dreapta spre stânga. Dacă numărul conţine mai puţin de p cifre se va afişa un mesaj
corespunzător.
8. Să se genereze toate numerele de patru cifre de forma 3a2b care se divid cu numărul 9.
9. Se citeşte o succesiune de numere întregi până la introducerea valorii 0. Să se calculeze
media aritmetică a numerelor pozitive citite şi numărul numerelor negative.
10. Se citesc pe rând n numere întregi. Să se determine câte numere pare şi, respectiv, câte
numere impare au fost citite.
11. Se dă de la tastatură un număr natural n mai mic sau egal cu 5000. Se cere să se afişeze
numerele naturale mai mici sau egale cu n care au exact trei divizori proprii.
12. Se citesc pe rând numere întregi până la introducerea valorii –1. Să se calculeze media
aritmetică a valorilor nenule citite.
13. Se citesc pe rând n numere naturale nenule. Să se afişeze şi să se numere acele numere
pentru care suma cifrelor este divizibilă cu 5.
14. Se citesc pe rând n numere naturale mai mari ca 1. Să se determine c.m.m.d.c. al celor n
numere.
15. Se citesc numere naturale până la introducerea valorii 0. Să se afişeze toate tripletele de
numere citite consecutiv, în care al treilea număr este media aritmetică dintre primul şi al
doilea.
16. Se citesc numere naturale până la introducerea valorii 0. Să se afişeze toate perechile de
numere citite consecutiv, cu proprietatea că al doilea număr este egal cu suma cifrelor
primului număr.
17. Să se afişeze toate perechile de numere naturale citite consecutiv, cu proprietatea că al doilea
număr reprezintă restul împărţirii primului număr la suma cifrelor sale. Introducerea numerelor
se încheie cu 0.
18. Se citesc numere naturale până la introducerea valorii 13. Să se afişeze toate perechile de
numere citite consecutiv, cu proprietatea că al doilea număr reprezintă numărul de apariţii ale
cifrei 3 în pătratul primului număr.
19. Să se afişeze toate tripletele de numere citite consecutiv cu proprietatea că al treilea număr
este suma dintre primul şi al doilea. Introducerea datelor se încheie la introducerea a două
numere consecutive egale.
20. Se citesc numere reale pozitive până la introducerea valorii 0. Să se afişeze tripletele de
numere citite consecutiv cu proprietatea că ele pot reprezenta laturile unui triunghi: (a) isoscel,
(b) dreptunghic.
21. Să se afişeze toate numerele de forma a2+b3, cu 1<=a<=5 şi 1<=b<=5.
22. Să se afişeze toate numerele mai mici decât n (număr natural nenul dat), care au suma
cifrelor divizibilă cu 5.
23. Fiind dat un număr natural nenul n şi un număr prim p, să se stabilească la ce putere apare
factorul prim p în descompunerea numărului n dat.
24. Se dă ecuaţia de gradul al doilea ax2+bx+c=0 prin coeficienţii reali a,b,c. Să se calculeze
sumele Sn=x1n+x2n pentru n natural nenul dat, unde x1 şi x2 sunt rădăcinile ecuaţiei.
25. Se citeşte un număr natural cu maxim 9 cifre. Să se determine dacă este o putere a lui 2.
26. Se citesc numerele naturale nenule n şi k şi apoi n numere naturale. Să se afişeze acele
numere dintre cele n citite care au exact k divizori proprii.
27. Se citesc pe rând n numere reale. Să se calculeze şi să se afişeze raportul dintre suma
numerelor de rang impar şi suma numerelor de rang par după ordinea de citire.
28. Se citeşte un număr natural nenul n. Să se afişeze numerele perfecte mai mici sau egale cu
n. Un număr perfect a fost definit de Pitagora ca fiind un număr egal cu suma divizorilor proprii
plus 1. Exemplu: 6=1+2+3.
29. Cunoscând succesiunea 1,2,2,3,3,3,4,4,4,4,5,...să se precizeze valoarea elementului aflat pe
poziţia k dată, fără a citi sau construi efectiv succesiunea.
30. Să se verifice dacă un număr natural nenul dat este cub perfect fără a folosi funcţii
matematice de aproximare.
31. Pentru un număr natural nenul n dat, să se determine p natural cu proprietatea 2p<=n.
32. Să se determine aria unui triunghi ale cărui vârfuri au coordonatele carteziene numere întregi
citite de la tastatură.
33. Să se determine toate triunghiurile diferite cu laturile numere naturale şi perimetrul p dat.
34. Se citeşte un număr natural n. Să se calculeze produsul primelor n numere naturale dacă
acesta încape în reprezentarea shortint, iar dacă nu, să se afişeze până la ce valoare s-a
făcut calculul.
35. Să se scrie un program care rezolvă câte o ecuaţie de gradul doi de forma ax2+bx+c=0, dată
prin coeficienţii reali a,b,c până când programatorul nu mai doreşte acest lucru.
36. Se dă de la tastatură un număr natural nenul n<=1000000. Să se afişeze numărul de apariţii
ale cifrei 3 în numărul dat.
37. Se citesc de la tastatură numere naturale până la întâlnirea valorii 0. Să se afişeze perechile
de numere citite consecutiv cu proprietatea că al doilea număr este egal cu pătratul primului.
38. Se dă un dreptunghi prin coordonatele (x1,y1), (x2,y2) ale vârfurilor stânga-sus, respectiv
dreapta-jos. Laturile dreptunghiului sunt paralele cu axele de coordonate. Să se afişeze
perechile de numere întregi (x,y) care reprezintă coordonatele punctelor din interiorul
dreptunghiului.
39. Se consideră dreapta ax+by+c=0 dată prin coeficienţii săi întregi a,b,c şi o mulţime de n
perechi de numere întregi (x,y) ce reprezintă coordonatele carteziene a n puncte în plan. Să
se determine câte dintre aceste puncte aparţin dreptei date.
40. Să se verifice dacă trei puncte A,B,C ale căror coordonate numere întregi se citesc de la
tastatură sunt sau nu colineare.
41. Să se calculeze lungimilor laturilor unui dreptunghi având laturile paralele cu axele de
coordonate şi diagonala determinată de punctele M(a,b), N(c,d) cu a,b,c,d numere naturale
date.
42. Se dau coordonatele carteziene x1,y1 şi x2,y2 pentru două puncte A şi B din plan. Să se
determine lungimea segmentului format pe dreapta AB de punctele de intersecţie cu fiecare
din axele de coordonate. Programul trebuie să prevadă şi să soluţioneze şi cazurile limită.
43. Să se determine intersecţia a două intervale [a,b] şi [c,d] date prin numerele reale a,b,c,d şi
să se afişeze numerele întregi din intervalul de intersecţie, dacă acesta este nevid.
44. Să se afişeze numerele prime mai mici decât 100 făcând un număr cât mai mic de verificări.
45. Se citesc numere naturale până la întâlnirea valorii 0. Să se afişeze perechile de numere citite
consecutiv cu proprietatea că suma celor două numere este multiplu de 7.
46. Să se determine cel mai mare divizor propriu al unui număr natural n dat făcând un număr
minim de verficări.
47. Să se determine într-un mod eficient cel mai mare număr prim mai mic decât o limită m dată.
48. Se citesc de la tastatură diferite altitudini ale unui traseu turistic, numere reale strict pozitive.
Şirul valorilor se încheie la citirea valorii 0. Să se afişeze altitudinea minimă, maximă şi
numărul altitudinilor citite.
49. Se dau două numere naturale având acelaşi număr de cifre (maxim 9). Să se determine câte
cifre trebuie modificate pentru a transforma un număr în celălalt.
50. Se dau cifrele a două numere naturale x şi y, în ordinea crescătoare a rangului şi n, numărul
de cifre ale lui x, respectiv y. Cifrele se citesc în ordine de la tastatură, câte o cifră din fiecare
număr. Să se calculeze suma celor două numere şi să se afişeze rezultatul ca număr zecimal.
51. Se dă numărul natural nenul n. Să se determine cel mai mic număr par, obţinut din numărul
dat prin eliminarea uneia din cifrele sale. Exemplu: din 576, eliminăm 7 şi obţinem 56.
52. Să se determine toate palindroamele de n cifre care au suma cifrelor egală cu m, m şi n
numere naturale nenule date.
53. Se ştie că un număr natural n este deosebit dacă există un număr natural m astfel încât
n=m+S(m), unde S(m) este suma cifrelor lui m. Exemplu: pentru n=15, există m=12 astfel
încât 15=12+3. Să se determine toate numerele deosebite dintr-un interval [a,b] dat.
54. Scrieţi un program eficient care să afişeze toate pătratele perfecte mai mici sau egale cu n,
n<=109, număr natural nenul dat.
55. Se citesc de la tastatură n numere reale (n<=100000). Să se stabilească dacă toate numerele
citite se află sau nu în afara intervalului închis [a,b] dat.
56. Scrieţi un program eficient care să stabilească de câte ori apare o cifră nenulă c în scrierea
tuturor numerelor naturale mai mici sau egale cu un număr dat k. Cifra c şi valoarea k se
citesc de la tastatură.
57. Se citesc n numere întregi. Să se afişeze numerele libere de puteri. Un număr întreg se
numeşte liber de puteri dacă factorii primi din descompunerea sa nu apar la o putere mai
mare ca 1.
58. Să se determine la ce putere apare un număr k în descompunerea în factori primi a numărului
natural nenul n, k şi n date.
59. Să se găsească două numere naturale nenule a şi b, astfel încât cmmdc(a,b)=m şi
cmmmc(a,b)=n, unde m şi n sunt numere naturale date.
60. Se dă un număr par mai mare decât 4. Să se găsească toate modurile de a scrie acest număr
ca sumă de două numere impare prime (conjectura lui Goldbach).
61. Se citesc pe rând n valori întregi nenule. Să se determine cea mai mare valoare strict
negativă şi cea mai mică valoare strict pozitivă, precizându-se dacă sunt sau nu unice.
62. Se citesc pe rând n numere întregi. Să se determine lungimea platoului maxim. Prin platou se
înţelege un şir de valori egale citite consecutiv.
63. Se citesc pe rând n numere reale. Să se determine numărul maxim de valori nule citite
consecutiv.
64. Se citesc numere întregi până la introducerea valorii 0. Să se afişeze media armonică a
oricăror trei valori strict pozitive citite consecutiv.
65. Se citesc de la tastatură trei numere naturale f,a şi b (a<b), fiecare număr având cel mult trei
cifre. Să se afişeze o „tablă” cu toate înmulţirile de doi factori naturali dintre care unul este
obligatoriu f şi care dau ca rezultate numai numere cuprinse între a şi b inclusiv. Înmulţirile vor
fi afişate câte una pe linie, în ordinea crescătoare a rezultatelor. De exemplu, pentru f=5, a=8
şi b=25 se va afişa „tabla înmulţirilor cu 5” astfel:
2*5=10
3*5=15
4*5=20
5*5=25
66. Se citesc de la tastatură două numere naturale a şi b, fiecare număr având cel mult trei cifre.
Să se afişeze pe ecran, câte unul pe linie, toate numerele naturale din intervalul închis
determinat de a şi b care au suma cifrelor 15. Înţelegem prin interval închis determinat de
valorile a şi b intervalul închis [a,b] dacă a<=b sau intervalul închis [b,a] dacă b<=a.
Cap.4 Tablouri
4.1 Tablouri unidimensionale (vectori)
1. Fiind dat un şir de n numere reale să se determine valoarea maximă.
Observaţii:
Se foloseşte algoritmul cunoscut: se iniţializează maximul cu prima valoare din şir, apoi se
compară pe rând cu celelalte valori şi se actualizează (vezi metoda 6.3.2).
#include<stdio.h>
#include<conio.h>
#define N 50
void main()
{
int n,i;
float a[N],max;
printf("numarul de elemente,n=");
do{
scanf("%d",&n);
}while(n<1 || n>N);
printf("\tIntroduceti elementele vectorului:\n");
for(i=1;i<=n;i++)
{
printf("a[%d]=",i);
scanf("%f",&a[i]);
}
printf("\n\n\tVectorul introdus este:\n");
for(i=1;i<=n;i++)
printf("%.3f ",a[i]);
printf("\n\n");
max=a[1];
for(i=2;i<=n;i++)
if(max<a[i]) max=a[i];
printf("valoarea maxima este %.3f\n",max);
getch();
}
2. Fiind dat un şir de n numere întregi să se determine primul element divizibil cu un număr
natural nenul k dat şi poziţia în care apare în şir.
Observaţii:
Se foloseşte metoda descrisă la 6.3.3 (determinarea primului element cu o anumită proprietate),
căutarea făcându-se de la stânga spre dreapta, fie până găsim primul element cu proprietatea
cerută, fie epuizăm elementele vectorului.
#include<stdio.h>
#include<conio.h>
#define N 50
void main()
{
int n,i,a[N],k,poz=0;
do{
scanf("%d",&n);
}while(n<1 || n>N);
for(i=1;i<=n;i++)
{
printf("a[%d]=",i);
scanf("%d",&a[i]);
}
printf("\n\n\tVectorul introdus este:\n\n");

for(i=1;i<=n;i++)
printf("%d ",a[i]);
printf("\n\n");
printf("k="); scanf("%d",&k);
//parcurgem vectorul de la stanga spre dreapta
for(i=1;i<=n;i++)
if(!(a[i]%k))
{
poz=i; break;
//a[i] este primul element divizil cu k
}
if(poz)
printf("\nprimul element divizibil cu %d este
%d si apare in pozitia %d\n",k,a[poz],poz);
else
printf("\nnu exista nici-un element divizibil
cu %d\n",k);
getch();
}
3. Fiind dat un şir de n numere naturale nenule să se determine ultimul număr prim din şir şi
poziţia în care apare.
Observaţii:
Se foloseşte metoda descrisă la 6.3.4 (determinarea ultimului element cu o anumită proprietate),
căutarea făcându-se de la dreapta spre stânga până găsim primul element prim sau epuizăm
elementele vectorului.
#include<stdio.h>
#include<stdlib.h>
#include<math.h>
#include<conio.h>
#define N 50
void main()
{
int n,i,a[N],k,poz=0,ok;
do{
scanf("%d",&n);
}while(n<1 || n>N);
for(i=1;i<=n;i++)
{
printf("a[%d]=",i);
scanf("%d",&a[i]);
}
for(i=1;i<=n;i++)
printf("%d ",a[i]);
printf("\n\n");
//parcurgem şirul de la dreapta spre stânga
for(i=n;i>=1;i--)
{
ok=1;
//verificăm dacă i este număr prim
for(k=2;k<=sqrt(a[i])+1;k++)
if(!(a[i]%k)) //a[i] nu este prim
{
ok=0; break;
//abandonăm verificarea şi trecem
//la următorul număr
}
if(ok) //a[i] este ultimul număr prim
{
poz=i;break;
}
}
if(poz)
printf("\nultimul element prim este %d si
apare in pozitia %d\n",a[poz],poz);
else
printf("\nnu exista nici-un element prim\n");
getch();
}
4. Dându-se un vector de n numere reale, să se scrie un program care elimină elementele nule
din şir fără a utiliza memorie suplimentară.
Observaţii:
Se foloseşte metoda descrisă la 6.3.5 (eliminarea tuturor elementelor cu o anumită proprietate),
valorile nenule „îngrămădindu-le” la începutul vectorului.
#include<stdio.h>
#include<conio.h>
#define N 50
void main()
{
int n,i,j=0;
float a[N];
do{
scanf("%d",&n);
}while(n<1 || n>N);
for(i=1;i<=n;i++)
{
printf("a[%d]=",i);
scanf("%f",&a[i]);
}
for(i=1;i<=n;i++)
printf("\n\n");
for(i=1;i<=n;i++)
if(a[i]) //element nenul
a[++j]=a[i];
//îl mutăm la începtul vectorului
n=j; //actualizăm numărul de elemente
printf("\tVectorul obtinut este:\n\n");
for(i=1;i<=n;i++)
printf("\n\n");
getch();
}
5. Fiind dat un şir de n numere întregi, să se elimine din şir primul element care are suma cifrelor
divizibilă cu 3. Dacă nu există nici-un element cu proprietatea cerută, să se elimine din şir
primul element.
Observaţii:
Se combină algoritmul de determinare a primului element cu o proprietate dată cu algoritmul de
eliminare a elementului dintr-o poziţie k dată (vezi 6.3.3 şi 6.3.6).
#include<stdio.h>
#include<conio.h>
#define N 50
void main()
{
int n,i,a[N],x,s,k=1;
do{
scanf("%d",&n);
}while(n<1 || n>N);
for(i=1;i<=n;i++)
{
printf("a[%d]=",i);
scanf("%d",&a[i]);
}
for(i=1;i<=n;i++)
printf("%d ",a[i]);
printf("\n\n");
//parcurgem vectorul de la stânga spre dreapta
for(i=1;i<=n;i++)
{
//calculăm suma cifrelor lui a[i]
x=a[i]; //lucrăm cu copia lui a[i]
s=0; //suma cifrelor
while(x)
{
s+=x%10;
x/=10;
}
if(!(s%3))
//suma cifrelor este divizibilă cu 3
{
k=i; break; //am găsit primul număr
}
}
if(k!=1)
printf("\nprimul numar cu suma cifrelor
divizibila cu 3 este %d\n",a[k]);
else
printf("\nnu exista numar cu suma cifrelor
divizibila cu 3\n");
//eliminăm din şir elementul din poziţia k
for(i=k;i<=n-1;i++)
a[i]=a[i+1];
n--; //corectăm lungimea
printf("\n\tVectorul obtinut dupa eliminare
este:\n\n");
for(i=1;i<=n;i++)
printf("%d ",a[i]);
printf("\n"); getch();
}
6. Fiind dat un şir de n numere întregi, să se determine poziţia în care apare ultimul număr
palindromic şi apoi să se insereze în şir, în respectiva poziţie, o valoare x citită de la tastatură.
Dacă şirul nu conţine nici-un număr palindromic să se adauge valoarea x la sfârşitul şirului.
Observaţii:
Se combină algoritmul de determinare a ultimului element cu o anumită proprietate (6.3.4) cu
algoritmul de inserare a unei noi valori în poziţia k dată (6.3.7).
#include<stdio.h>
#include<conio.h>
#define N 50
void main()
{
int n,i,a[N],x,inv,k;
do{
scanf("%d",&n);
}while(n<1 || n>N);

for(i=1;i<=n;i++)
{
printf("a[%d]=",i);
scanf("%d",&a[i]);
}
for(i=1;i<=n;i++)
printf("%d ",a[i]);
printf("\n\n");
//parcurgem vectorul de la dreapta spre stânga
k=n+1;
for(i=n;i>=1;i--)
{
//verificăm dacă a[i] este palindrom
x=a[i]; //lucrăm cu copia lui a[i]
inv=0; //nr.-ul cu cifrele în ordine inversă
while(x)
{
inv=inv*10+x%10;
x/=10;
}
if(inv==a[i]) //este palindrom
{
k=i; break;
} //oprim căutarea
}
if(k!=n+1)
printf("\nultimul numar palindromic este
%d\n",a[k]);
else
printf("\nsirul nu contine nici-un numar
palindromic\n");
printf("\nvaloarea inserata,x="); scanf("%d",&x);
//inserăm x în poziţia k
for(i=n+1;i>=k+1;i--)
a[i]=a[i-1];
a[k]=x; n++; //inserăm x şi corectăm lungimea
printf("\n\tVectorul obtinut dupa inserare
este:\n\n");
for(i=1;i<=n;i++)
printf("%d ",a[i]);
}
7. Fiind dat un şir de n numere reale, să se permute circular numerele cu x poziţii spre dreapta,
apoi cu y poziţii spre stânga, unde x şi y sunt numere naturale nenule, mai mici decât n şi
diferite între ele citite de la tastatură. Se va afişa şirul obţinut după fiecare operaţie.
Observaţii:
Se folosesc algoritmii descrişi în secţiunile 6.3.8 şi 6.3.9, repetaţi de y, respectiv de x ori.
#include<stdio.h>
#include<conio.h>
#define N 50
void main()
{
int n,i,x,y,k;
float a[N],aux;
do{
scanf("%d",&n);
}while(n<1 || n>N);
for(i=1;i<=n;i++)
{
printf("a[%d]=",i);
scanf("%f",&a[i]);
}
for(i=1;i<=n;i++)
printf("\n\n");
printf("x,y=");
do{
scanf("%d %d",&x,&y);
}while(x<1 || x>=n || y<1 || y>=n || x==y);
//permutăm întâi spre dreapta circular cu x poziţii
for(k=1;k<=x;k++)
{
aux=a[n];
for(i=n;i>=2;i--)
a[i]=a[i-1];
a[1]=aux;
}
printf("\n\tVectorul obtinut dupa %d permutari
circulare spre dreapta:\n\n",x);
for(i=1;i<=n;i++)
printf("\n");
//permutăm spre stânga circular cu y poziţii
for(k=1;k<=y;k++)
{
aux=a[1];
for(i=1;i<=n-1;i++)
a[i]=a[i+1];
a[n]=aux;
}
printf("\n\tVectorul obtinut dupa %d permutari
circulare spre stanga:\n\n",y);
for(i=1;i<=n;i++)
}
8. Fiind dat un şir de n valori reale, să se ordoneze crescător folosind metoda bubblesort.
Observaţii:
Se foloseşte algoritmul descris în secţiunea 6.3.10 A.
#include<stdio.h>
#include<conio.h>
#define N 50
void main()
{
int n,i,k,ok;
float a[N],aux;
do{
scanf("%d",&n);
}while(n<1 || n>N);
for(i=1;i<=n;i++)
{
printf("a[%d]=",i);
scanf("%f",&a[i]);
}
for(i=1;i<=n;i++)
printf("\n\n");
k=n;
do{
ok=0;
for(i=1;i<k;i++)
if(a[i]>a[i+1])
{
aux=a[i]; a[i]=a[i+1];
a[i+1]=aux; ok=1;
}
k--;
}while(ok);
printf("\n\tVectorul ordonat crescator este:\n\n");
for(i=1;i<=n;i++)
}
9. Fiind dat un şir de n valori reale, să se ordoneze descrescător folosind sortarea prin selecţie
directă.
Observaţii:
Se foloseşte algoritmul descris în secţiunea 6.3.10 B.
#include<stdio.h>
#include<conio.h>
#define N 50
void main()
{
int n,i,j;
float a[N],aux;
do{
scanf("%d",&n);
}while(n<1 || n>N);
for(i=1;i<=n;i++)
{
printf("a[%d]=",i);
scanf("%f",&a[i]);
}
for(i=1;i<=n;i++)
printf("\n\n");
for(i=1;i<n;i++)
for(j=i+1;j<=n;j++)
if(a[i]<a[j])
{
aux=a[i]; a[i]=a[j];
a[j]=aux;
}
printf("\n\tVectorul ordonat crescator este:\n\n");
for(i=1;i<=n;i++)
}
10. Fiind dat un şir de n numere întregi distincte şi o valoare întreagă x, să se verifice dacă x
apare în şir şi pe ce poziţie. Dacă şirul de valori nu este ordonat, să se ordoneze şi apoi să se
folosească algoritmul de căutare binară.
Observaţii:
Pentru căutarea binară se foloseşte algoritmul descris în secţiunea 6.3.11, iar dacă şirul nu este
ordonat, se ordonează folosind metoda B (ordonarea prin selecţie directă).
#include<stdio.h>
#include<stdlib.h>
#include<conio.h>
#define N 50
void main()
{
int n,i,j,a[N],x,p,q,mij,aux,ok=1;
do{
scanf("%d",&n);
}while(n<1 || n>N);
for(i=1;i<=n;i++)
{
printf("a[%d]=",i);
scanf("%d",&a[i]);
}
for(i=1;i<=n;i++)
printf("%d ",a[i]);
printf("\n\n");
printf("valoarea cautata,x=");
scanf("%d",&x);
//verificăm dacă vectorul este ordonat crescător
for(i=1;i<n;i++)
if(a[i]>a[i+1])
{
ok=0; break; //şirul nu este ordonat
}
if(!ok) //ordonăm şirul crescător
{
printf("\n\nsirul initial nu a fost
ordonat!\n");
for(i=1;i<n;i++)
for(j=i+1;j<=n;j++)
if(a[i]>a[j])
{
aux=a[i];
a[i]=a[j];
a[j]=aux;
}
printf("\n\tVectorul dupa ordonare:\n\n");
for(i=1;i<=n;i++)
printf("%d ",a[i]);
printf("\n\n");
}
//aplicăm algoritmul de căutare binară
p=1; q=n;
while(p<=q)
{
mij=(p+q)/2;
if(a[mij]==x)
{
printf("\nvaloarea %d apare in sir in
pozitia %d\n",x,mij);
exit(0);
}
else
if(x<a[mij])
q=mij-1;
else
p=mij+1;
}
printf("\nvaloarea %d nu apare in sir\n",x);

getch();
}
11. Fiind date două şiruri de numere întregi cu m, respectiv n elemente, să se interclaseze cele
două şiruri folosind santinele. Dacă cele două şiruri nu sunt ordonate, se vor ordona folosind
sortarea prin selecţie directă.
Observaţii:
Pentru interclasare se foloseşte algoritmul de interclasare cu santinele prezentat în secţiunea
6.3.12.
#include<stdio.h>
#include<conio.h>
#define N 100
void main()
{
int a[N],b[N],c[N],m,n,i,j,k,ok,aux;
printf("cate elemente are primul vector? ");
do{
scanf("%d",&m);
}while(m<1 || m>N);
printf("\n\tIntroduceti elementele primului
vector:\n\n");
for(i=1;i<=m;i++)
{
printf("a[%d]=",i);
scanf("%d",&a[i]);
}
printf("\ncate elemente are al doilea vector? ");
do{
scanf("%d",&n);
}while(n<1 || n>N);
printf("\n\tIntroduceti elementele pentru al doilea
vector:\n\n");
for(i=1;i<=n;i++)
{
printf("b[%d]=",i);
scanf("%d",&b[i]);
}
//verificăm dacă vectorul a este ordonat crescător
ok=1;
for(i=1;i<m;i++)
if(a[i]>a[i+1]) //nu este ordonat crescător
{
ok=0; break;
}
if(!ok)
{
//ordonăm crescător vectorul a
printf("\nVectorul a nu este ordonat
crescator!\n");
for(i=1;i<m;i++)
for(j=i+1;j<=m;j++)
if(a[i]>a[j])
{
aux=a[i]; a[i]=a[j];
a[j]=aux;
}
printf("\n\tVectorul a dupa ordonare:\n\n");
for(i=1;i<=m;i++)
printf("%d ",a[i]);
printf("\n\n");
}
//verificăm dacă vectorul b este ordonat crescător
ok=1;
for(i=1;i<n;i++)
if(b[i]>b[i+1]) //nu este ordonat crescător
{
ok=0; break;
}
if(!ok)
{
//ordonăm crescător vectorul b
printf("\nVectorul b nu este ordonat
crescator!\n");
for(i=1;i<n;i++)
for(j=i+1;j<=n;j++)
if(b[i]>b[j])
{
aux=b[i]; b[i]=b[j];
b[j]=aux;
}
printf("\n\tVectorul b dupa ordonare:\n\n");
for(i=1;i<=n;i++)
printf("%d ",b[i]);
printf("\n\n");
}
//adăugăm santinelele
a[m+1]=b[n]+1; b[n+1]=a[m]+1;
i=1; j=1;
//interclasăm vectorii
for(k=1;k<=m+n;k++)
if(a[i]<b[j])
c[k]=a[i++];
else
c[k]=b[j++];
printf("\n\tVectorul obtinut dupa
interclasare:\n\n");
for(i=1;i<=m+n;i++)
printf("%d ",c[i]);
}
12. Să se scrie un program care citeşte un şir de n întregi şi afişează elementele pare situate pe
poziţii impare ale şirului precum şi numărul acestora.
#include<stdio.h>
#include<conio.h>
#define N 50
void main()
{
int n,i,a[N],k=0;
do{
scanf("%d",&n);
}while(n<1 || n>N);
for(i=1;i<=n;i++)
{
printf("a[%d]=",i);
scanf("%d",&a[i]);
}
for(i=1;i<=n;i++)
printf("%d ",a[i]);
printf("\n\n");
//parcurgem elementele situate pe poziţii impare
for(i=1;i<=n;i+=2)
if(!(a[i]%2)) //este par

k++; //numărăm elementele pare
printf("\nVectorul contine %d elemente pare situate
pe pozitii impare\n",k);
getch();
}
13. Să se scrie un program care citeşte n numere întregi şi afişează valorile distincte din şir fără a
folosi memorie suplimentară.
Observaţii:
Pentru a reţine în vector numai valorile distincte se foloseşte un algoritm asemănător cu cel
descris în secţiunea 6.3.5. Valorile distincte se mută la începutul vectorului, pe poziţii succesive.
Primul element îşi păstrează poziţia astfel încât verificările se fac începând cu al doilea element.
Numărul curent al valorilor distincte mutate la începutul vectorului este k (iniţial are valoarea 1
pentru că a[1] îşi păstrează poziţia).
#include<stdio.h>
#include<conio.h>
#define N 50
void main()
{
int n,i,a[N],k=1,j,ok;
//k este numărul valorilor distincte
do{
scanf("%d",&n);
}while(n<1 || n>N);
for(i=1;i<=n;i++)
{
printf("a[%d]=",i);
scanf("%d",&a[i]);
}
for(i=1;i<=n;i++)
printf("%d ",a[i]);
printf("\n\n");
for(i=2;i<=n;i++)
{
ok=1; //presupunem că a[i] este distinct
for(j=1;j<=k;j++)
if(a[i]==a[j]) //se repetă
{
ok=0; break;
}
if(ok) //este distinct
a[++k]=a[i];
//îl mutăm la începutul vectorului
}
printf("\n\tValorile distincte din sir sunt:\n\n");
for(i=1;i<=k;i++)
printf("%d ",a[i]);
}
14. Scrieţi un program care citeşte cele n elemente ale unui vector de numere reale şi determină
minimul acestor elemente precum şi poziţia (poziţiile) în care acesta apare în vector.
Observaţii:
Pentru determinarea minimului s-a iniţializat valoarea variabilei corespunzătoare cu o valoare
foarte mare (231-1) astfel încât orice valoare din vector să-l actualizeze corect. Pentru a determina
toate poziţiile în care apare minimul se mai foloseşte un vector poz. Când găsim în vector un
element egal cu minimul curent, indicele elementului respectiv se memorează în poz în
următoarea poziţie liberă. Când se găseşte o valoare mai mică decât minimul curent, se şterg
toate poziţiile memorate în poz (indicele lui curent devine 0) şi se memorează poziţia noului
minim.
#include<stdio.h>
#include<conio.h>
#define N 50
void main()
{
int poz[N],n,i,j=0;
float a[N],min=1<<31-1;
do{
scanf("%d",&n);
}while(n<1 || n>N);
for(i=1;i<=n;i++)
{
printf("a[%d]=",i);
scanf("%f",&a[i]);
}
for(i=1;i<=n;i++)
printf("\n\n");
for(i=1;i<=n;i++)
if(a[i]<min)
{
min=a[i]; j=0; //un nou minim
poz[++j]=i;
}
else
if(min==a[i])
poz[++j]=i;
//o nouă apariţie a minimului curent
printf("\nminimul este %.3f si se gaseste in
pozitiile: ",min);
for(i=1;i<=j;i++)
printf("%d ",poz[i]);
}
15. Fiind dat un şir de numere reale cu n elemente, să se afle numărul de ordine al primului şi,
respectiv ultimului element nul întâlnit.
Observaţii:
Pentru rezolvarea problemei se parcurge vectorul simultan din ambele capete folosind doi indici:
prim iniţial egal cu 1 şi ultim iniţial egal cu n. Indicele prim creşte iar indicele ultim scade fie
până găsim cele două (unul) elemente nule, fie până când prim devine mai mare decât ultim,
semn că am inspectat fără succes toate elementele vectorului.
#include<stdio.h>
#include<conio.h>
#define N 50
void main()
{
int n,i,prim,ultim;
float a[N];
do{
scanf("%d",&n);
}while(n<1 || n>N);
for(i=1;i<=n;i++)
{
printf("a[%d]=",i);
scanf("%f",&a[i]);
}
for(i=1;i<=n;i++)
printf("\n\n");
//parcurgem şirul simultan din ambele capete
prim=1; ultim=n;
do{
if(a[prim]) prim++;
if(a[ultim]) ultim--;
if(prim>ultim) break;
}while(a[prim] || a[ultim]);
if(prim>ultim)
printf("\nsirul nu contine nici un
zero\n\n");
else
{
printf("\nprimul 0 apare in pozitia
%d\n\n",prim);
printf("\nultimul 0 apare in pozitia
%d\n\n",ultim);
}
getch();
}
16. Citiţi un şir de n valori întregi şi inversaţi ordinea elementelor din şir.
Observaţii:
Pentru rezolvarea problemei este suficient să interschimbăm elementele egal depărtate de
mijlocul vectorului. Elementul din mijloc are indicele [n/2] iar perechea de elemente simetrice este
a[i] , a[n-i+1].
#include<stdio.h>
#include<conio.h>
#define N 50
void main()
{
int n,i,a[N],aux;
do{
scanf("%d",&n);
}while(n<1 || n>N);
for(i=1;i<=n;i++)
{
printf("a[%d]=",i);
scanf("%d",&a[i]);
}
for(i=1;i<=n;i++)
printf("%d ",a[i]);
printf("\n\n");
//inversăm ordinea elementelor egal depărtate de
// mijlocul şirului
for(i=1;i<=n/2;i++)
{
aux=a[i]; a[i]=a[n-i+1];
a[n-i+1]=aux;
}
printf("\n\n\tVectorul inversat este:\n\n");
for(i=1;i<=n;i++)
printf("%d ",a[i]);
}
17. Generaţi numerele prime din intervalul [2,n], unde n este un număr natural introdus de
utilizator, după metoda numită „ciurul lui Eratostene”.
Observaţii:
Metoda matematică constă în: se umple „ciurul” (vectorul) cu toate numerele de la 2 la n. Primul
număr din şir (2) este prim. Se elimină din şir toţi multiplii de 2 transformând elementele respective
în 0. Următorul număr nenul din şir (3) este prim. Se elimină din şir toţi multiplii de 3 s.a.m.d. În
final, numerele nenule rămase sunt toate numere prime.
#include<stdio.h>
#include<conio.h>
#define N 2000
void main()
{
unsigned a[N],n,i,j;
printf("numarul n=");
do{
scanf("%d",&n);
}while(n<=2 || n>N);
for(i=2;i<=n;i++) a[i]=i;
//numerele din intervalul [2,n]
for(i=2;i<=n/2;i++)
if(a[i]) //a[i] este număr prim
//ştergem din vector toţi multiplii lui a[i]
for(j=2*i;j<=n;j+=i) a[j]=0;
printf("\n\tNumerele prime din intervalul [2,%d]
sunt:\n\n",n);
for(i=2;i<=n;i++)
if(a[i]) printf("%d ",a[i]);
}
18. Să se calculeze valoarea polinomului P(x) de grad n şi coeficienţi reali daţi, pentru o valoare x
dată folosind „gruparea lui Horner”. Coeficienţii polinomului sunt memoraţi vectorial.
Observaţii:
Prin această metodă coeficienţii polinomului sunt luaţi în considerare în ordinea descrescătoare a
puterilor lui x. Metoda evită ridicarea la putere a argumentului x folosind formula de calcul
iterativă: Pi(x)=Pi-1(x)*x+an-i
#include<stdio.h>
#include<conio.h>
#define N 20
void main()
{
int n,i;
double a[N],x,P=0;
printf("gradul polinomului,n=");
do{
scanf("%d",&n);
}while(n<0 || n>N);
desrescatoare a puterilor lui X:\n\n");
for(i=n;i>=0;i--)
{
printf("a[%d]=",i);
scanf("%lf",&a[i]);
}
printf("\npunctul x=");
scanf("%lf",&x);
printf("\n\tPolinomul dat este:\n\n");
printf("P(x)=");
for(i=n;i>=0;i--)
printf("%+g*x^%d ",a[i],i);
printf("\n\n");
for(i=n;i>=0;i--)
P=P*x+a[i];
printf("P(%g)=%g\n\n",x,P); getch(();
}
19. Se dă un vector x cu n (1<=n<=100) componente numere naturale cu cel mult nouă cifre. Se
cere să se afişeze numărul cel mai mare format cu prima cifră a fiecărei componente din x.
Exemplu: pentru n=4 şi x=(2341, 789, 1998, 2000) se va afişa 7221.
Observaţii:
Extragem prima cifră din fiecare număr şi o memorăm într-un vector. Sortăm acest vector
descrescător şi obţinem cel mai mare număr.
#include<stdio.h>
#include<conio.h>
void main()
{
int x[100],c[100],n,i,j,aux,cifra,y;
for(i=1;i<=n;i++)
{
printf("x[%d]=",i); scanf("%d",&x[i]);
}
for(i=1;i<=n;i++)
{
y=x[i]; //folosim o copie a numărului
while(y)
{ cifra=y%10;
y/=10;
}
c[i]=cifra; //este prima cifră din număr
}
//ordonăm crescător vectorul c
for(i=1;i<=n-1;i++)
for(j=i+1;j<=n;j++)
if(c[i]<c[j])
{
aux=c[i]; c[i]=c[j]; c[j]=aux;
}
printf("\n Cel mai mare numar posibil este ");
for(i=1;i<=n;i++) printf("%d",c[i]);
}
20. Se dau două mulţimi prin intermediul a doi vectori, x şi y, cu n (1<=n<=100) componente
întregi. Se cere să se verifice dacă aceste mulţimi sunt proporţionale. În caz afirmativ se va
afişa şi şirul de rapoarte egale.
Observaţii:
Observând proprietăţile matematice ale numerelor care formează un şir de rapoarte egale, vom
constata că dacă numitorii sunt în ordine crescătoare, atunci şi numărătorii sunt tot în ordine
crescătoare. Deci ordonăm elementele celor două mulţimi şi formăm perechile corespunzătoare
pentru a verifica proporţionalitatea directă.
#include<stdio.h>
#include<math.h>
#include<conio.h>
void main()
{
int a[50],b[50],n,i,j,aux,dir=1;
float rap,t;
printf("\t Prima multime:\n");
for(i=1;i<=n;i++)
{
printf("a[%d]=",i); scanf("%d",&a[i]);
}
printf("\t A doua multime:\n");
for(i=1;i<=n;i++)
{
printf("b[%d]=",i); scanf("%d",&b[i]);
}
//ordonăm crescător numărătorii
for(i=1;i<=n-1;i++)
for(j=i+1;j<=n;j++)
if(a[i]>a[j])
{
aux=a[i]; a[i]=a[j]; a[j]=aux;
}
//ordonăm crescător numitorii
for(i=1;i<=n-1;i++)
for(j=i+1;j<=n;j++)
if(b[i]>b[j])
{
aux=b[i]; b[i]=b[j]; b[j]=aux;
}
rap=(float)a[1]/b[1]; //valoarea raportului
for(i=2;i<=n;i++)
{
t=(float)a[i]/b[i];
//fiind vorba de valori reale reprezentate
//intern prin aproximare,putem considera
//două valori ca fiind egale dacă diferenţa
//lor în modul este mai miîa decât 0.00001 //(de
exemplu);în acest fel se evită erorile
//ce pot apărea la evaluarea egalităţii //numerelor reale
if(fabs(t-rap)>1e-5)
{ dir=0; break; }
}
if(!dir)
printf("multimile nu sunt direct
proportionale\n");
else
{
printf("multimile sunt direct proportionale;
sirul de rapoarte egale este:\n");
for(i=1;i<=n;i++)
printf("%d/%d=",a[i],b[i]);
printf("%g\n",rap);
}
getch();
}
21. Se dau două numere naturale în baza 2 prin intermediul a doi vectori, x şi y, cu m, respectiv n
componente binare (1<=n,m<=100). Fără a trece numerele în baza 10, să se determine suma
celor două numere (tot în baza 2). Cifrele numerelor sunt date în ordinea descrescătoare a
puterilor lui 2.
Observaţii:
Completăm numărul mai scurt cu zerouri la stânga pentru a aduce cele două numere la aceeaşi
lungime, apoi adunăm cele două numere cifră cu cifră, de la dreapta la stânga ţinând cont de
transport.
#include<stdio.h>
#include<conio.h>
void main()
{
int x[50],y[50],z[50],m,n,i,j,t,max,st=1;
printf("m="); scanf("%d",&m);
for(i=1;i<=m;i++)
{
}
for(i=1;i<=n;i++)
{
printf("y[%d]=",i); scanf("%d",&y[i]);
}
max=m>n? m: n; //lungimea maximă a numerelor
t=max-m; //câte cifre 0 trebuie adăugate la x
for(i=1;i<=t;i++)
{
//deplasăm vectorul x spre dreapta cu t
//poziţii şi inserăm t zerouri la început
for(j=m+1;j>=2;j--) x[j]=x[j-1];
x[1]=0; m++;
}
t=max-n; //câte cifre 0 trebuie adăugate la y
for(i=1;i<=t;i++)
{
//deplasăm vectorul y spre dreapta cu t
//poziţii şi inserăm t zerouri la început
for(j=n+1;j>=2;j--) y[j]=y[j-1];
y[1]=0; n++;
}
t=0; //transportul iniţial către rangul superior
for(i=max;i>=1;i--)
{
z[i]=(x[i]+y[i]+t)%2;
t=(x[i]+y[i]+t)/2; //transportul curent
}
if(t==1) //suma numerelor are max+1 cifre
{ z[0]=1; st=0; } //prima cifră este in z[0]
printf("\n\t Suma celor doua numere este:\n");
for(i=st;i<=max;i++) printf("%d",z[i]);
}
22. Se dă un vector cu n (1<=n<=100) componente naturale. Să se afişeze cea mai lungă

secvenţă formată din elemente consecutive în ordine crescătoare. Exemplu: pentru n=7 şi
vectorul 2, 33, 1, 4, 5, 3, 12 se va afişa 1, 4, 5.
Observaţii:
Pentru a putea analiza şi ultima secvenţă din vector, vom adăuga elementul a[n+1]=a[n]. Primul
element face parte dintr-o secvenţă care iniţial are lungimea 1. La fiecare pas comparăm
elementul curent a[i] cu elementul precedent a[i-1]. Dacă este mai mare, secvenţa îşi păstrează
monotonia şi creştem lungimea secvenţei monotone curente. În caz contrar, secvenţa monotonă
anterioară s-a încheiat cu elementul a[i-1] având lungimea lung. Verificăm dacă lungimea
acesteia este mai mare decât lungimea maximă curentă lmax şi, eventual, actualizăm acest
maxim şi poziţia de început pmax. În poziţia i începe o nouă secvenţă monotonă care
deocamdată are lungimea 1.
#include<stdio.h>
#include<conio.h>
void main()
{
int a[100],n,i,poz,lung,pmax,lmax;
for(i=1;i<=n;i++)
{
}
a[n+1]=a[n]; //santinela
//considerăm că prima secvenţă începe în poziţia 1
//are lungimea 1 şi este iniţial de lungime maximă

poz=1; lung=1; pmax=1; lmax=1;
for(i=2;i<=n+1;i++)
if(a[i]>a[i-1])
//creşte lungimea secvenţei curente
lung++;
else
//s-a încheiat o secvenţă pentru care
//verificăm lungimea
{
if(lung>lmax) //actualizăm valorile
{
lmax=lung; pmax=poz;
}
//în poziţia i începe o nouă secvenţă
//cu lungimea iniţială 1
poz=i; lung=1;
}
printf("\n cea mai lunga seceventa de elemente
consecutive in ordine crescatoare este:\n");
for(i=pmax;i<=pmax+lmax-1;i++) printf("%d ",a[i]);
}
23. Se dau vectorii x şi y cu câte n (1<=n<=100) elemente numere naturale nenule. Să se

determine numerele p şi q prime între ele astfel încât: p/q=x[1]/y[1]+x[2]/y[2]+..
+x[n]/y[n].
Observaţii:
Rezolvarea problemei se bazează pe următoarele raţionamente matematice:
Vom calcula numitorul comun al fracţiei (T) şi apoi numărătorul ca suma elementelor de forma
x[i]*numitor/y[i]. Vom calcula c.m.m.d.c al celor două numere întregi obţinute şi vom simplifica
numitorul şi numărătorul cu c.m.m.d.c. obţinând numărătorul şi numitorul fracţiei ireductibile
echivalente.
#include<stdio.h>
#include<conio.h>
void main()
{
int x[50],y[50],n,i,numitor=1,numarator=0,c,d,p,q;
printf("\t primul vector:\n");
for(i=1;i<=n;i++)
{
}
printf("\t al doilea vector:\n");
for(i=1;i<=n;i++)
{
printf("y[%d]=",i); scanf("%d",&y[i]);
numitor*=y[i]; //numitorul fractiei
}
//calculăm numărătorul fracţiei sumă
for(i=1;i<=n;i++)
numarator+=x[i]*numitor/y[i];
//determinăm c.m.m.d.c prin scăderi repetate
c=numitor; d=numarator;
while(c!=d)
if(c>d) c-=d; else d-=c;
//simplificăm numitorul şi numărătorul fracţiei

p=numarator/c;
q=numitor/c;
printf("p=%d\tq=%d\n",p,q);
getch();
}
24. Fie a un şir cu n elemente întregi, n<=100. Să se rearanjeze elementele lui a, fără a folosi
memorie suplimentară, astfel încât cele pare să apară înaintea celor impare şi în aceeaşi
ordine în care erau în vectorul iniţial.
Observaţii:
Vom parcurge vectorul element cu element de la stânga spre dreapta. Dacă elementul curent a[i]
este par, el îşi păstrează poziţia şi avansăm la următorul element. Dacă este impar, îl mutăm la
sfârşitul vectorului, în poziţia n, deplasând toate elementele de după a[i] cu o poziţie spre stânga.
Pentru a sesiza momentul în care partiţionarea vectorului s-a încheiat folosim o variabilă k, iniţial
egală cu n, care scade la fiecare mutare a unui element impar la sfârşitul vectorului. În momentul
în care cele două valori i şi k devin egale, partiţionarea vectorului s-a încheiat.
#include<stdio.h>
#include<conio.h>
void main()
{
int a[50],n,i,j,k,aux;
for(i=1;i<=n;i++)
{
}
i=1; k=n;
do{
if(!(a[i]&1)) i++; //element par,avansăm
else
{
//element impar,îl mutăm în poziţia n
aux=a[i];
for(j=i;j<=n-1;j++) a[j]=a[j+1];
a[n]=aux; k--;
}
}while(i<k);
printf("\n\t Vectorul obtinut este:\n");
for(i=1;i<=n;i++) printf("%d ",a[i]);
}
25. Se dă o secvenţă de n numere naturale, n<=50 , şi un număr natural lim. Să se insereze între
oricare două componente vecine a căror diferenţă în modul este mai mare sau egală cu lim ,
partea întreagă a mediei lor aritmetice.
Observaţii:
Parcurgem vectorul începând cu primul element şi comparăm vecinii (a[i],a[i+1]). Dacă diferenţa
lor în modul este mai mică decât lim avansăm la elementul următor. În caz contrar, calculăm
media aritmetică a celor două elemente, deplasăm cu o poziţie spre dreapta secvenţa
a[i+1].....a[n], inserăm în poziţia i+1 media calculată, actualizăm lungimea şirului (care creşte cu
un element) şi trecem la elementul următor care este a[i+2] (sărim peste media tocmai introdusă
în şir).
#include<stdio.h>
#include<math.h>
#include<conio.h>
void main()
{
int a[100],n,i,j,lim,t;
for(i=1;i<=n;i++)
{
}
printf("lim="); scanf("%d",&lim);
i=1;
do{
if(abs(a[i]-a[i+1])<lim) i++;
//nutrecem la elementul următor
else
{
//calculăm nedia aritm. a elem. vecine
t=(a[i]+a[i+1])/2;
//deplasăm spre dreapta secvenţa
for(j=n+1;j>=i+2;j--)
a[j]=a[j-1];
//inserăm în poziţia i+1 media aritm.
//actualizăm lungimea şirului
//şi sărim peste media introdusă
a[i+1]=t; n++; i+=2;
}
}while(i<n);
printf("\n\t Vectorul obtinut este:\n");
for(i=1;i<=n;i++)
printf("%d ",a[i]);
}
26. N pitici aşezaţi unul în spatele celuilalt, poartă căciuli colorate roşii sau albe. Fiecare pitic
spune două numere, primul reprezentând numărul de căciuli albe, celălalt numărul de căciuli
roşii pe care le poartă piticii din faţa sa.
a) Ştiind că piticii cu căciulă roşie mint (dau incorect cel puţin unul din cele două numere) ,
iar cei cu căciulă albă spun întotdeauna adevărul , să se determine culoarea căciulii
fiecărui pitic. Se vor citi de la tastatură numărul n de pitici (n<=100) şi cele n perechi de
numere. Se va tipări pe ecran o succesiune de litere A şi R reprezentând culorile căciulilor
piticilor în ordinea în care stau în şir
b) Ştiind că fiecare pitic îşi păstrează culoarea căciulii determinată la punctul (a) , să se afle
dacă este posibilă schimbarea ordinii piticilor în şir astfel încât toţi piticii să spună
adevărul. În caz afirmativ, se vor tipări numerele de ordine iniţiale ale piticilor în noua
ordine stabilită.
Observaţii:
Primul punct se rezolvă analizând succesiv afirmaţiile fiecărui pitic. Dacă spune
adevărul are căciulă albă, altfel are căciulă roşie. Pentru al doilea punct determinăm
pe rând perechile de numere care au suma (adică numărul de pitici aflaţi în faţă) 0,
apoi 1, apoi 2,..,până la n-1, condiţia de existenţă a soluţiei fiind ca la fiecare pas să
existe o astfel de pereche şi piticul corespunzător să spună adevărul (să aibă
căciulă albă).
#include<stdio.h>
#include<conio.h>
void main()
{
int a[100],r[100],n,i,j,k,na,nr;
char sir[101];
na=0; nr=0;
for(i=1;i<=n;i++)
{
printf("raspunsul piticului %d (alb,rosu):
",i);
scanf("%d %d",&a[i],&r[i]);
if(na==a[i] && nr==r[i])
{
na++; sir[i]='A'; //spune adevărul
}
else
{
nr++; sir[i]='R'; //minte
}
}
printf("\n\t Caciulile piticilor sunt:\n");
for(i=1;i<=n;i++) printf("%c ",sir[i]);
printf("\n");
printf("punctul b)\n");
na=0; nr=0; i=0;
do{
j=0;
for(k=1;k<=n;k++)
if(a[k]+r[k]==i && na==a[k] &&
nr==r[k]) j=k;
printf("%d ",j);
if(j)
if(sir[j]=='A') na++;
else nr++;
i++;
}while(j && i<n);
if(!j)
printf("\nNu exista solutie\n");
else
printf("\n");
getch();
}
27. Fiind date n segmente (intervale deschise) situate pe aceeaşi axă, se cere colorarea lor cu un
număr minim de culori astfel încât oricare două segmente care se intersectează să aibă culori
diferite. Fiecare interval este dat pe o linie sub forma unei perechi de numere întregi din
intervalul [1,1000], primul număr fiind întotdeauna mai mic decât al doilea.
Observaţii:
Problema se reduce la determinarea numărului maxim de segmente care se suprapun. Axa pe
care sunt scrise segmentele este un vector (linie). Fiecare segment se colorează adunând la
elementele sale valoarea 1. Iniţial toate elementele sunt 0 adică necolorate.
#include<stdio.h>
#include<conio.h>
void main()
{
int linie[10001],n,i,j,a,b,max;
//iniţializăm culoarea punctelor din intervalul
//[1..1000] cu 0
for(i=1;i<=1000;i++) linie[i]=0;
//citim numărul intervalelor
for(i=1;i<=n;i++)
{
//citim extremităţile fiecărui interval [a,b]
printf("[a,b]="); scanf("%d %d",&a,&b);
//creştem cu 1 culoarea punctelor din
//intervalul [a,b]
for(j=a+1;j<=b;j++) linie[j]++;
}
max=0;
//culoarea maximă din tablou reprezintă numărul
//intervalelor care se intersectează
for(i=1;i<=1000;i++)
if(max<linie[i]) max=linie[i];
printf("\nnumarul minim de culori necesare este
%d\n",max);
getch();
28. Se citesc de la tastatură două numere naturale de cel mult cinci cifre fiecare. Să se afişeze
valoarea exactă a raportului lor folosind un număr minim de caractere.
Observaţii:
Cunoscând algoritmul împărţirii numerelor naturale din aritmetică, vom simula împărţirea în
program coborând zecimalele deîmpărţitului (zerouri) cifră cu cifră. Înţelegând prin cerinţa „număr
minim de caractere” că pentru numerele zecimale infinite (obligatoriu periodice deoarece provin
din fracţii de numere întregi, deci din numere raţionale) se va folosi reprezentarea lor cu perioada
principală între paranteze, vom avea grijă să memorăm resturile parţiale ale împărţirilor pentru a
sesiza când se repetă unul dintre resturi.
#include<stdio.h>
#include<conio.h>
void main()
{
unsigned char c[10000];
unsigned r[10000],i,j,k,a,b,poz;
printf("numerele a,b: "); scanf("%u %u",&a,&b);
if(!b)
{
printf("raport cu numitorul 0!\n");
return;
}
printf("\nValoarea zecimala a raportului este: ");
printf("%u",a/b);
if(a%b) //restul este nenul
{
putchar('.'); i=0; poz=0;
do{
a%=b; //restul curent
for(j=1;j<=i;j++)
if(r[j]==a) //restul se repetă
{
poz=j; break;
//memorăm poziţia
}
i++; r[i]=a; //memorăm restul curent
a*=10;
//coborâm un zero din deîmpărţit
c[i]=a/b;
//memorăm cifra curentă a rezultatului
}while(a&&!poz);
//până se împarte exact sau se obţine un rest
//care a mai apărut
if(poz) //număr periodic
{
for(k=1;k<=poz-1;k++)
printf("%d",c[k]);
printf("(");
for(k=poz;k<=i-1;k++)
printf("%d",c[k]);
printf(")\n");
}
else //număr neperiodic
{
for(k=1;k<=i;k++) printf("%d",c[k]);
printf("\n");
}
}
getch();
}
B. Probleme propuse
1. Să se construiască un vector cu primele n (1<=n<=20) numere cuburi perfecte nenule, apoi

să se afişeze componentele lui cu spaţiu între ele.
2. Scrieţi un program care citeşte de la tastatură cele n componente reale ale unui vector a
(1<=n<=100) şi afişează pe ecran câte dintre valorile citite sunt mai mici decât media
aritmetică a elementelor vectorului.
3. Scrieţi un algoritm eficient care determină şi afişează cel mai mare număr ce se poate forma
având exact aceleaşi cifre ca şi un număr natural n citit de la tastatură (n<=999 999 999).
4. Se citeşte de la tastatură un vector cu n (1<=n<=100) componente reale. Se cere să se
calculeze suma componentelor negative, produsul componentelor pozitive şi numărul
componentelor nule.
5. Se citeşte de la tastatură un vector cu n (1<=n<=100) componente de tip întreg. Se cere să se
construiască şi să se afişeze un nou vector cu componentele pătrate perfecte din vectorul
iniţial. Dacă nu există componente pătrate perfecte, se va afişa mesajul “VECTOR VID”.
6. Fără a folosi un vector auxiliar, să se mute la sfârşitul unui vector componentele sale nule,
păstrându-se ordinea acestora. Se ştie că vectorul are n (1<=n<=100) componente numere
naturale.
7. Se dă un vector x cu n (1<=n<=100) componente numere întregi. Se cere să se determine
componentele distincte din x împreună cu frecvenţa lor de apariţie.
8. Să se treacă un număr natural n (1<=n<=1000000) din baza 10 în baza 2 folosind pentru
memorarea cifrelor numărului binar un vector.
9. Să se treacă un număr natural cu n (1<=n<=26) cifre din baza 2 în baza 10. Cifrele numărului
sunt date în vectorul x în ordinea descrescătoare a puterilor lui 2.
10. Se dă un vector cu n (1<=n<=100) componente numere naturale. Să se construiască şi să se
afişeze un nou vector cu componentele pare ale celui iniţial.
11. Se dau doi vectori x, y cu n (1<=n<=100) componente. Primul conţine nume de elevi, iar al
doilea notele la informatică. Se cere să se afişeze numele elevilor cu nota cea mai mică.
12. Să se calculeze suma şi produsul componentelor unui vector cu n (1<=n<=100) componente
reale.
13. Se dau doi vectori x,y cu n (1<=n<=100) componente întregi. Să se determine valoarea
expresiei: x[1]y[1]+x[2]y[2]+….+x[n]y[n].
14. Se dau doi vectori x,y cu n (1<=n<=100) componente reale. Să se calculeze sumele:
x[1]*y[1]+….+x[n]*y[n], respectiv x[n]*y[1]+x[n-1]*y[2]+…+x[1]*y[n].
15. Se dă un vector cu n (1<=n<=100) componente naturale. Să se calculeze suma elementelor
divizibile cu a, pentru a număr natural dat.
16. Se dă un vector cu n (1<=n<=100) componente numere naturale. Să se insereze între oricare
două componente alăturate media aritmetică a celorlalte n-2 componente.
17. Se dă un vector cu n (1<=n<=100) componente întregi. Se cere să se afişeze primele k
componente în ordine crescătoare iar celelalte în ordine descrescătoare.
18. Se dă un vector cu n (1<=n<=100) componente naturale. Să se afişeze componenta care
apare de cele mai multe ori în vector. Dacă există mai multe astfel de componente se vor
afişa toate.
19. Să se determine cel mai mare divizor comun şi cel mai mic multiplu comun a n numere
naturale.
20. Se dă un vector cu n (1<=n<=100) componente întregi. Să se verifice dacă reprezintă o
mulţime în sens matematic (valorile nu se repetă).
21. Se dă un şir cu n elemente reale, n<=100 . Să se determine cel mai mare număr negativ şi
poziţiile pe care se află el în şirul dat.
22. Fie a un vector cu n numere reale, n<=100. Să se afle cea mai mare diferenţă în modul dintre
două componente ale sale. Să se modifice vectorul astfel încât cele două componente să fie
consecutive.
23. Se citesc doi vectori, a cu m elemente şi b cu n elemente, m,n<=150, numere întregi. Să se
verifice dacă cei doi vectori sunt mulţimi în sens matematic şi , în caz afirmativ, să se
calculeze intersecţia şi reuniunea lor.
24. Să se stabilească dacă o valoare dată y se află printre componentele unui vector de numere
întregi şi, în caz afirmativ, să se tipărească toate poziţiile în care apare printr-o singură
parcurgere a vectorului.
25. Fie a un vector cu n elemente reale, n<=100. Să se înlocuiască fiecare element cu media
aritmetică a celorlalte n-1 elemente.
26. Fie a un şir cu n elemente întregi, n<=100. Să se determine elementul maxim din şir şi toate
poziţiile în care acesta apare printr-o singură parcurgere a şirului.
27. Fie a un vector de n numere reale, n<=150. Să se determine printr-o singură parcurgere a sa
cea mai lungă secvenţă de elemente consecutive egale. Se va preciza lungimea şi poziţia de
început a primei astfel de secvenţe fără a folosi memorie suplimentară.
28. Fiind dat un număr natural având cel puţin k cifre (k<=20), se cere să se elimine din număr k
cifre astfel încât numărul rămas să fie cel mai mare posibil.
29. Se dă un şir de n numere reale, n<=250. Să se scrie un program care determină ce element
se află pe poziţia k dată în şirul ordonat, fără a face efectiv ordonarea şi fără a folosi memorie
suplimentară. (0<=k<=n-1).
30. Se dau n pioni de culoare albă, albastră şi roşie. Şirul se consideră ordonat parţial: primele k-
1 poziţii sunt ocupate cu pioni roşii, poziţiile de la k la l-1 de pioni albi, poziţiile de la l la m-1
de pioni albaştri şi poziţiile de la m la n de pioni neordonaţi (1<=k<=l<=m<=n). Să se scrie un
program care plasează pionii neordonaţi în şirul ordonat. Plasarea lor se face prin schimbarea
pionilor între ei. Culoarea unui pion se analizează o singură dată. Se va folosi o singură
locaţie de memorie suplimentară.
31. Fie a un număr real şi x un vector cu n elemente reale, n<=100. Să se rearanjeze elementele
lui x astfel încât toate numerele mai mici decât a să fie înaintea tuturor numerelor mai mari
sau egale cu a, fără a ordona efectiv şirul.
32. Fie a un număr real şi vectorul x cu n elemente reale, n<=100. Să se elimine din şir toate
elementele mai mici decât a fără a folosi memorie suplimentară.
33. Fie a un număr real şi x un vector cu n numere reale, n<=100. Să se ordoneze vectorul
crescător după distanţa lor faţă de numărul a.
34. Dacă X este şirul : 1,1,2,1,2,3,1,2,3,4,…… obţinut din şirul numerelor naturale prin înlocuirea
fiecărui k natural cu secvenţa de numere 1,2,3,…,k , să se construiască vectorul V(n) cu
componente egale cu primii n termeni ai şirului X , n<=250, dat.
35. Fie a un vector cu n numere întregi, n<=100. Să se interschimbe două secvenţe de lungime
L1 şi L2 care încep din poziţiile p1, respectiv p2. Elementele care nu sunt cuprinse în cele
două secvenţe pot fi mutate astfel încât interschimbarea să se poată face.
Exemplu : n=9
A=(1,2,3,4,5,6,7,8,9)
P1=2 , L1=2
P2=6 , L2=3
 a=(1,6,7,8,4,5,2,3,9)
36. Se dă un vector numeric cu n elemente. Să se determine cea mai lungă secvenţă de
elemente consecutive din şir cu proprietatea că doi vecini au semne diferite.
37. La o adunare a oamenilor de afaceri s-a propus înfiinţarea de către un grup de investitori a
unei societăţi comerciale cu un capital de pornire c, dat. Cunoscând suma de care dispune
fiecare din cei n oameni de afaceri, să se aleagă acele persoane care totalizează suficient
capital pentru a putea înfiinţa societatea şi în acelaşi timp să formeze un grup cât mai restrâns
(pentru ca posibilităţile de a interveni neînţelegeri între ei să fie cât mai reduse).
38. Fie n puncte în plan date prin coordonatele lor carteziene (xi,yi) numere reale.Să se afişeze
coordonatele şi mărimea celui mai lung segment obţinut prin unirea a două puncte din cele n.
39. Se citeşte un număr natural foarte mare (maxim 100 de cifre). Să se verifice dacă este
palindrom.
40. Se consideră două numere naturale cu câte maxim 50 de cifre oarecare, cifrele fiind date în
ordinea descrescătoare a rangurilor. Să se afişeze suma celor două numere.
41. Se consideră două tablouri cu m, respectiv n componente reale (1<=m,n<=100). Se citeşte un
număr natural k. Să se insereze în primul tablou, după poziţia k, tabloul al doilea.
42. Se consideră două tablouri cu m, respectiv n elemente reale, care reprezintă coeficienţii a
două polinoame P(x) şi Q(x) în ordinea descrescătoare a gradelor lui x. Să se afişeze
coeficienţii polinomului sumă.
43. Dându-se un tablou cu n (1<=n<=100) numere naturale, să se afişeze numai elementele care
sunt prime sau fac parte din şirul Fibonacci.
44. Dându-se un tablou cu n (1<=n<=100) numere naturale, să se localizeze elementul maxim şi
toate elementele dinaintea lui să se ordoneze crescător, iar cele de după el, descrescător,
afişându-se rezultatul.
45. Să se calculeze 2n, unde n este un număr natural citit, de valoare maximă 100, astfel încât să
se afişeze rezultatul corect. Apoi să se afişeze fracţia zecimală care rezultă din 1/2n.
46. Fiind date n (1<=n<=100) numere întregi şi un număr k, să se determine dacă există o
secvenţă de k elemente consecutive a căror valoare este 0.
47. Fiind date n (1<=n<=100) numere întregi, să se numere perechile de numere de pe poziţii
consecutive care au valori a căror diferenţă în modul este egală cu 1.
48. Fiind date două tablouri a şi b cu n, respectiv m elemente, scrieţi un program care să verifice
dacă au aceleaşi elemente distincte (toate elementele unui vector se găsesc printre
elementele celuilalt vector şi invers). Exemplu: a=(2,3,2,2,4,1) şi b=(2,4,2,4,1,3) au aceleaşi
elemente distincte (1,2,3,4).
49. Se consideră doi vectori a şi b, cu n, respectiv m elemente numere întregi (1<=n<=m<=100).
Să se verifice dacă elementele vectorului a sunt printre elementele vectorului b, în aceeaşi
ordine, dar nu neapărat consecutive.
50. Fiind dat un tablou cu n (1<=n<=100) numere întregi, să se determine numărul elementelor
prime cu un număr natural k dat.
51. Cunoscându-se lungimea unui şir şi componentele sale, să se tipărească o secvenţă de
lungime maximă de elemente consecutive care formează o progresie aritmetică. Exemplu:
pentru şirul (5,2,15,23,2,4,6,-1,33.5,81,21,-19) sunt corecte secvenţele (2,4,6) şi (81,21,-19).
52. Se citesc n numere naturale. Să se determine din câte secvenţe monotone este format şirul
dat şi să se tipărescă fiecare secvenţă. Prin secvenţă monotonă se înţelege un şir de termeni
consecutivi care sunt, fie în ordine crescătoare, fie în ordine descrescătoare. Exemplu: şirul
(2,8,12,4,20,24,30,5,3,1,1,0) este format din 3 secvenţe monotone şi anume (2,8,12),
(4,20,24,30), (5,3,1,1,0) primele două fiind crescătoare şi a treia descrescătoare.
53. Fiind dat un vector cu n numere reale (1<n<=100) să se verifice dacă toate elementele
vectorului sunt constante (egale două câte două).
54. Fiind date n segmente (intervale închise) situate pe aceeaşi axă, date prin extremităţile lor, să
se determine intersecţia celor n intervale.
55. Fiind dat un vector cu n elemente întregi, să se separe elementele astfel: cele pozitive la
începutul vectorului, iar cele negative la sfârşit. Se va păstra ordinea de apariţie a elementelor
pozitive, respectiv negative în vector şi nu se va utiliza memorie suplimentară.
56. Să se elimine elementele impare dintr-un vector cu n numere naturale nenule fără a folosi
memorie suplimentară.
57. Scrieţi un program eficient care determină câte valori distincte de cel mult două cifre există
într-un şir de n numere naturale (n<=2000) citite de la tastatură.
58. Se citesc două şiruri de numere naturale fiecare având n elemente. Să se construiască un şir
care conţine pe fiecare poziţie suma elementelor corespunzătoare celor două şiruri date şi să
se tipărească elementele acestuia în ordine crescătoare.
59. Pentru n numere date se calculează media aritmetică şi două valori procentuale cu o
zecimală: procentul de numere dintre cele date care sunt strict mai mici decât media
aritmetică a întregului şir şi procentul de numere care sunt strict mai mari decât media
aritmetică.
60. Scrieţi un program eficient care determină toate perechile de numere naturale a şi b, cu a<=b,
numerele ce formează perechea având proprietatea că nu au nici o cifră comună şi suma lor
este s. Valoarea s este un număr natural citit de la tastatură (s<100 000 000).
61. Scrieţi un program eficient care citeşte n valori naturale de cel mult 5 cifre fiecare (0<n<1000)
şi afişează cea mai mică valoare de exact trei cifre care nu apare printre cele n valori. Dacă
nu există nici-un astfel de număr se va afişa mesajul EROARE. De exemplu, pentru n=8 şi
valorile (1238, 511, 104, 60, 101, 7000, 100, 44) se va afişa 102.
62. Scrieţi un program care citeşte de la tastatură o valoare naturală n (0<n<200) şi apoi cele n
componente numere întregi ale vectorului v, orice element al vectorului având cel mult patru
cifre. Să se realizeze sortarea crescătoare a elementelor pare ale vectorului având grijă ca în
plus fiecare element impar să rămână exact pe poziţia pe care se afla iniţial. Pentru n=7 şi
vectorul v=(10,2,5,11,6,5,8) se va afişa şirul de valori 2 6 5 11 8 5 10.

Caiet de Laborator

Încărcat de

Informații document

Titlu original

Drepturi de autor

Formate disponibile

Partajați acest document

Partajați sau inserați document

Opțiuni de partajare

Vi se pare util acest document?

Este necorespunzător acest conținut?

Drepturi de autor:

Formate disponibile

Caiet de Laborator

Încărcat de

Drepturi de autor:

Formate disponibile

Caiet de laborator pentru clasa a IX-a 1

CAP.1 FUNCŢII DE CITIRE/SCRIERE.........................................................................2

1.1 Funcţii de citire/scriere pentru caractere şi şiruri de caractere.......................................2

1.2 Funcţiile de citire/scriere cu format....................................................................................5

CAP.2 OPERATORII LIMBAJULUI C.......................................................................11

CAP.3 STRUCTURI DE CONTROL..........................................................................26

3.1 Structura secvenţială şi alternativă...................................................................................26

3.2 Structura repetitivă (iterativă)..........................................................................................31

4.1 Tablouri unidimensionale (vectori)...................................................................................74

Cap.1 Funcţii de citire/scriere

1.1 Funcţii de citire/scriere pentru caractere şi şiruri de

3. Citiţi un caracter alb sau imprimabil folosind macrourile getchar şi putchar .

4. Citiţi cu ecou o litera mică şi afişaţi-o ca literă mare .

5. Rezolvaţi problema anterioară folosind macrourile getchar şi putchar .

6. Citiţi de la terminalul standard o succesiune de caractere imprimabile şi reafişaţi-o pe ecran,

1.2 Funcţiile de citire/scriere cu format

printf("%2c",c); //afişarea pe un câmp de lungime 2

2. Citiţi un caracter şi afişaţi-l pe ecran precedat şi urmat de câte un asterisc.

4. Citiţi o cifră zecimală ca şi caracter şi afişaţi-o precedată de 3 zerouri nesemnificative .

5. Citiţi un şir de maxim 50 de caractere şi afişaţi-l pe ecran pe o linie nouă.

8. Citiţi o literă mare şi afişaţi-o ca literă mică .

11. Citiţi 4 cifre zecimale şi afişaţi-le precedate de câte un spaţiu fiecare .

Cap.2 Operatorii limbajului C

2. Având în vedere modul de evaluare a expresiilor de atribuire, să se indice rezultatele afişate

3. Programul următor ilustrează modalităţile de utilizare a operatorilor unari +,-,++,-- şi a

a+++++b=11 a=1 b=10

4. Să se arate care sunt rezultatele pe care le afişează programul de mai jos şi să se

5. Având în vedere semnificaţia pe care o are compunerea diferiţilor operatori cu operatorul de

8. Ţinând seama de regulile de precedenţă ale operatorilor pe biţi şi de semnificaţia acestora, să

9. Fie declaratia : int i,x,y;

10. Precizaţi efectul operaţiilor :

15. Să se depisteze erorile existente în expresiile de mai jos, să se argumenteze şi să se verifice

2. Realizaţi cu ajutorul operatorului condiţional "?" şi/sau a operaţiilor de atribuire următoarele

a) determinarea valorii absolute a unui număr real x

3. Sa se determine valorile expresiilor de mai jos, apoi să se verifice rezultatele cu ajutorul

16. Să se citescă un întreg în variabila x şi să se afişeze valoarea expresiei x3+32145x+1. Întrucât

Cap.3 Structuri de control

3.1 Structura secvenţială şi alternativă

1. Să se calculeze şi să se afişeze media aritmetică a două numere reale citite de la tastatură.

2. Să se interschimbe valorile a două variabile întregi citite de la tastatură.

6. Să se calculeze valoarea absolută a unui număr real citit de la tastatură.

7. Să se calculeze valoarea expresiei

printf("valoarea A="); scanf("%d",&a);

8. Să se calculeze valoarea funcţiei

1. Cunoscând numărul natural n să se calculeze suma 1+2+3+...+n.

3.2 Structura repetitivă (iterativă)

1. Să se calculeze suma S=1+2+....+n, respectiv produsul P=1*2*...*n pentru n număr natural

3. Să se realizeze înmulţirea a două numere întregi a şi b date de la tastatură, prin adunări

5. Să se determine şi să se afişeze divizorii proprii ai unui număr natural nenul n dat de la

6. Se defineşte şirul lui Fibonacci (legea creşterilor organice) astfel:

9. Fie expresia P(x)=anxn+an-1xn-1+.....+a1x+a0. Să se calculeze valoarea expresiei pentru x real

cifra=b10%q; //obţinem restul

printf("a,b="); scanf("%d %d",&a,&b);

37. Să se scrie un program care să afişeze un meniu de forma:

//k este lungimea secvenţei strict crescătoare curentă

unde cifra 9 apare de l ori şi cifra 0 de n ori.

45. Se introduce de la tastatură un număr natural. Să se determine numărul minim şi numărul

d) S=1+1*2+1*2*3+….+1*2*..*n, n număr natural nenul dat

4.1 Tablouri unidimensionale (vectori)

printf("\n\n\tVectorul introdus este:\n\n");

printf("\tIntroduceti elementele vectorului:\n");

printf("\nvaloarea %d nu apare in sir\n",x);

if(!(a[i]%2)) //este par

1. Să se calculeze suma S=1+2+....+n, respectiv produsul P=12...*n pentru n număr natural

d) S=1+12+123+….+12..n, n număr natural nenul dat