1) Exemplificare in declarare si folosirea variabilelor pointer.

Transferul se va face intre adrese ale

locatiilor de memorie, cu retinere simultana si a valorilor retinute la acestea.

#include<stdio.h>

int main()

int a=1; /* a este o locatie de memorie pentru elemente de tip int pe doi

octeti, pe care am initializat-o cu valoarea 1 */

int* b; /* b este o variabila pointer spre tipul int, adica capabila a

retine adrese ale altor variabile de tipul specificat */

//declaram pointerul

b=&a; /* in adresa b retinem adresa locatiei de memorie (adica a

variabilei) a, deci b devine adresa locatiei de memorie a */

printf("Val a= %d\t Val b= %d\n\n", a,*b);

printf("Adresa a= %p\t Adresa b= %p", &a, b);

2) Exemplificare in declarare si folosirea variabilelor pointer. Transferul se va face doar intre

valori retinute la anumite locatii de memorie

#include<stdio.h>

#include<stdio.h>

void main()

int a=1; /*a este o locatie de memorie pentru elemente de tip int pe doi octeti,

pe care am initializat-o cu valoarea 1 */

int x=55;

int *b; /* b este o variabila pointer spre tipul int, adica capabila a retine adrese ale

altor variabile de tipul specificat */

//declaram pointerul

b=&x; //initializam pointerul

/* in adresa b retinem adresa locatiei de memorie (adica a variabilei) x,

deci b devine adresa locatiei de memorie x */

*b = a; /* transferul se face intre valori;

valorii retinute la adresa b ii atribuim valoarea retinuta in a */

printf("Val a= %d\t Val b= %d\n\n", a,*b);

printf("Adresa a= %p\t Adresa b= %p", &a, b);

4) Transmiterea informatiilor prin intermediul adreselor. Interschimbarea se va face

intre adrese ale locatiilor de memorie, elementul auxiliar interschimbarii ne fiind o
adresa (un pointer).
#include<stdio.h>
void main()
{
int *a, *b, c;
int x=2, y=5;

a=&x; //initializam a
b=&y; //initializam b

printf("Introduceti a: ",a);
scanf("%d", a);
printf("Introduceti b: ",b);
scanf("%d", b);
 printf("\nInainte de interschimbare: \n");

printf("\tVal a= %d\tVal b= %d\n\n", *a,*b);

printf("\tAdresa a= %p\tAdresa b= %p\n", a, b);

//interschimbarea

c=*a; // transfer intre valori, pt ca expresia &c=a; nu ar fi

fost valida
a=b;
b=&c;

printf("\nDupa interschimbare: \n");

printf("\tVal a= %d\tVal b= %d\n\n", *a,*b);

printf("\tAdresa a= %p\tAdresa b= %p\n", a, b);

getchar();
int k;
scanf("&d", k);
}

5) Transmiterea informatiilor prin intermediul adreselor. Interschimbarea se va face

intre valorile retinute la locatiile de memorie ale respectivelor adrese, elementul
auxiliar interschimbarii fiind o adresa (un pointer).
#include<stdio.h>
void main()
{
int *a, *b, *c;
int x=2, y=5, z=7;

a=&x; //initializam a
b=&y; //initializam b
c=&z; //initializam c

printf("Introduceti a: ",a);
scanf("%d", a);
printf("Introduceti b: ",b);
scanf("%d", b);

printf("\nInainte de interschimbare: \n");

printf("\tVal a= %d\tVal b= %d\n\n", *a,*b);

printf("\tAdresa a= %p\tAdresa b= %p\n", a, b);

//interschimbarea

*c=*a; // transfer intre valori

*a=*b;
*b=*c;
 printf("\nDupa interschimbare: \n");

printf("\tVal a= %d\tVal b= %d\n\n", *a,*b);

printf("\tAdresa a= %p\tAdresa b= %p\n", a, b);

getchar();
int k;
scanf("&d", k);
}
6) Transmiterea informatiilor prin intermediul adreselor. Interschimbarea se va face
intre valorile retinute la locatiile de memorie ale respectivelor adrese, elementul
auxiliar interschimbarii nefiind o adresa (un pointer).
#include<stdio.h>
void main()
{
int *a, *b, c;
int x=2, y=5;

a=&x; //initializam a
b=&y; //initializam b

printf("Introduceti a: ",a);
scanf("%d", a);
printf("Introduceti b: ",b);
scanf("%d", b);

printf("\nInainte de interschimbare: \n");

printf("\tVal a= %d\tVal b= %d\n\n", *a,*b);

printf("\tAdresa a= %p\tAdresa b= %p\n", a, b);

//interschimbarea

c=*a; // transfer intre valori

*a=*b;
*b=c;

printf("\nDupa interschimbare: \n");

printf("\tVal a= %d\tVal b= %d\n\n", *a,*b);

printf("\tAdresa a= %p\tAdresa b= %p\n", a, b);

getchar();
int k;
scanf("&d", k);
}
7) Aritmetica pointerilor. Se va scrie o rutina in C pentru exemplificarea aritmeticii
in cazul pointerilor, exemplificare pe cazurile operatiilor de
incrementare/decrementare, respectiv adunare/sca dere de valori.
#include<stdio.h>
void main()
{

int a[]={10,20,30,40,50}; /*am declarat un sir de elemente de tip

int pe care
l-am initializat cu valorile aflate
in multime*/
int* b; // b este pointer spre tipul int
b=a; //in adresa b retinem sirul a
/* transferul se face astfel deoarece a este o adresa prin numele sau,
adresa primului element din sir*/

for(int i=1; i<=5; i++)

{
printf("%d\n", *b); /* b-ul prin transfer fiind adresa primului
element,
rezultatul acestei expresii, va fi prima
valoare din sir, adica 10*/
b++; //se face trecerea la elementul urmator din
sir
}

// ne vom intoarce cu pointerul de cursor al sirului in

prima pozitie
b-=5; //sau b=b-5
printf("Primul element al sirului: %d\n", *b);

/* ne pastram pozitia de pointare in sir, daca vrem sa

afisam elementul
al treilea al sirului*/
printf("Al treilea element al sirului: %d\n", *(b+2));

getchar();
int k;
scanf("&d", k);
}

8) Aritmetica pointerilor. Se va scrie o rutina in C pentru exemplificarea aritmeticii

in cazul pointerilor, exemplificare pe cazurile operatiilor de
incrementare/decrementare, respectiv adunare/scadere asupra unui sir de caractere
prin prelucrare pe subsiruri ale acestuia.
#include<stdio.h>
void main()
{
char a[]="ABCDE"; //sirul a retine un sir de caractere, in numar de
5
char* b;
b=a;
 for(int i=1;i<=5;i++)
{
printf("%s\n",b); /* un sir este o adresa, iar, mesajul
acesta va
afisa subsirul incepand cu prima
pozitie, adica "ABCDE" */
b++;
}

b-=5;
printf("subsirul incepand cu prima pozitie: %s\n",b);
printf("subsirul incepand cu a treia pozitie: %s",b+2);

getchar();
int k;
scanf("&d", k);
}

9) Alocarea memorie dinamice în lucrul cu variabile pointer. Să se realizeze un

program care interschimbă două valori reale folosind variabile pointer.
#include<stdio.h>
#include<stdlib.h> //sau #include<alloc.h>
void main()
{
double *a,*b,*c;

/* vom crea variabile dinamice, adica variabile ce isi vor pastra

memoria extinsa intr-o zona, numita zona HEAP */

a=(double*)malloc(sizeof(double)); /* in zona HEAP am rezervat

spatiu suficient pentru
memorarea unei variabile de
tipul double */
printf("Introduceti a: "); scanf("%lf",a);

b=(double*)malloc(sizeof(double));
printf("Introduceti b: "); scanf("%lf",b);
c=a; /* pentru c nu este nevoie sa
alocam memorie dinamica,
pentru ca c primeste prin
transfer de la a */
a=b;
b=c;
printf("dupa interschimbare: a= %.2lf\tb= %.2lf",*a,*b);

/* desi in acest caz nu este necesar, pentru ca o variabila

dinamica
nu mai este viabila la sfarsitul executiei functiei, totusi noi
putem opta pentru dealocare explicita pentru variabilele create
dinamic */
 free(a);
free(b);

getchar();
int k;
scanf("&d", k);
}
10) Transferul parametrilor prin valoare (exemplul 1).
#include<stdio.h>
void modifica(int x, int y, int z)
{
printf("Valori initiale in functie: %d %d %d\n",x,y,z); //1 2 3
x+=10;
y+=10;
z+=10;
printf("Valori finale in functie: %d %d %d\n",x,y,z); //11 12 13
}

void main()
{
int a=1,b=2,c=3;
printf("Valori initiale in program: %d %d %d\n",a,b,c); //1 2 3
modifica(a,b,c);
printf("Valori finale in program: %d %d %d\n",a,b,c); //1 2 3

getchar();
int k;
scanf("&d", k);
}

11) Transferul parametrilor prin valoare (exemplul 2).

#include<stdio.h>
int suma (int s)
{
for(int i=0; i<=10; i++)
s=s+i;
return s;
}

void main()
{
int s=0;
suma(s);
printf("Suma este: %d", s); //Sume este 0

getchar();
int k;
scanf("%d",k);
}
12) Transferul parametrilor prin adresa (exemplul 1).
#include<stdio.h>
void modifica(int* x, int* y, int* z)
{
printf("Valori initiale in functie: %d %d %d\n",*x,*y,*z); //1 2 3
*x+=10;
*y+=10;
*z+=10;
printf("Valori finale in functie: %d %d %d\n",*x,*y,*z); //11 12
13
}
void main()
{
int a=1,b=2,c=3;
printf("Valori initiale in program: %d %d %d\n",a,b,c);
//1 2 3 modifica(&a,&b,&c);

printf("Valori finale in program: %d %d %d\n",a,b,c);

//11 12 13

getchar();
int k;
scanf("%d",k);
}

13) Transferul parametrilor prin adresa (exemplul 2).

#include<stdio.h>void suma(int* s)
{
for(int i=0; i<=10; i++)
*s=*s+i;
}
void main()
{
int s=0;
suma(&s);
printf("Suma este: %d\n", s); //Sume este 55

getchar();
int k;
scanf("%d",k);
}

14) Sa se scrie un program care va realiza interschimbarea conţinutului a două

variabile ce pot reţine valori reale. Programul va defini funcţii de citire şi afişare
pentru un număr real, precum şi o funcţie proprie pentru interschimbarea
conţinutului variabilelor, cu rămânerea rezultatului şi în afara execuţiei funcţiei.
#include<stdio.h>
//citirea unei variabile reale
void citire(float* x, char c)
{
printf("Introduceti %c: ", c);
scanf("%f", x);
}
//afisarea continutului unei variabile reale
void afisare(float x, char c)
{
printf("Valoarea din %c este: %.2f\n", c,x);
}
//functia de interschimbare a continutului a doua variabile reale
void interschimbare(float *x, float *y)
{
float z;
z=*x;
*x=*y;
*y=z;
}
void main()
{
float a, b;
citire(&a,'a');
citire(&b,'b');

printf("\nINITIAL:\n");
afisare(a,'a');
afisare(b,'b');

printf("\nDUPA INTERSCHIMBARE:\n");
interschimbare(&a,&b);
afisare(a,'a');
afisare(b,'b');

getchar();
int k;
scanf("%d",k);
}

15) Sa se scrie un program care va realiza interschimbarea conţinutului a două

variabile ce pot reţine valori reale. Programul va defini funcţii de citire şi afişare
pentru un număr real, precum şi o funcţie proprie pentru interschimbarea
conţinutului variabilelor, cu rămânerea rezu ltatului şi în afara execuţiei funcţiei.
Variabilele sunt declarate global; declarate de un tip standard definit.
#include<stdio.h>
float a,b;
//functia de citire a celor doua variabile
void citire()
{
printf("Introduceti a: ");
scanf("%f", &a);
printf("Introduceti b: ");
scanf("%f", &b);
}
//functia de afisare
void afisare()
{
printf("Valoarile sunt: a=%.2f, b=%.2f\n", a, b);
}
//functia de interschimbare
void interschimbare()
{
float c;
c=a;
a=b;
b=c;
}
void main()
{
citire();
afisare();
printf("\n");
interschimbare();
afisare();
getchar();
int k;
scanf("%d",k);
}

16) Sa se scrie un program care va realiza interschimbarea conţinutului a două

variabile ce pot reţine valori reale. Programul va defini funcţii de citire şi afişare
pentru un număr real, precum şi o funcţie proprie pentru interschimbarea
conţinutului variabilelor, cu rămânerea rezultatului şi în afara execuţiei funcţiei.
Variabilele sunt declarate global; declarate de un tip pointer spre un tip real.
#include<stdio.h>
#include<stdlib.h>
float*a,*b;
void alocare()
{
a=(float*)malloc(sizeof(float));
b=(float*)malloc(sizeof(float));
}
void citire()
{
 alocare();
printf("dati a: ");
scanf("%f",a);
printf("dati b: ");
scanf("%f",b);
}
void afisare()
{
printf("valorile sunt: a=%.2f, b=%.2f\n",*a,*b);
}
void interschimba()
{
float c;
c=*a;
*a=*b;
*b=c;
}
void main()
{
citire();
afisare();
printf("\n");
interschimba();
afisare();

getchar();
int k;
scanf("%d",k);
}

17) Ce va afisa programul de mai jos?

#include<stdio.h>

int a,b;
int f(int m,int n)
{
m=n+b;
//printf("\nm=%d", m);

n+=1;
//printf("\nn=%d", n);

return n+b+m;
//printf("\nm=%d", n+b+m);
}
void main()
{
a=6;
b=5;
printf("\n%d %d ",a,b);
printf("\n%d ",f(a,b));
printf("\n%d %d ",a,b);

getchar();
int k;
scanf("%d",k);
}

Raspuns: 6 5 21 6 5

18) Se cere a se scrie o funcţie care va calcula suma cifrelor unui numar. Funcţia se
va scrie cu prototip (zona declarativă diferenţiată de cea definitivă).
#include<stdio.h>
//in acest caz rezultatul se va transmite prin tipul rezultat
int suma(int); //suma cifrelor unui nr. intreg

void main()
{
int n, suma_cifrelor=0, nr_invers=0;
printf("Introduceti n: ");
scanf("%d",&n);

suma_cifrelor=suma(n);
printf("\nSuma cifrelor sale este: %d", suma_cifrelor);

getchar();
int k;
scanf("%d",k);
}

/* suma cifrelor unui numar intreg:

Presupunem nr. dorit ca fiind 523 ptr. care sa calculam suma cifrelor
523 : 10 = 52 rest 3
Suma cifrelor intermediara: 0+3=3
52 : 10 = 5 rest 2
Suma cifrelor intermediara: 3+2=5
5 : 10 = 0 rest 5
Suma cifrelor finala: 5+5=10
*/

int suma(int n)
{
int s=0;
while (n)
{
s=s+n%10;
n/=10;
}
return s;
}
/* inversul unui numar intreg:
Presupunem nr. dorit ca fiind 523 ptr. care dorim sa-i aflam inversul
523 : 10 = 52 rest 3
Numarul invers intermediar: 0*10+3=3
52 : 10 = 5 rest 2
Numarul invers intermediar: 3*10+2=32
5 : 10 = 0 rest 5
Numarul invers final: 32*10+5=325
*/

19) Folosind o funcţie să se realizeze un program care calculează următoarea

expresie: (1+ ½ + 1/3+ ¼ +…+1/n)^n , unde n este un întreg dat de la tastatură.
#include<stdio.h>
#include<math.h>

float suma (int n)

{
float s=0;
float p=1;
for(int i=1; i<=n; i++)
{
p=1/(float)i;
s=s+p;
}
s=pow(s,n);
return s;
}
void main()
{
int n;

printf("\nIntroduceti n: ");
scanf("%d", &n);
printf("\n\tRezultatul expresiei este: %.2f", suma(n));

getchar();
int k;
scanf("%d", k);
}

20) Să se realizeze un program care calculeaza prin intermediul a două funcţii

cmmdc-ul şi cmmmc-ul a două numere date de la tastatură.
#include <stdio.h>
#include <math.h>

int cmmdc (int n, int m)

{
while(n!=m)
{
if(n>m)
 n=n-m;
else
m=m-n;
}
return n;
}

int cmmmc (int n, int m)

{
int z;
z=(n*m)/cmmdc(n,m);
return z;
}

void main()
{
int n,m;
printf("\nIntroduceti n: ");
scanf("%d", &n);

printf("\nIntroduceti m: ");
scanf("%d", &m);

printf("\nCmmdc este: %d", cmmdc(n,m));

printf("\nCmmmc este: %d", cmmmc(n,m));

getchar();
int k;
scanf("%d", k);
}

21) Să se realizeze adunarea şi înmulţirea a două numere reale folosind variabile de

tipul pointer.
#include<stdio.h>
void main()
{
int a;
printf("Introduceti a: ");
scanf("%d", &a);

int b;
printf("Introduceti b: ");
scanf("%d", &b);

int* n; //declar pointer

int* m; //declar pointer

n=&a; //initializez pointer

m=&b; //initializez pointer
 printf("\nSuma este: %d", *n+*m);
printf("\nProdusul este: %d", *n * *m);

getchar();
int k;
scanf("%d", k);
}

22) Scrieţi o funcţie care primeşte ca parametru lungimea laturii unui pătrat şi
returnează aria sa şi o funcţie care returnează diagonala.
#include<stdio.h>
#include<math.h>
float lungime (int n)
{
float aria;
aria=n*n;
return aria;
}

float diagonala (double n)

{
double diag;
diag=sqrt((n*n)+(n*n));
return diag;
}

void main()
{
int n;
printf("Introduceti n: ");
scanf("%d", &n);

printf("\nAria patratului este: %.2f", lungime(n));

printf("\nDiagonala patratului este: %.2lf", diagonala(n));

getchar();
int k;
scanf("%d", k);
}

23) Scrieţi o funcţie care primeşte 3 parametri de tip real, cu semnificaţia de

lungimi pentru 3 segmente. Funcţia va returna 1, dacă cele trei segmente pot forma
un triunghi şi 0, în caz contrar.
#include<stdio.h>
#include<math.h>
int triunghi (float x, float y, float z)
{
if((x>0)&&(y>0)&&(z>0)&&(x<y+z)&&(y<x+z)&&(z<x+y))
 return 1;
else return 0;
}
void main()
{
float x;
float y;
float z;
printf("Introduceti x: ");
scanf("%f", &x);
printf("Introduceti y: ");
scanf("%f", &y);
printf("Introduceti z: ");
scanf("%f", &z);

printf("Rezultat: %d",triunghi(x,y,z)),

getchar();
int k;
scanf("%d", k);
}

24) Scrieţi o funcţie care returnează ultima cifră a unui număr natural. De exemplu,
dacă numărul este 234, funcţia va returna 4.
#include<stdio.h>
#include<math.h>
int cifra (int a)
{
int b;
b=a%10;
return b;
}
void main()
{
int a;

printf("Introduceti numarul: ");

scanf("%d", &a);

printf("Ultima cifra este: %d",cifra(a));

getchar();
int k;
scanf("%d", k);
}

Vectori

ezolvari
1) Declarare a unui şir (tablou sau matrice unidimensionată) cu iniţializare de
valori.
#include<stdio.h>
void main()
{
int a[]={2,91,0,-45}; /*un sir de elemente intregi,
variabila matrice
initializata la declarare. Memoria
alocata
pentru aceasta matrice vine direct
din numarul
de elemente cu care este initilizata
*/

// afisarea sirului ce contine numere intregi

for(int i=0; i<4; i++)
printf("%d", a[i]);

getchar();
int k;
scanf("%d", k);
}

2) Memorarea informaţiei într-un tablou unidimensional prin citire.

#include<stdio.h>
void main()
{
int a[20]; /*am declarat un sir de max 20 de elem. de tipul int
cu numele a */

// INTRODUCEM DATE IN SIR

// introducem numarul de elemente din sir

int n;
printf("Dati nr de elemente din sir (<=20): ");
scanf("%d", &n);

//introducem elementele din sir

printf("Introduceti elementele: \n");
for(int i=0; i<n; i++)
{
printf("\t elem %d: ", i+1);
scanf("%d", &a[i]);
}

//AFISAM ELEMENTELE DIN SIR

printf("Elementele sirului sunt: ");
for(int i=0; i<n; i++)
printf("%d", a[i]);
 getchar();
int k;
scanf("%d", k);
}

3) Sa se scrie funcţii de citire şi afişare ale şirului de numere întregi, după ce acesta
a fost în prealabil declarat.
#include<stdio.h>
void citire(int a[], int* n)
{
printf("Dati numarul de elemente ale sirului: ");
scanf("%d",n);
printf("\nIntroduceti elementele sirului:\n");
for(int i=0;i<*n;i++)
{
printf("\tIntroduceti elem %d: ",i+1);
scanf("%d",&a[i]);
}
}
void afisare(int a[], int n)
{
printf("\nElementele sirului sunt: ");
for(int i=0;i<n;i++)
printf("%d ",a[i]);

}
void main()
{
int a[20],n;
citire(a,&n);
afisare(a,n);

getchar();
int k;
scanf("%d", &k);
}

4) Sa se scrie funcţii de citire şi afişare ale şirului de numere întregi, după ce acesta
a fost în prealabil declarat. Se cere construcţia unui tip propriu pentru reţinerea
şirurilor de elemente întregi.
#include<stdio.h>
typedef int vector[20]; /*vector de tip propriu creat pt retinerea
sirurilor,
cu o dimensiune max de 20 elemente*/
void citire(vector a, int* n)
{
printf("Dati numarul de elemente ale sirului: ");
scanf("%d",n);
 printf("Introduceti elementele sirului:\n");
for(int i=0;i<*n;i++)
{
printf("\telem %d: ",i+1);
scanf("%d",&a[i]);
}
}
void afisare(vector a, int n)
{
printf("Elementele sirului sunt: ");
for(int i=0;i<n;i++)
printf("%d ",a[i]);
}
void main()
{
vector a;
int n;
citire(a,&n);
afisare(a,n);

getchar();
int k;
scanf("%d", &k);
}

5) Alocare de memorie dinamică a unui şir. Se va citi şi ulterior, afişa, un şir de

numere întregi, pentru care spaţiul ocupat se va determina la rulare şi nu la
compilare.
#include<stdio.h>
#include<stdlib.h>

//functie de alocare de memorie pentru nr de elemente citite in sir

int* alocare(int* a, int* n)

{
printf("Dati numarul de elemente ale sirului: ");
scanf("%d",n);
a=(int*)malloc(*n*sizeof(int)); /* alocam memorie dinamica (in zona
Heap) pentru
memorarea unui sir in mod dinamic de
n elemente */
if(!a)
{
printf ("Eroare de alocare.");
return 0;
}
return a;
}
//functie ptr introducerea elementelor in sir
void citire(int* a, int n)
{
printf("Introduceti elementele sirului:\n");
for(int i=0;i<n;i++)
{
printf("\telem %d: ",i+1);
scanf("%d",&a[i]);
}
}
//functie ptr afisarea elementelor din sir
void afisare(int* a, int n)
{
printf("Elementele sirului sunt: ");
for(int i=0;i<n;i++)
printf("%d ",a[i]);
}
void main()
{
int* a, n;
a=alocare(a,&n); //apel al functiei de alocare de memorie
citire(a,n); //apel al functiei de citire
afisare(a,n); //apel al functiei de afisare

getchar();
int k;
scanf("%d", &k);
}

6) Se va dezvolta o aplicaţie pentru reprezentarea şirurilor de numere întregi, şi

anume:
- se va determina un tip de date pentru astfel de reprezentari
- se va citi un sir de numere întregi
- se va afisa un sir de numere întregi
- se vor aduna componentele sirului (vom prezenta doua metode: una cu transfer
rezultat prin tipul rezultat si alta cu transfer prin linia de parametri)
- se va realiza operatia de înmultire a componentelor sirului
- media elementelor din sir
- numarul de componente negative si numarul de componente pozitive din sir
- minimul si maximul dintre elementele sirului
- sortarea ascendenta a sirului
- cautarea unui anumit element în sir cu returnarea pozitiei pe care se gaseste; în
cazul în care elementul se afla de mai multe ori în pe pozitii diferite, vom avea ca
rezultat prima pozitie pe care acesta se gaseste.
Functiile vor fi descrise cu zona declarativa explicita, a dica, cu prototip de functie.
#include<stdio.h>
#include<stdlib.h>
typedef int* vector;

//functie de alocare de memorie in zona Heap pentru un sir declarat

vector alocare(vector,int*); /*primul parametru este sirul, iar al doilea
dimensiunea sa
(numarul de elemente ce vor fi
citite)*/

//functia de citire a elementelor unui sir

void citire(vector,int);

//afisarea unui sir de numere intregi

void afisare(vector,int);

//sumarea elementelor din sir - cu transfer prin tipul rezultat

int suma1(vector,int);

//sumarea elementelor din sir - cu transfer prin linia de parametri

void suma2(vector,int,int*); //al 3-lea parametru va retine rezultatul
suma

//produsul elementelor din sir

int produs(vector,int);

//media elementelor din sir

float media(vector,int);

//numarul de elemente negative, respectiv pozitive, din sir

void nr_neg_poz(vector,int,int*,int*);

//minimul si maximul valorilor din sir

void min_max(vector,int,int*,int*);

//functie de sortare a sirului

void sortare(vector,int);

/* cautarea unui anumit element, cu returnarea pozitiei pe care se gaseste

in sir (in cazul in care respectivul element se gaseste de mai multe ori
in
sir, se va returna prima pozitie la care se afla) */
int cautare(vector,int,int);

void main()
{
vector v;
int n;
v=alocare(v,&n); //apelul functiei de alocare

citire(v,n); //apelul functiei de citire

afisare(v,n);
int s1=suma1(v,n);
 printf("\n\nSuma elementelor: %d",s1);
int s2;
suma2(v,n,&s2);
printf("\nSuma elementelor: %d",s2);
int p=produs(v,n);
printf("\nProdusul elementelor: %d",p);
float m=media(v,n);
printf("\nMedia elementelor: %.2f",m);
int neg,poz;
nr_neg_poz(v,n,&neg,&poz);
printf("\nNr. de elem. negative: %d; Nr. de elem. pozitive:
%d",neg,poz);
int min,max;
min_max(v,n,&min,&max);
printf("\nMinimul din sir: %d; Maximul din sir: %d",min,max);
sortare(v,n);
afisare(v,n);
int elem;
printf("\nDati un element ce se doreste a fi cautat: ");
scanf("%d",&elem);
if(cautare(v,n,elem)) //rezultat diferit de 0
printf("\tElementul se gaseste pe pozitia %d",
cautare(v,n,elem));
else
printf("\tElementul nu se afla in sir");

getchar();
int k;
scanf("%d", &k);
}
vector alocare(vector a, int* n)
{
printf("Dati numarul de elemente: ");
scanf("%d",n);
a=(int*)malloc(*n*sizeof(int));
return a;
}
void citire(vector a, int n)
{
printf("Introduceti elementele:\n");
for(int i=0;i<n;i++)
{
printf("\telem %d= ",i+1);
scanf("%d",&a[i]);
}
}
void afisare(vector a, int n)
{
printf("\nSirul este: ");
for(int i=0;i<n;i++)
printf("%d ",a[i]);
}
int suma1(vector a, int n)
{
 int s=0;
for(int i=0;i<n;i++)
s+=a[i]; //s=s+a[i];
return s;
}
void suma2(vector a, int n, int* s)
{
*s=0;
for(int i=0;i<n;i++)
*s+=a[i];
}
int produs(vector a, int n)
{
int p=1;
for(int i=0;i<n;i++)
p*=a[i];
return p;
}
float media(vector a, int n)
{
return (float)suma1(a,n)/n;
}
void nr_neg_poz(vector a, int n, int* neg, int* poz)
{
*neg=*poz=0;
for(int i=0;i<n;i++)
if(a[i]>=0)
(*poz)++;
else
(*neg)++;
}
void min_max(vector a, int n, int* m, int* M)
{
*m=*M=a[0]; /*mergem de la premiza ca primul element va fi atat
element
minim cat si maxim in sir*/
for(int i=1;i<n;i++)
if(a[i]<*m)
*m=a[i];
else
if(a[i]>*M)
*M=a[i];
}
void sortare(vector a, int n)
{
int aux;
for(int i=0;i<n-1;i++)
for(int j=i+1;j<n;j++)
if(a[i]>a[j]) //sortare ascendenta
{
aux=a[i];
a[i]=a[j];
a[j]=aux;
}
}
int cautare(vector a, int n, int e)
{
for(int i=0;i<n;i++)
if(a[i]==e)
return i+1;
return 0;
}

7) Citirea si afisarea unui sir de numere, prin constructia unui tip propriu pentru
retinerea sirului de numere intregi. Funcţia va fi descrisa cu zonă declarativă
explicită, adică, cu prototip de funcţie.
#include<stdio.h>
#include<malloc.h>
typedef int* vector;
vector alocare (vector a, int* n)
{
printf("Dati numarul de elemente: ");
scanf("%d",n);
a=(int*)malloc(*n*sizeof(int));
return a;
}
void citire(vector a, int n)
{
printf("Introduceti elementele:\n");
for(int i=0;i<n;i++)
{
printf("\telem %d= ",i+1);
scanf("%d",&a[i]);
}
}
void afisare(vector a, int n)
{
printf("\nSirul este: ");
for(int i=0;i<n;i++)
printf("%d ",a[i]);
}
void main()
{
vector x; //sirul de nr. intregi
int n; //nr. de elemente ce vor fi citite in sir

x=alocare(x,&n);
citire(x,n);
afisare(x,n);

getchar();
int k;
scanf("%d",k);
}
8) Fie declaraţiile : int a[20]; int n; float e;
Să se determine valoarea expresiei e în fiecare din cazul: e = x1+x2+x3+…+xn;
#include<stdio.h>
void citire(int a[], int* n)
{
printf("\nIntroduceti nr de elemente: ");
scanf("%d", n);
printf("\nIntroduceti elementele: ");
for(int i=0; i<*n; i++)
{
printf("\nElem %d: ", i+1);
scanf("%d", &a[i]);
}
}
int expresie(int a[20],int n)
{
int e=0;
for(int i=0; i<n; i++)
{
e=e+a[i];
}
return e;
}
void main()
{
int a[20], n, e;

citire(a, &n);
printf("\nRezultatul este: %d", expresie(a,n));

getchar();
int var;
scanf("%d", &var);
}

9) Alocare dinamica sir.

#include <stdio.h>
#include <stdlib.h>
void main()
{
int n , *a, i;
printf ("Dati numarul de elemente ale sirului: ");
scanf ("%d", &n);
//alocare memorie pt memorarea unui sir in mod dinamic de n elemente
a=(int*) malloc(n*sizeof(int));
//introducere elementelor in sir
printf ("Introduceti elementele in sir: \n");
for (i=0; i<n; i++)
 {
printf ("element %d: ", i+1);
scanf ("%d", &a[i]);
}
//afisarea elementelor
printf ("Elementele intregi ale sirului sunt: \n");
for (i=0; i<n; i++)
{
printf ("element %d = %d\n", i+1, a[i]);
}

int j;
scanf("%d", &j);
}

10) Fie declaraţiile : int a[20]; int n; float e; Să se determine valoarea expresiei e în
fiecare din cazurile:
a) e = x1+x2+x3+…+xn;
b) e = x1*x2*x3*…*xn;
c) e = media aritmetica a componentelor din vector;
d) e = suma patratelor componentelor din vector;
e) e = suma cuburilor componentelor negative din vector;
f) e = x1-x2+x3-x4+…±xn
#include<stdio.h>

//introducere date in sir

void citire(int b[], int* n)
{
printf("\nIntroduceti numarul de elemente: ");
scanf("%d", n);

printf("\nIntroduceti elementele:\n ");

for(int i=0; i<*n; i++)
{
printf("\nElem %d:", i+1);
scanf("%d", &b[i]);
}
}
int expresie1 (int a[20], int n)
{
int e=0;
for(int i=0; i<n; i++)
e=e+a[i];
return e;
}
int expresie2 (int a[20], int n)
{
int e=1;
 for(int i=0; i<n; i++)
e=e*a[i];
return e;
}
float expresie3 (int a[20], int n)
{
float e=0;
for(int i=0; i<n; i++)
e=e+a[i]/(float)n;
return e;
}
int expresie4 (int a[20], int n)
{
int e=0;
for(int i=0; i<n; i++)
e=e+a[i]*a[i];
return e;
}
int expresie5 (int a[20], int n)
{
int e=0;
for(int i=0;i<n;i++)
{
if(a[i]<0)
e=e+a[i]*a[i]*a[i];
}
return e;
}
int expresie6 (int a[20], int n)
{
int e=0,semn=1;
for(int i=0;i<n;i++)
{
if (i%2==0)
semn=1;
else
semn=-1;
e=e+a[i]*semn;
}
return e;
}
void main()
{
int b[20], n, i;
float e;
citire(b, &n);
printf("\n\tSuma elementelor este: %d",expresie1(b,n));
printf("\n\tProdusul este: %d",expresie2(b,n));
printf("\n\tMedia aritmetica este: %.2f",expresie3(b,n));
printf("\n\tSuma patratelor este: %d",expresie4(b,n));
printf("\n\tSuma cuburilor negative este: %d",expresie5(b,n));
printf("\n\tExpresia este: %d",expresie6(b,n));

getchar();
 int var;
scanf("%d", &var);
}

11) Să se realizeze un program care interclasează doi vectori într -un al treilea
vector. Primii doi vor fi iniţial sortaţi.
#include<stdio.h>
#include<stdlib.h>
void main()
{
int n , m, *a, *b, i, j, gasit, aux, k, *c;
//------------------------------------------------------------------------
---------
printf ("Dati numarul de elemente ale sirului1: ");
scanf ("%d", &n);
//alocare memorie pt memorarea unui sir in mod dinamic de n
elemente
a=(int*) malloc(n*sizeof(int));
//introducere elementelor in sir
printf ("Introduceti elementele in sir1: \n");
for (i=0; i<n; i++)
{
printf ("element %d: ", i+1);
scanf ("%d", &a[i]);
}
//------------------------------------------------------------------------
---------

printf ("Dati numarul de elemente ale sirului2: ");

scanf ("%d", &m);
//alocare memorie pt memorarea unui sir in mod dinamic de n
elemente
b=(int*) malloc(m*sizeof(int));
//introducere elementelor in sir
printf ("Introduceti elementele in sir2: \n");
for (j=0; j<m; j++)
{
printf ("element %d: ", j+1);
scanf ("%d", &b[j]);
}
//------------------------------------------------------------------------
---------
//afisarea elementelor celor 2 siruri
printf ("Elementele intregi ale sirului1 sunt: \n");
for (i=0; i<n; i++)
{
printf ("element %d = %d\n", i+1, a[i]);
}
printf ("Elementele intregi ale sirului2 sunt: \n");
for (j=0; j<m; j++)
{
 printf ("element %d = %d\n", j+1, b[j]);
}
//------------------------------------------------------------------------
---------
//sortare sir I

do
{
gasit=0;
for(i=0;i<n-1;i++)
if (a[i]>a[i+1])
{
aux=a[i];
a[i]=a[i+1];
a[i+1]=aux;
gasit=1;
}
}
while(gasit);
//afisare dupa sortare sir 1

printf ("Elementele sirului1 dupa sortare sunt: \n");

for (i=0; i<n; i++)
{
printf ("element %d = %d\n", i+1, a[i]);
}
//------------------------------------------------------------------------
---------
//sortare sir II

for(i=0;i<m-1;i++)
for(j=i+1;j<m;j++)
if(b[i]>b[j])
{
aux=b[i];
b[i]=b[j];
b[j]=aux;
}

//afisare dupa sortare sir 2

printf ("Elementele sirului2 dupa sortare sunt: \n");

for (j=0; j<m; j++)
{
printf ("element %d = %d\n", j+1, b[j]);
}
//------------------------------------------------------------------------
---------
//interschimbarea propriu-zisa

//alocare memorie pt memorarea unui sir in mod dinamic de n

elemente
c=(int*) malloc((n+m)*sizeof(int));
i=j=k=0;
 while(i<m && j<n)
if (a[i]==b[j]) //în cazul în care avem elemente comune în cei doi
vectori acestea
sa fie puse o singura data în vectorul interclasat
{
c[k++]=a[i++];
j++;
}
else
if (a[i]<b[j]) c[k++]=a[i++];
else c[k++]=b[j++]; //sau {c[k]=b[j]; k++; j++;}

if(i<m) //în caz ca mai ramân elemente neanalizate în a se copiaza

în c
for(j=i;j<n;j++)
c[k++]=a[j];
else //în caz ca mai ramân elemente neanalizate în b se copiaza în
c
for(i=j;i<m;i++)
c[k++]=b[i];
//afisare dupa sortare siruri

printf ("Elementele sirului dupa sortare sunt: \n");

for (k=0; k<(m+n); k++)
{
printf ("element %d = %d\n", k+1, c[k]);
}
//---------------------------------------------------

Matrice

Rezolvari

1) Se va concepe o matrice bidimensională, având componente întregi, prin

iniţializare în momentul declarării.
#include<stdio.h>
void main()
{
int a[][3]={
{2,-9,0},
{7,11,-8},
{2,2,-20},
{12,7,90}
};
//operatia de afisare a matricei declarata avand 4 linii si 3
coloane
for(int i=0; i<4; i++)
{
for(int j=0; j<3; j++)
printf("%5d", a[i][j]);
 printf("\n");
}

getchar();
int k;
scanf("%d", k);
}

2) Se va scrie o rutină care va citi o matrice bidimensională având componente

întregi, după care o va afişa.
#include<stdio.h>
void main()
{
int a[10][10]; /* matricea bidimensionala avand un nr. maximi
de 10 linii si 10 coloane ce vor putea fi memorate
*/
int m,n; /* numarul real (la citire) de randuri, respectiv,
de
coloane, ale matricei */
int i,j;
//introducerea dimensiunilor matricei
printf("Introduceti nr de linii: ");
scanf("%d", &m);
printf("Introduceti nr de coloane: ");
scanf("%d", &n);
//introducerea elementelor matricii
printf("Introduceti elementele matricei: \n");
for(i=0; i<m; i++)
for(j=0; j<n; j++)
{
printf("\tElem [%d,%d]= ", i+1, j+1);
scanf("%d", &a[i][j]);
}
//afisarea elementelor matricei
for(i=0; i<m; i++)
{
for(j=0; j<n; j++)
printf("%5d", a[i][j]);
printf("\n");
}
getchar();
int k;
scanf("%d", k);
}

3) Se va scrie o rutină care va citi o matrice bidimensională având componente

întregi, după care o va afişa, iar apoi va calcula suma elementelor matricei.
#include<stdio.h>
void main()
{
int a[10][10]; /* matricea bidimensionala avand un nr. maximi
de 10 linii si 10 coloane ce vor putea fi memorate
*/
int m,n; /* numarul real (la citire) de randuri, respectiv,
de
coloane, ale matricei */
int i,j;
//introducerea dimensiunilor matricei
printf("Introduceti nr de linii: ");
scanf("%d", &m);
printf("Introduceti nr de coloane: ");
scanf("%d", &n);
//introducerea elementelor matricii
printf("Introduceti elementele matricei: \n");
for(i=0; i<m; i++)
for(j=0; j<n; j++)
{
printf("\tElem [%d,%d]= ", i+1, j+1);
scanf("%d", &a[i][j]);
}
//afisarea elementelor matricei
for(i=0; i<m; i++)
{
for(j=0; j<n; j++)
printf("%5d", a[i][j]);
printf("\n");
}
//calcularea sumei elementelor matricei
int s=0;
for(i=0; i<m; i++)
for(j=0; j<n; j++)
s=s+a[i][j];
printf("\nSuma elem. este: %d", s);

getchar();
int k;
scanf("%d", k);
}

4) Să se realizeze un program care încarcă numerele de la 1 la 12 într -o matrice

bidimensională şi le afişează rând cu rând, după care realizează interschimbari între
liniile acesteia. De asemenea se vor obţine primul, respectiv ultimul element dintr-o
matrice tablou.
//macrouri de tip constante pentru numarul de linii, respectiv de coloane
#define lin 3
#define col 4
#include<stdio.h>
//definirea unui tip matrice cu un numar specificat de linii si coloane
typedef int matrice[lin][col];

//o prima functie de atribuire a valorilor de la 1 la 12 intr-o matrice

bidimensionala
void atribuire1(matrice a)
{
int k=1,i,j;
for(i=0;i<lin;i++)
for(j=0;j<col;j++)
{
a[i][j]=k;
k++;
}
}
//o alta functie de atribuire a valorilor de la 1 la 12 intr-o matrice
bidimensionala
void atribuire2(matrice a)
{
int i,j;
for(i=0;i<lin;i++)
for(j=0;j<col;j++)
a[i][j]=(i*col)+j+1;
}
//afisarea primului, respectiv, al ultimului element dintr-o matrice
void afis_prm_ult(matrice a)
{
printf("\nPrimul element este: %d",a[0][0]);
printf("\nUltimul element este: %d\n",a[lin-1][col-1]);
}
//afisarea unei matrice bidimensionale sub forma unui tablou
void afisare(matrice a, char c)
{
int i,j;
printf("\n");
printf("\nMatricea %c este:\n",c);
for(i=0;i<lin;i++)
{
for(j=0;j<col;j++)
printf("%4d",a[i][j]);
printf("\n");
}
}
//interschimbarea a doua linii citire intr-o matrice
void interschimbare(matrice a)
{
int x,y,j,aux;
printf("\nDati linia care se doreste a se interschimba : ");
scanf("%d",&x);
printf("Dati linia cu care se doreste interschimbarea : ");
scanf("%d",&y);

/* Interschimbarea între continutul liniei x cu y se face element

cu
 element prin parcurgerea intregii coloane. */
for(j=0;j<col;j++)
{
aux=a[x-1][j];
a[x-1][j]=a[y-1][j];
a[y-1][j]=aux;
}
}
//functia principala in rulare
void main()
{
matrice a,b;
atribuire1(a);
atribuire2(b);
afis_prm_ult(a);
afisare(a,'A');
afisare(b,'B');
interschimbare(a);
afisare(a,'A');

getchar();
int k;
scanf("%d", k);
}

5) Se va scrie un program pentru realizarea principalelor sumări între elementele

unei matrice bidimensionale.
#include<stdio.h>
//definirea unui tip matrice cu un numar specificat de linii si coloane
typedef int matrice[10][10];

void citire(matrice a, int *n, char c)

{
int i,j;
printf("Introduceti datele matricei %c:\n",c);

//introducerea dimensiunii matricei

printf("\tnumarul de linii (coloane): ");
scanf("%d",n);

//introducerea elementelor matricei

printf("\telementele matricei:\n");
for(i=0;i<*n;i++)
for(j=0;j<*n;j++)
{
printf("\t\t%c[%d][%d]= ",c,i+1,j+1);
scanf("%d",&a[i][j]);
}
}
void afisare(matrice a, int n, char c)
{
 int i,j;
printf("Matricea %c este:\n",c);
for(i=0;i<n;i++)
{
for(j=0;j<n;j++)
printf("%5d",a[i][j]);
printf("\n");
}
}
//suma tuturor elementelor matricei
void suma1(matrice a, int n)
{
int s=0,i,j;
for(i=0;i<n;i++)
for(j=0;j<n;j++)
s+=a[i][j];
printf("\nSuma tuturor elementelor este: %d", s);
}
//suma elementelor de pe diagonala principala
void suma2(matrice a, int n)
{
int s=0,i;
for(i=0;i<n;i++)
s+=a[i][i];
printf("\n\nSuma elementelor de pe diagonala principala este: %d",
s);
}
//suma elementelor de deasupra diagonalei principale
void suma3(matrice a,int n)
{
int s=0,i,j;
for(i=0;i<n-1;i++)
for(j=i+1;j<n;j++)
s+=a[i][j];
printf("\nSuma elementelor de deasupra diagonalei principale este:
%d", s);
}
//suma elementelor de sub diagonala principala
void suma4(matrice a,int n)
{
int s=0,i,j;
for(i=1;i<n;i++)
for(j=0;j<=i-1;j++)
s+=a[i][j];
printf("\nSuma elementelor de sub diagonala principala este: %d",
s);
}
//suma elementelor de pe diagonala secundara
void suma5(matrice a,int n)
{
int s=0,i;
for(i=n-1;i>=0;i--)
s+=a[i][n-i-1];
 printf("\n\nSuma elementelor de pe diagonala secundara este: %d",
s);
}
//suma elementelor de deasupra diagonalei secundare
void suma6(matrice a,int n)
{
int s=0,i,j;
for(i=0;i<n-1;i++)
for(j=0;j<=n-2-i;j++)
s+=a[i][j];
printf("\nSuma elementelor de deasupra diagonalei secundare este:
%d",s);
}
//suma elemntelor de sub diagonala secundara
void suma7(matrice a,int n)
{
int s=0,i,j;
for(i=n-1;i>=1;i--)
for(j=n-i;j<n;j++)
s+=a[i][j];
printf("\nSuma elemntelor de sub diagonala secundara este: %d",s);
}
//suma elementelor de pe o anumita linie
void suma8(matrice a,int n,int l)
{
int s=0,j;
for(j=0;j<n;j++)
s+=a[l-1][j];
printf("Suma elementelor de pe o anumita linie este: %d",s);
}
void main()
{
matrice a,b,c;
int n,l;
citire(a,&n,'A');
afisare(a,n,'A');
suma1(a,n);
suma2(a,n);
suma3(a,n);
suma4(a,n);
suma5(a,n);
suma6(a,n);
suma7(a,n);

printf("\n\nDati linia dorita a se calcula suma: ");

scanf("%d",&l);

suma8(a,n,l);

getchar();
int k;
scanf("%d", k);
}
6) Se va scrie un program pentru realizarea principalelor sumări între elementele
unei matrice bidimensionale, astfel încât funcţiile vor transmite rezultatele, nu doar
le vor afişa în interiorul corpului acestora.
#include<stdio.h>
//definirea unui tip matrice cu un numar specificat de linii si coloane
typedef int matrice[10][10];
void citire(matrice a, int *n, char c)
{
int i,j;
printf("Introduceti datele matricei %c:\n",c);
//introducerea dimensiunii matricei
printf("\tnumarul de linii (coloane): ");
scanf("%d",n);
//introducerea elementelor matricei
printf("\telementele matricei:\n");
for(i=0;i<*n;i++)
for(j=0;j<*n;j++)
{
printf("\t\t%c[%d][%d]= ",c,i+1,j+1);
scanf("%d",&a[i][j]);
}
}
void afisare(matrice a, int n, char c)
{
int i,j;
printf("Matricea %c este:\n",c);
for(i=0;i<n;i++)
{
for(j=0;j<n;j++)
printf("%5d",a[i][j]);
printf("\n");
}
}
//suma tuturor elementelor matricei
int suma1(matrice a, int n)
{
int s=0,i,j;
for(i=0;i<n;i++)
for(j=0;j<n;j++)
s+=a[i][j];
return s;
}
//suma elementelor de pe diagonala principala
int suma2(matrice a, int n)
{
int s=0,i;
for(i=0;i<n;i++)
s+=a[i][i];
return s;
}
//suma elementelor de deasupra diagonalei principale
int suma3(matrice a,int n)
{
int s=0,i,j;
for(i=0;i<n-1;i++)
for(j=i+1;j<n;j++)
s+=a[i][j];
return s;
}
//suma elementelor de sub diagonala principala
int suma4(matrice a,int n)
{
int s=0,i,j;
for(i=1;i<n;i++)
for(j=0;j<=i-1;j++)
s+=a[i][j];
return s;
}
//suma elementelor de pe diagonala secundara
int suma5(matrice a,int n)
{
int s=0,i;
for(i=n-1;i>=0;i--)
s+=a[i][n-i-1];
return s;
}
//suma elementelor de deasupra diagonalei secundare
int suma6(matrice a,int n)
{
int s=0,i,j;
for(i=0;i<n-1;i++)
for(j=0;j<=n-2-i;j++)
s+=a[i][j];
return s;
}
//suma elemntelor de sub diagonala secundara
int suma7(matrice a,int n)
{
int s=0,i,j;
for(i=n-1;i>=1;i--)
for(j=n-i;j<n;j++)
s+=a[i][j];
return s;
}
//suma elementelor de pe o anumita linie
int suma8(matrice a,int n,int l)
{
int s=0,j;
for(j=0;j<n;j++)
s+=a[l-1][j];
return s;
}
void main()
{
matrice a,b,c;
int n,l;
citire(a,&n,'A');
afisare(a,n,'A');
printf("\nSuma tuturor elementelor este: %d", suma1(a,n));
printf("\nSuma elementelor de pe diagonala principala este: %d",
suma2(a,n));
printf("\nSuma elementelor de deasupra diagonalei principale e: %d",
suma3(a,n));
printf("\nSuma elementelor de sub diagonala principala este: %d",
suma4(a,n));
printf("\nSuma elementelor de pe diagonala secundara este: %d",
suma5(a,n));
printf("\nSuma elementelor de deasupra diagonalei secundare este: %d",
suma6(a,n));
printf("\nSuma elemntelor de sub diagonala secundara este: %d",
suma7(a,n));

printf("\n\nDati linia dorita a se calcula suma: ");

scanf("%d",&l);
printf("\nSuma elementelor de pe o anumita linie este: %d", suma8(a,n,l));

getchar();
int k;
scanf("%d", k);
}

7) Se va scrie o rutină care va citi o matrice bidimensională având componente

întregi, după care o va afişa, iar apoi se va face o functie proprie care va returna
suma elementelor matricei de pe diagonala secundara.
#include<stdio.h>
//definirea unui tip matrice cu un numar specificat de linii si coloane
typedef int matrice[10][10];
//suma elementelor de pe diagonala secundara
int suma(matrice a, int n)
{
int s=0,i;
for(i=n-1;i>=0;i--)
s+=a[i][n-i-1];
return s;
}
void main()
{
matrice a; /* matricea bidimensionala avand un nr. maximi de 10
linii
si 10 coloane ce vor putea fi
memorate */
int n; /* numarul real (la citire) de randuri/coloane ale
matricei */
int i,j;
//introducerea dimensiunilor matricei
 printf("Introduceti nr de linii: ");
scanf("%d", &n);
//introducerea elementelor matricii
printf("Introduceti elementele matricei: \n");
for(i=0; i<n; i++)
for(j=0; j<n; j++)
{
printf("\tElem [%d,%d]= ", i+1, j+1);
scanf("%d", &a[i][j]);
}
//afisarea elementelor matricei
printf("Matricea este: \n");
for(i=0; i<n; i++)
{
for(j=0; j<n; j++)
printf("%5d", a[i][j]);
printf("\n");
}
//afisarea sumei elementelor de pe diagonala secundara
printf("\nSuma elementelor de pe diagonala secundara este: %d",
suma(a,n));
getchar();
int k;
scanf("%d", &k);
}

8) Suma a doua matrice.

#include<stdio.h>
//definirea unui tip matrice cu un numar specificat de linii si coloane
typedef int matrice[10][10];
void citire(matrice x, int n) // n - nr. de linii/coloane
{
for(int i=0; i<n; i++)
for(int j=0; j<n; j++)
{
printf("\tElem [%d,%d]= ", i+1, j+1);
scanf("%d", &x[i][j]);
}
}
//afisarea unei matrice bidimesionala
void afisare(matrice x, int n, char* s)
{
printf("\nMatricea %s este:\n",s);
for(int i=0;i<n;i++)
{
for(int j=0;j<n;j++)
printf("\t%d",x[i][j]);
printf("\n");
}
}
//suma a doua matrice
void suma(matrice x, matrice y, matrice z, int n) /* in acest caz putem
returna matricea prin tipul rezultat,
pentru matricea este un
pointer (o adresa) */
{

for(int i=0;i<n;i++)
for(int j=0;j<n;j++)
z[i][j] = x[i][j] + y[i][j];
}
void main()
{
matrice A,B,C;
int n;

printf("Introduceti dimensiunile matricelor.\n");

printf("\tnr. de linii/coloane: ");

scanf("%d",&n);

printf("Introducem elementele matricei A.\n");

citire(A,n);
afisare(A,n,"A");

printf("Introducem elementele matricei B.\n");

citire(B,n);
afisare(B,n,"B");

suma(A,B,C,n);
afisare(C,n,"A+B");

getchar();
int k;
scanf("%d", &k);
}

9) Inmultirea a doua matrice patratice.

#include<stdio.h>
//definirea unui tip matrice cu un numar specificat de linii si coloane
typedef int matrice[10][10];
void citire(matrice x, int n) // n - nr. de linii/coloane
{
for(int i=0; i<n; i++)
for(int j=0; j<n; j++)
{
printf("\tElem [%d,%d]= ", i+1, j+1);
scanf("%d", &x[i][j]);
}
}
//afisarea unei matrice bidimesionala
void afisare(matrice x, int n, char* s)
{
printf("\nMatricea %s este:\n",s);
for(int i=0;i<n;i++)
{
for(int j=0;j<n;j++)
printf("\t%d",x[i][j]);
printf("\n");
}
}
//inmultirea a doua matrice
void inmultire(matrice x, matrice y, matrice z, int n) /* in acest caz
putem returna matricea
prin tipul rezultat, pentru matricea
este un pointer (o adresa) */
{
for(int i=0;i<n;i++)
for(int j=0;j<n;j++)
{
z[i][j]=0;
for(int k=0;k<n;k++)
z[i][j]+=x[i][k]*y[k][j];
}
}
void main()
{
matrice A,B,C;
int n;

printf("Introduceti dimensiunile matricelor.\n");

printf("\tnr. de linii/coloane: ");

scanf("%d",&n);

printf("Introducem elementele matricei A.\n");

citire(A,n);
afisare(A,n,"A");

printf("Introducem elementele matricei B.\n");

citire(B,n);
afisare(B,n,"B");

inmultire(A,B,C,n);
afisare(C,n,"A*B");

getchar();
int k;
scanf("%d", &k);
}

10) Sa se scrie un program care determina elementele de maxim şi minim din

întreaga matrice pătratică.
#include<stdio.h>
void main()
{
int a[10][10]; /* matricea bidimensionala avand un nr. maximi de 10
linii
si 10 coloane ce vor putea fi
memorate */
int n; /* numarul real (la citire) de randuri/coloane, ale
matricei */
int i,j;

//introducerea dimensiunilor matricei

printf("Introduceti nr de linii/col: ");
scanf("%d", &n);

//introducerea elementelor matricii

printf("Introduceti elementele matricei: \n");
for(i=0; i<n; i++)
for(j=0; j<n; j++)
{
printf("\tElem [%d,%d]= ", i+1, j+1);
scanf("%d", &a[i][j]);
}

//afisarea elementelor matricei

for(i=0; i<n; i++)
{
for(j=0; j<n; j++)
printf("%5d", a[i][j]);
printf("\n");
}

//Maximul si minimul din intreaga matrice

int max=a[0][0];
for(i=0;i<n;i++)
for(j=0;j<n;j++)
{
if(a[i][j]>max)
max=a[i][j];
}

int min=a[0][0];
for(i=0;i<n;i++)
for(j=0;j<n;j++)
{
if(a[i][j]<min)
min=a[i][j];
}

printf("Maximul si minuml din matrice: %d si %d",max,min);

getchar();
int k;
scanf("%d", k);
}

STRUCTURI

Rezolvari

1) Declararea unei înregistrări şi folosirea acesteia.

#include<stdio.h>
/* structurile declarate, in principiu vor fi declarate in afara
oricarei functii, pentru a putea fi utilizata in intreg programul */
struct angajat
{
int cod_angajat;
char* nume;
char* prenume;
struct
{
int an;
char luna;
char zi;
}data_angajarii;
float sal_incadrare;
};
void main()
{
angajat x;
x.cod_angajat=1021;
x.nume="Popescu";
x.prenume="Ioan";
x.data_angajarii.an=2002;
x.data_angajarii.luna=9;
x.data_angajarii.zi=10;
x.sal_incadrare=1250;

printf("angajat: %s %s\n",x.nume,x.prenume);
printf("data angajarii: %d/%d/%d\n",x.data_angajarii.zi,
x.data_angajarii.luna, x.data_angajarii.an);
printf("salariu incadrare: %.2f",x.sal_incadrare);

getchar();
int k;
scanf("%d", &k);
}

2) Se va scrie un program C ce va evidenţia diferenţele între folosirea unei structuri

şi a unei uniuni.
a) se va folosi o structură de înregistrări:
#include<stdio.h>
struct exemplu
{
long int a;
char* b;
char* c;
};
void main()
{
exemplu x;
printf("Spatiul ocupat de o variabila la structura:
%d\n",sizeof(x));
x.a=10;
x.b="ABCD";
x.c="EFG";
printf("%ld\n",x.a);
printf("%s\n",x.b);
printf("%s\n",x.c);

getchar();
int k;
scanf("%d", &k);
}

b) se va folosi o structură tip uniune:

#include<stdio.h>
union exemplu
{
long int a;
char* b;
char* c;
};
void main()
{
exemplu x;
printf("Spatiul ocupat de o variabila la uniune: %d\n",sizeof(x));
x.a=10;
x.b="ABCD";
x.c="EFG";

printf("%ld\n",x.a);
printf("%s\n",x.b);
printf("%s\n",x.c);

getchar();
int k;
scanf("%d", &k);
}
3) Să se realizeze o aplicaţie care realizează prelucrări cu numere complexe, adică
citire, afişare, modul, sumă şi produs între două astfel de numere.
#include<stdio.h>
#include<math.h>
typedef struct{
float a; //partea reala
float b; //partea imaginara
}complex; //numele structurii
//citirea unui nr. complex
void citire(complex* z,char s[]) //s retine numele nr. complex
{
printf("Introducem nr. complex %s:\n",s);
printf("\tpartea reala: ");
scanf("%f",&(*z).a);
printf("\tpartea imaginara: ");
scanf("%f",&z->b); //alt mod de scriere
}
//afisarea unui nr. complex
void afisare(complex z,char s[])
{
printf("Nr. complex %s: ",s);
if(z.b>=0)
printf("%.2f+%.2fi\n",z.a,z.b);
else
printf("%.2f%.2fi\n",z.a,z.b);
}
//modulul unui nr. complex
float modul(complex z)
{
return sqrt(pow(z.a,2)+pow(z.b,2));
}
//conjugatul unui numar complex
complex conjugat(complex z)
{
complex t;
t.a=z.a;
t.b=-z.b;
return t;
}
//suma a doua nr. complexe (varianta cu transfer prin tipul rezultat)
complex suma1(complex x,complex y)
{
complex z;
z.a=x.a+y.a;
z.b=x.b+y.b;
return z;
}
//suma a doua nr. complexe (varianta cu transfer prin linia de parametri)
void suma2(complex x,complex y,complex* z)
{
z->a=x.a+y.a; //(*z).a=x.a+y.a;
z->b=x.b+y.b;
}
//produsul a doua nr. complexe
complex produs(complex x,complex y)
{
complex z;
z.a=x.a*y.a-x.b*y.b;
z.b=x.a*y.b+x.b*y.a;
return z;
}
//functia principala in rulare
void main()
{
complex z1,z2;
//citirea celor doua nr. complexe
citire(&z1,"z1");
citire(&z2,"z2");
printf("\n");
//afisarea celor doua nr. complexe
afisare(z1,"z1");
afisare(z2,"z2");
printf("\n");
//modulele celor doua nr. complexe
printf("Modulul lui z1: %.2f\n",modul(z1));
printf("Modulul lui z2: %.2f\n",modul(z2));
printf("\n");
//conjugatele celor doua numere complexe
afisare(conjugat(z1),"conjugat z1");
afisare(conjugat(z2),"conjugat z2");
//suma a doua nr. complexe - varianta 1
complex s1;
s1=suma1(z1,z2);
afisare(s1,"z1+z2");
//suma a doua nr. complexe - varianta 2
complex s2;
suma2(z1,z2,&s2);
afisare(s2,"z1+z2");
//produsul a doua nr. complexe
complex p;
p=produs(z1,z2);
afisare(p,"z1*z2");

getchar();
int k;
scanf("%d", &k);
}

4) Să se realizeze o aplicaţie pentru lucrul cu numere raţionale (valori numerice ce

pot fi scrise sub formă de fracţie) şi anume: citirea, afişarea, sumarea şi produsul a
două numere astfel de numere.
#include<stdio.h>
#include<math.h>
typedef struct
{
int a,b;
int cmmdc(int x,int y)
{
if(x==y) return x;
else
if(x>y) return cmmdc(x-y,y);
else
return cmmdc(x,y-x);
}
void ireductibil()
{
if(b<0)
{
a=-a;
b=-b;
}
if(!a)
b=1;
else
if(abs(a)!=1 && abs(b)!=1)
{
int d=cmmdc(abs(a),abs(b));
a=a/d;
b=b/d;
}
}
}rational;
void citire(rational* x, char c)
{
printf("Dati numarul rational %c:\n",c);
printf("\tnumaratorul: ");
scanf("%d",&x->a);
int n;
do
{
printf("\tnumitorul: ");
scanf("%d",&n);
}
while(n==0);
x->b=n;
x->ireductibil();
}

void afisare(rational x, char c[])

{
printf("Numarul rational %s: %d/%d\n",c,x.a,x.b);
}
rational adunare(rational x, rational y)
{
rational r;
r.a=x.a*y.b+x.b*y.a;
r.b=x.b*y.b;
 r.ireductibil();
return r;
}
rational inmultire(rational x, rational y)
{
rational r;
r.a=x.a*y.a;
r.b=x.b*y.b;
r.ireductibil();
return r;
}
void main()
{
rational x,y;

citire(&x,'x');
citire(&y,'y');

afisare(x,"x");
afisare(y,"y");

rational s;
s=adunare(x,y);
afisare(s,"x+y");

rational p;
p=inmultire(x,y);
afisare(p,"x*y");

getchar();
int k;
scanf("%d", &k);
}

5) Să se scrie un program care sa administreze un parc de automobile. Informaţiile

relative la un automobil sunt: numărul de locuri, puterea (în cai putere), marca,
culoarea, anul fabricaţiei maşinii.
a) se vor citi informatiile relative la cele n automobile din parcul de autoturisme. Se
vor afisa doar acele automobilele care au 5 locuri;
b) sa se ordoneze crescator dupa putere automobilele – se vor afisa datele ordonate;
c) sa se scrie o functie care afiseaza toate automobilele fabricate într -un anumit an
dat ca parametru.
#include<stdio.h>
#include<conio.h>
typedef struct //declarare structura
{
char marca[20];
char model[20];
 char cul[20];
int an;
struct //definire structura
{
char nl;
int put;
}date; //lista variabile la structura
}automobil; //nume structura
typedef automobil masini[20]; //tip de date propriu
void citire(masini a, int *n) //introducere date
{
int i;
printf("Dati nr. de automobile: ");
scanf("%d",n);
for(i=0; i<*n; i++)
{
printf("Introduceti datele despre automobilul %d\n",i+1);
printf("\tmarca: ");
scanf("%s",a[i].marca);
printf("\tmodelul: ");
scanf("%s",a[i].model);
printf("\tculoarea: ");
scanf("%s",a[i].cul);
printf("\tanul: ");
scanf("%d",&a[i].an);
printf("\tnumarul de locuri: ");
scanf("%d",&a[i].date.nl);
printf("\tputerea in cai putere: ");
scanf("%d",&a[i].date.put);
}
}

void afisare(masini a,int n) //afisare date

{
int i;
for (i=0;i<n;i++)
{
printf("Automobil [%d]:\n",i+1);
printf("\tmarca: %s\n",a[i].marca);
printf("\tmodelul: %s\n",a[i].model);
printf("\tculoarea: %s\n",a[i].cul);
printf("\tan fabr.: %d\n",a[i].an);
printf("\tnr locuri: %d\n",a[i].date.nl);
printf("\tputerea: %d\n\n",a[i].date.put);
}
}
void an(masini a,int n,int p)
{
int i;
for(i=0;i<n-1;i++)
{
if(a[i].an=p) //atribuire valori membrilor
structurii
{
 printf("Automobil [%d]:\n",i+1);
printf("\tmarca: %s\n",a[i].marca);
printf("\tmodelul: %s\n",a[i].model);
printf("\tculoarea: %s\n",a[i].cul);
printf("\tan fabr.: %d\n",a[i].an);
printf("\tnr locuri: %d\n",a[i].date.nl);
printf("\tputerea: %d\n\n",a[i].date.put);
}
}
}
void main()
{
masini a;
int n,aux,i,j,p;
citire(a,&n);
afisare(a,n);
for(i=0;i<n;i++)
{
if(a[i].date.nl=5) //atribuire valori membrilor
structurii
{
printf("Automobil [%d]:\n",i+1);
printf("\tmarca: %s\n",a[i].marca);
printf("\tmodelul: %s\n",a[i].model);
printf("\tculoarea: %s\n",a[i].cul);
printf("\tan fabr.: %d\n",a[i].an);
printf("\tnr locuri: %d\n",a[i].date.nl);
printf("\tputerea: %d\n\n",a[i].date.put);
}
}
for(i=0;i<n-1;i++)
for(j=i+1;j<n;j++)
{
if(a[i].date.put>a[j].date.put)
{
aux=i;
i=j;
j=aux;
}
}
afisare(a,n);
printf("\n\tDati anul dupa care vor fi afisate masinile: ");
scanf("%d",&p);
an(a,n,p);

getchar();
int k;
scanf("%d", &k);

Siruri
1) Să se realizeze un program care arată diferenţa dintre 'A' si "A".
#include<stdio.h>
#include<conio.h>
void main()
{
char a1='A';
char a2[]="A";
printf("%c %c %s",a1,a2[0],a2); //afisam continutul celor doua
variabile
printf("\n%d %d",sizeof(a1),sizeof(a2)); //verificam memoria ocupata de
cele doua variabile
printf("\n%s adica %d",a2[1],a2[1]); //vedem care este cel de-al
doilea element
getch();
}

2) Să se realizeze un program care afiseaza intr -un sir de caractere literele mari ale
alfabetului si face prelucrari asupra acestuia.
#include<stdio.h>
#include<string.h>
#include<conio.h>
void main()
{
char a[256];
for(int i=0;i<26;i++)
a[i]='A'+i;

puts("Sirul de caractere contine:");

printf("\"%s\"",a);

//dorim ca la sfarsit sa adaugam caracterul '1' si sa reafisez

sirului
a[26]='1';
a[27]='2';
a[28]=0;
printf("\n\"%s\"",a);

//afisez numarul de caractere ale sirului

printf("\nNumarul de caractere este %d",strlen(a));

//afisez sirul incepand cu al doilea element si pana la al zecelea

a[10]=0; //sau NULL
printf("\n\"%s\"",a+1); // !!! nu puneti a++
printf("\n\"%s\"",a+6);

//reafisez numarul de caractere ale sirului

printf("\nNumarul de caractere este %d",strlen(a));

/*introduc o noua variabila p care va retine adresa vectorului de

caractere a numele
 vectorului (a) este insusi o adresa si este aceeasi cu adresa
elementului prim, adica a[0]*/
char *p;
p=a; /*aceasta atribuire este corecta, variabila p retinand adresa
vectorului de caractere a, adica
adresa primului sau octet. In schimb, atribuirea a=p este incorecta
pt. ca a este o data constanta */

//dupa atribuire putem utiliza p in aceleasi conditii ca si a

printf("\n%s",p);
//patru relatii echivalente de afisare a adresei vectorului
printf("\n%p",p);
printf("\n%p",a);
printf("\n%p",&p[0]);
printf("\n%p",&a[0]);

/* daca la continutul variabilei p se adauga 1, aceasta va retine

adresa vectorului
al carui prim element coincide cu al doilea octet (element)
al vectorului */
printf("\n%s",++p); //p++; printf("\n%s",p);
printf("\n%s",p++);

//doua adrese echivalente

printf("\n%p",p);
printf("\n%p",&a[2]);

//noul vector se poate adresa si pe octeti

printf("\n%c",p[0]); //va afisa elementul 'C'
printf("\n%c",p[-2]); //va afisa elementul 'A'

/* se pot face si scaderi intre adrese. In acest caz rezultatul

este unul intreg
si prin p-a se obtine indicele in a al primului octet retinut in p
*/
printf("\n%d",p-a);

getch();
}

3) Diferenţa între tipul şir de elemente ce reprezintă caractere şi tipul adresă pentru
memorarea unui şir de caractere.
#include<stdio.h>
#include<string.h>
#include<conio.h>
void main()
{
char a[]="Salut C!"; // sir de elemente ce reprezinta caractere
char* b="Salut C!"; // tipul adresa pentru memorarea unui sir de
caractere
puts(a);
 puts(b);
printf("%d",sizeof(a));
printf("\n%d",sizeof(b));
getch();
}

4) Citindu-se un sir de la tastatura sa se afiseze caracter cu caracter si sa se

determine numarul de caractere şi dându-se un alt sir acesta sa se adauge sau sa se
copieze in primul sir.
#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#include<conio.h>
void main()
{
char* a; //sir introdus de utilizator
int i; //indexul sirului

a=(char*)malloc(sizeof(char)*255) ;

printf("Introduceti un sir de caractere si apoi apasati Enter\n");

gets(a); //scanf("%s",&a);

//Afiseaza fiecare caracter pana cand gaseste pe NULL

for(i=0;a[i]!=NULL;i++)
putchar(a[i]);
//sau printf("%c",a[i]);
printf("\nNumarul de caractere este %d adica %d",i,strlen(a)); //nu
se numara caracterul NULL

//doresc sa introduc un nou sir de caractere

char b[]=" alt sir";
strcat(a,b); //adaug sirul de adresa b la sirul a (realizez
concatenarea celor doua)
printf("\nNoul sir a este \"%s\"",a); // sau puts("Noul sir a
este"); puts(a);
strcpy(b,a); //copiaza sirul a in b
puts("\nNoul sir b este:");
puts(b);

//se compara cele doua siruri

printf("%d",strcmp(a,b));

getch();
}

5) Sa se determine numarul de cuvinte dintr -un text.

#include<stdio.h>
#include<string.h>
#include<conio.h>
void main()
{
int k=0;
char txt[1024]; //sir introdus de utilizator
char* p;
printf("Introduceti un sir de caractere si apoi apasati Enter\n");
gets(txt); //scanf("%s",&txt);

p=strtok(txt," ");
while (p!=NULL)
{
p=strtok(NULL, " ");
k++;
}
printf("\nNumarul de cuvinte este: %d",k); //nu se numara
caracterul NULL

getch();
}

6) Sa se determine numarul de cuvinte dintr -un text, folosind o functie proprie.

#include<stdio.h>
#include<string.h>
#include<conio.h>

int separare(char* txt, char* p)

{
int k=0;
p=strtok(txt," ");
while (p!=NULL)
{
p=strtok(NULL, " ");
k++;
}
return k;
}
void main()
{
int k;
char txt[1024]; //sir introdus de utilizator
char p;
printf("Introduceti un sir de caractere si apoi apasati Enter\n");
gets(txt); //scanf("%s",&txt);

printf("\nNumarul de cuvinte este: %d",separare(txt,&p)); //nu se

numara caracterul NULL

getch();
}
7) Să se realizeze un program care citeste intr -un sir n cuvinte. Acestea vor fi
sortate alfabetic.
#include<stdio.h>
#include<string.h>
#include<conio.h>
#include<stdlib.h>

/* Exista aplicatii in care este necesar sa se lucreze cu n cuvinte –

intelegand prin caracter
o succesiune de caractere care nu sunt albe. In acest caz avem
posibilitatea sa declaram vectori
de cuvinte. Acestea sunt, de fapt, matrice cu elemente de baza de tip
char. */

void main()
{
char cuvinte[10][25]; /* fiecare linie din cele 10 ale matricei poate
retine un sir de tipul char*.
Acesta poate avea cel mult 25 de caractere
(inclusiv caracterul nul).
Cuvintele pot fi adresate prin a[0] (primul cuvant), a[1]
(cuvantul al doilea) etc*/
char *aux;
int i,n,gasit;
printf("Dati numarul de cuvinte: ");
scanf("%d",&n);
for(i=0;i<n;i++)
{
printf("cuvant: ");
scanf("%s",&cuvinte[i]);
}
do
{
gasit=0;
for(i=0;i<n-1;i++)
if ( strcmp(cuvinte[i],cuvinte[i+1]) > 0 )
{
strcpy(aux,cuvinte[i]);
strcpy(cuvinte[i],cuvinte[i+1]);
strcpy(cuvinte[i+1],aux);
gasit=1;
}
} while (gasit);
for(i=0;i<n;i++)
printf("\n%s",cuvinte[i]);
getch();

}
Recursivitate
 Rezolvari

1) Să se calculeze n! in varianta iterativa.

#include<stdio.h>
long int factorial (int n)
{
long int f=1;
for (int i=1; i<=n;i++)
f=f*i;
return f;
}
void main()
{
int n;
printf("Introduceti n= ");
scanf("%d", &n);

if(!n)
printf("0!=1\n");
else
printf("%d!=%ld\n",n,factorial(n));

getchar();
int var;
scanf("%d", var);
}

2) Să se calculeze n! in varianta recursiva.

// factorial(3)=3*factorial(2)=3*2*factorial(1)=3*2*1
#include<stdio.h>
long int factorial (int n)
{
if (n==1) return 1;
else return n*factorial(n-1);
}
void main()
{
int n;
printf("Introduceti n= ");
scanf("%d", &n);

if(!n)
printf("0!=1\n");
else
printf("%d!=%ld\n",n,factorial(n));

getchar();
int var;
scanf("%d", var);
}
3) Să se calculeze recursiv suma elementelor unui sir.
#include<stdio.h>
int suma(int n)
{
if (n==0) return 0;
else return (n + suma(n-1));
}
void main()
{
int n;
printf("Introduceti n: ");
scanf("%d", &n);
printf("Suma elementelor este %d\n",suma(n));

getchar();
int var;
scanf("%d", var);
}

4) Scrieti o functie proprie care realizeaza calculul recursiv al sumei elementelor

unui vector, de n<=10, de nr reale. Scrieti functia main care citeste datele de la
tastatura, calculeaza suma, utilizand functia recursiva anterior definita si afiseaza
valoarea obtinuta.
#include <stdio.h>
#include <conio.h>

int a[10], n;
int Suma (int n, int a[10])
{
if(n==0) return 0;
else return(a[n]+Suma(n-1,a));
}
void main()
{
// Citire date de intrare
printf("Introduceti nr de elemente: ");
scanf("%d", &n);
for (int i=1; i<=n; i++)
{
printf("Elementul [%d] = ", i);
scanf("%d", &a[i]);
}
// Afisarea rezultatelor
printf("Suma = %d", Suma(n,a));

getch();
}
5) Să se scrie un program C, pentru rezolvarea cmmdc -ului dintre două numere
întregi fără semn (pentru determinarea cmmdc -ului vom folosi algritmul lui Euclid
prin scăderi). Varianta iterativa.
#include <stdio.h>
#include <conio.h>

unsigned int cmmdc(unsigned int a, unsigned int b)

{
while(a!=b)
{
if(a>b)
a=a-b;
else
b=b-a;
}
return a;
}
void main()
{
unsigned int x,y;
printf("Introduceti x: ");
scanf("%u",&x);
printf("Introduceti y: ");
scanf("%u",&y);

if(!x || !y) //daca x=0 sau y=0

printf("cmmdc(%u,%u) = 1\n",x,y);
else
printf("cmmdc(%u,%u) = %u\n",x,y,cmmdc(x,y));

getch();
}

6) Să se scrie un program C, pentru rezolvarea cmmdc -ului dintre două numere

întregi fără semn (pentru determinarea cmmdc -ului vom folosi algritmul lui Euclid
prin scăderi). Varianta recursiva.
#include <stdio.h>
#include <conio.h>

unsigned int cmmdc(unsigned int a, unsigned int b)

{
if(a==b) return a;
else
if(a>b) return cmmdc(a-b,b);
else return cmmdc(a,b-a);
}
void main()
{
 unsigned int x,y;
printf("Introduceti x: ");
scanf("%u",&x);
printf("Introduceti y: ");
scanf("%u",&y);

if(!x || !y) //daca x=0 sau y=0

printf("cmmdc(%u,%u) = 1\n",x,y);
else
printf("cmmdc(%u,%u) = %u\n",x,y,cmmdc(x,y));

getch();
}

7) Să se scrie un program C, pentru rezolvarea cmmdc -ului a n numere întregi fără

semn (pentru determinarea cmmdc-ului vom folosi algritmul lui Euclid prin
scăderi). Varianta recursiva.
#include <stdio.h>
#include <conio.h>

unsigned int cmmdc_2(unsigned int a, unsigned int b)

{
if(a==b) return a;
if(a>b) return cmmdc_2(a-b,b);
else
return cmmdc_2(a,b-a);
}
unsigned int cmmdc_n(unsigned int x[], int n)
{
if (n==2) return cmmdc_2(x[0],x[1]);
else return cmmdc_2(cmmdc_n(x,n-1),x[n-1]);
}
void main()
{
unsigned int x[20];
int n;
printf("Introduceti n: ");
scanf("%d",&n);
for(int i=0;i<n;i++)
{
printf("elementul %d= ",i+1);
scanf("%u",&x[i]);
}
if (n==1)
printf("\nCmmdc-ul numerelor: %u",x[0]);
else
printf("\nCmmdc-ul numerelor: %u",cmmdc_n(x,n));

getch();
}
8) Se considera urmatoarele declaratii şi conventii:
typedef int vector[20]; x – este un vector (sir de elemente) n – este lungimea sa
(n>=1)
Se cere sa se scrie functii recursive pentru a determina, pentru un vector x de
lungime n, urmatoarele:
a. citirea componentelor sirului
b. afisarea elementelor din sir
c. suma componentelor
d. produsul componentelor
e. numarul componentelor negative
f. produsul componentelor pozitive
g. media aritmetica a elementelor
#include<stdio.h>
#include<conio.h>
/* un tip propriu definit pentru memorarea sirurilor de elemente intregi,
cu o
dimensiune maxima de 20 de componente */
typedef int vector[20];
//functia de citire
void citire(vector x,int n) //n este dimensiunea reala a sirului
{
//citim ultimul element din sir
printf("\telementul %d: ",n);
scanf("%d",&x[n-1]);
if(n>=2)
citire(x,n-1); //apelul recursiv al functiei
}
//functia de afisare
void afisare(vector x,int n) //n este dimensiunea reala (nr. de elem. din
sir)
{
//afisam ultimul element
printf("%d ",x[n-1]);
if(n>=2)
afisare(x,n-1); //apelul recursiv al functiei
}
//adunarea componentelor unui sir
int suma(vector x,int n) //n in acest caz il consideram fiind indice
element dinsir
{
if(n==-1) return 0; //situatia in care nu mai sunt elemente in sir,
pozitia n=-1 nefiind in sir
else return x[n]+suma(x,n-1);
}
//produsul componentelor
int produs(vector x,int n)
{
if(n==-1) return 1;
else return x[n]*produs(x,n-1);
}
//numarul de componente negative
int numar_negative(vector x,int n)
{
//ne pozitionam pe primul element din sir si verificam dc acesta
este negativ
if(n==0) return (x[n]<0); //expresia conditionata va returna 1 in caz de
adv. si 0 in caz de fals
else return (x[n]<0)+numar_negative(x,n-1);
}
//produsul componentelor pozitive
int produs_pozitive(vector x,int n)
{
if(n==0) return (x[n]>0?x[n]:1); /* am folosit operatorul de
conditionare,
care, daca expresia evaluata ca fi adv. se va lua in calcul x[n],
altfel,
valoarea 1 */
else return (x[n]>0?x[n]:1)*produs_pozitive(x,n-1);
}
//media aritmetica a componentelor sirului
float media(vector x, int m, int n) //cu m am notat indicele elementelor,
iar cu n dimensiunea reala a sirului
{
return (float)x[m]/n + ((m!=0)?media(x,m-1,n):0);
/* - am folosit expresia (float) pentru o conversie explicita a
rezultatului
spre un tip real
- prin x[m]/n intelegem un element (in prima faza, acesta fiind
ultimul
element din sir) impartit la numarul total de componente */
}
//functia principala in rulare
void main()
{
vector x; //sirul de elemente
int n; //dimensiunea sa (numarul de componente citite)

//realizarea operatiei de citire a sirului

printf("Dati numarul de elemente: ");
scanf("%d",&n);
printf("Introduceti elementele sirului:\n");
citire(x,n);

//realizarea operatiei de afisare a sirului

printf("Sirul de elemente este: ");
afisare(x,n);

//sumarea elementelor
 printf("\nSuma elementelor: %d",suma(x,n-1)); /* am apelat cu n-1,
ptr ca am
spus mai sus ca acest
parametru reprezinta
indicele ultimului element din
sir */
//produsul elementelor
printf("\nProdusul elementelor: %d",produs(x,n-1));
//numarul elementelor negative din sir
printf("\nNumarul elementelor negative: %d",numar_negative(x,n-1));
//produsul componentelor pozitive
printf("\nProdusul elementelor pozitive: %d",produs_pozitive(x,n-
1));
//media componentelor din sir
printf("\nMedia componentelor din sir: %.2f",media(x,n-1,n)); /*
primul parametru - sirul,
al doilea parametru - indicele
ultimului element din sir, al treilea
parametru - dimensiunea reala a
sirului (numarul de elemente citite) */
getch();
}

9) Sa se scrie o functie recursiva pentru determinarea sumei cifrelor unui numar

natural. Indicatie: Se izoleaza ultima cifra, iar lui n i se atribuie câtul întreg dintre
vechea valoare şi 10.
#include<stdio.h>
#include<conio.h>

int suma(int n)
{
if(!n) return 0; //!n=daca nu exista n
else return n%10+suma(n/10);
}
void main()
{
int n;
printf("Introduceti numarul: ");
scanf("%d", &n);

printf("Suma cifrelor numarului este: %d", suma(n));

getch();
}

10) Sa se scrie o functie recursiva pentru a transforma un numar natural n, din baza
10 în baza k (1<k<=10). Indicatie: Numarul se împarte la k, se retine restul, câtul se
împarte la k, se retine restul... pâna când câtul este mai mic decât împartitorul.
Rezultatul se obtine prin scrierea în ordine inversa a resturilor obtinute. Tiparirea
restului se face dupa autoapel.
#include<stdio.h>
#include<conio.h>

void transform(int n,int b)

{
int rest=n%b;
if (n>=b) transform(n/b,b);
printf("%d",rest);
}
void main()
{
int n,b;
printf("n="); scanf("%d",&n);
printf("baza="); scanf("%d",&b);
transform(n,b);
getch();
}

11) Se citeste x din Z . Se cere subprogramul pentru calculul functiei Manna -

Pnuelli:
x-1, x>=12
F(x)=
F(F(x+2)), x<12
#include<stdio.h>
#include<conio.h>

int F(int x)
{
if (x>=12) return x-1;
return F(F(x+2));
}
void main()
{
int x;
printf("x="); scanf("%d",&x);
printf("Valoarea functiei este: %d",F(x));

getch();
}

12) Se considera sirul lui Fibonacci (Un) definit astfel:

0, n=0
Un= 1, n=1
 Un-1+Un-2, altfel
Se citeste n, un numar natural. Sa se calculeze Un, in varianta iterativa.
#include<stdio.h>
#include<conio.h>

void main()
{
int n,U0=0,U1=1,U2;
printf("n="); scanf("%d",&n);
if(!n) printf("%d",U0);
else
if (n==1) printf("%d",U1);
else
{
for (int i=2;i<=n;i++)
{
U2=U0+U1;
U0=U1;
U1=U2;
}
printf("%d",U2);
}
/*
ptr. n=3
i=2: U2=U0+U1
U0=U1
U1=U2
i=3: U2=U1+U2
*/
getch();
}

13) Se considera sirul lui Fibonacci (Un) definit astfel:

0, n=0
Un= 1, n=1
Un-1+Un-2, altfel
Se citeste n, un numar natural. Sa se calculeze Un, in varianta recursiva.
#include<stdio.h>
#include<conio.h>

int U (int n)
{
if (!n) return 0;
else if (n==1) return 1;
else return U(n-1)+U(n-2);
}

void main()
{
int n;
printf("Introduceti n=");
scanf("%d",&n);

printf("Valoarea sirului in n este: %d",U(n));

getch();

Instructiuni

24) Sa se transforme un numar din baza 10 în baza p<10 (rezolvare...)

Rezolvari

1) Sa se scrie un program care executa operatia aritmetica dorita (+, -,/,*).

#include<stdio.h>
void main()
{
int a,b;
printf("Introduceti a: ");
scanf("%d", &a);
printf("Introduceti b: ");
scanf("%d", &b);
char x;
getchar();
printf("Introduceti operatia dorita (+ - * /): ");
scanf("%c", &x);
switch(x)
{
case '+': printf("a+b= %d", a+b); break;
case '-': printf("a-b= %d", a-b); break;
case '/': printf("a/b=%.2f",a/(float)b); break;
case '*': printf("a*b= %d", a*b); break;
default: printf("Operatie necunoscuta");
}
getchar();
int k;
scanf("%d", k);
}

2) Sa se scrie un program care calculeza suma primelor n numere naturale cu "for".

#include<stdio.h>
void main()
{
int n,s=0;
printf("Introduceti n:");
scanf("%d",&n);
for(int i=1;i<=n;i++)
s+=i; //s=s+i;
printf("Suma primelor %d numere naturale este: %d\n",n,s);

getchar();
int k;
scanf("%d", k);
}

3) Sa se scrie un program care calculeaza suma primelor n numere naturale cu

"while".
#include<stdio.h>

void main()
{
int n, s=0, i=1;
printf("Introduceti n:");
scanf("%d",&n);

while(i<=n)
{
s+=i; //s=s+i;
i++;
}

printf("Suma primelor %d numere naturale este: %d\n",n,s);

getchar();
int k;
scanf("%d", k);
}

4) Sa se scrie un program care calculeaza suma primelor n numere naturale cu "do

while".
#include<stdio.h>

void main()
{
int n, s=0, i=1;
printf("Introduceti n:");
scanf("%d",&n);

do
 {
s+=i; //s=s+i;
i++;
}
while(i<=n)

printf("Suma primelor %d numere naturale este: %d\n",n,s);

getchar();
int k;
scanf("%d", k);
}

5) Sa se scrie un program care rezolva ecuatia de gradul al II -lea.

#include <stdio.h>
#include <math.h>
void main (void)
{
int a,b,c;
float x1,x2,d;
printf("Introduceti coeficientii ecuatiei.\n");
printf("\ta="); scanf("%d",&a);
printf("\tb="); scanf("%d",&b);
printf("\tc="); scanf("%d",&c);
if(!a) //a==0
if(!b)
if(!c)
printf("Ecuatia are o infinitate de
solutii.");
else
printf("Ecuatia nu are nici o solutie.");
else
{
x1=-c/(float)b;
printf("Solutia ec. este: %.2f.",x1);
}
else
x1=-c/(float)b;
printf("Solutia ec. este: %.2f.",x1);

{
d=b*b-4*a*c;
if(d<0)
printf("Ec nu are solutii reale.");
else
{
x1=(-b-sqrt(d))/2*a;
printf("Solutiile sunt:\n\tx1 este:
%.2f\n",x1);
x2=(-b+sqrt(d))/2*a;
printf("\tx2 este: %.2f\n",x2);
}
 }

getchar();
int k;
scanf("%d", k);
}

6) sa se scrie un program care calculeaza valoarea expresiei S=1 -2+3-4+....+,

folosind functii proprii.
#include <stdio.h>

int suma1(int n) //cu instructiunea FOR

{
int s=0, i=1, semn=1;
for(; i<=n; i++)
{
s+=semn*i; //s=s+semn*i
semn=-semn;
}
return s;
}

int suma2(int n) //cu instructiunea WHILE

{
int s=0, i=1, semn=1;
while (i<=n)
{
s+=semn*i; //s=s+semn*i
semn=-semn;
i++;
}
return s;
}

int suma3(int n) //cu instructiunea DO WHILE

{
int s=0, i=1, semn=1;
do
{
s+=semn*i; //s=s+semn*i
semn=-semn;
i++;
}
while (i<=n);
return s;
}

void main()
{
int n;
printf("Introduceti n:");
 scanf("%d", &n);

printf("\n\tSuma calculata cu FOR are valoarea: %d" , suma1(n));

printf("\n\tSuma calculata cu WHILE are valoarea: %d" , suma2(n));
printf("\n\tSuma calculata cu DO WHILE are valoarea: %d" ,
suma3(n));

getchar();
int k;
scanf("%d", k);
}

7) Sa se scrie un program care calculeaza valoarea expresiei: P=1*2*3*4*...*n.

#include<stdio.h>
int produs1(int n) //cu instructiunea FOR
{
int P=1;
for(int i=1; i<=n; i++)
P=P*i;
return P;
}
int produs2(int n) //cu instructiunea WHILE

{
int P=1; int i=1;
while(i<=n)
{
P=P*i;
i++;
}
return P;
}
int produs3(int n) //cu instructiunea DO WHILE
{
int P=1; int i=1;
do{
P=P*i;
i++;
}
while(i<=n);
return P;
}
void main()
{
int n;
printf("Introduceti n: ");
scanf("%d", &n);
printf("\n\tProdusul calculat cu FOR are valoarea: %d.\n" ,
produs1(n));
printf("\n\tProdusul calculat cu WHILE are valoarea: %d.\n" ,
produs2(n));
 printf("\n\tProdusul calculat cu DO WHILE are valoarea: %d.\n" ,
produs3(n));

getchar();
int k;
scanf("%d", k);
}

8) Sa se scrie un program care calculeaza valoarea expresiei:

P=1*(1/2)*3*(1/4)*5*(1/6)*...n
#include<stdio.h>
#include<math.h>
float produs1(int n) //cu instructiunea FOR
{
float p=1;
float z=1;

for(int i=1; i<=n; i++)

{
if (!(i%2)) //se mai putea scrie if(i%2==0) <=> testeaza
dc nu e impar
{
z=1/(float)i;
p=p*z;
}

else p=p*i; //pt impar

}
return p;
}
float produs2(int n) //cu instructiunea WHILE
{
float p=1;
float z=1;
int i=1;
while(i<=n)
{
if (!(i%2)) //se mai putea scrie if(i%2==0) <=> testeaza
dc nu e impar
{
z=1/(float)i;
p=p*z;
}
else p=p*i; //pt impar
i++;
}
return p;
}
float produs3(int n) //cu instructiunea WHILE
{
float p=1;
 float z=1;
int i=1;
do
{
if (!(i%2)) //se mai putea scrie if(i%2==0) <=> testeaza
dc e par
{
z=1/(float)i;
p=p*z;
}

else p=p*i; //pt impar

i++;
}
while(i<=n);
return p;
}
void main()
{
int n;
printf("Introduceti n: ");
scanf("%d", &n);

printf("\nProdusul cu FOR este: %.5f\n", produs1(n));

printf("\nProdusul cu WHILE este: %.5f\n", produs2(n));
printf("\nProdusul cu DO WHILE este: %.5f\n", produs3(n));

getchar();
int k;
scanf("%d", k);
}

9) Sa se scrie un program care calculeaza valoarea expresiei:

S=1+1*2+1*2*3+1*2*3*4+1*2*3*4*5+...+1*2*...*n.
#include<stdio.h>
void main()
{
int n;
int s=0;
int p=1;

printf("Introduceti n:");
scanf("%d", &n);

for(int i=1; i<=n; i++)

{
p=p*i;
s=s+p;
}
printf("Rezutatul este: %d", s);
 getchar();
int k;
scanf("%d", k);
}

10) Sa se scrie un program care calculeaza x la puterea y (folosind functia pow).

#include <math.h>
#include<stdio.h>
void main()
{
double x, y, z;

printf("\nIntroduceti coeficientul: ");

scanf("%lf", &x);
printf("\nAti introdus x= %.2lf", x);

printf("\n\nIntroduceti puterea: ");

scanf("%lf", &y);
printf("\nAti introdus y= %.2lf", y);

z=pow(x,y);

printf("\n\n\%.2lf^%.2lf= %.2lf", x,y,z);

getchar();
int k;
scanf("%d", k);
}

11) Se citeste un text format din cuvinte ce pot fi despartite prin spatiu sau virgula.
Textul citit se termina cu punct sau enter. Sa se contorizeze vocalele si consoanele
din acel text.
#include<stdio.h>
void main()
{
int v=0;
int c=0;

printf("Introduceti textul dorit: ");

char k;
k=getchar(); //citeste un carater, care va fi primul din text, care va fi
trimis variabilei k

while(k!='.' && k!='\n')

{
if (k!=',' && k!=' ')
switch (k)
 {
case 'a':
case 'A':
case 'e':
case 'E':
case 'i':
case 'I':
case 'o':
case 'O':
case 'u':
case 'U': v++;
break;
default: c++;
}
k=getchar(); //urmatorul caracter din text va fi trimis in
variabila k
}
printf("Numarul de vocale este: %u\n",v);
printf("Numarul de consoane este: %u\n",c);

getchar();
int z;
scanf("%d", z);
}

12) Se citeste un text format din cuvinte ce pot fi despartite prin spatiu sau virgula.
Textul citit se termina cu punct sau enter. Sa se contorizeze vocalele si consoanele
din acel text. Sa se rezolve problema folosind o bucla repetitiva conditionata
posterior.
#include<stdio.h>
void main()
{
int v=0;
int c=0;
printf("Introduceti textul dorit: ");
char k;

do
{
k=getchar();
if (k!=',' && k!=' ' && k!='\n' && k!='.')
switch (k)
{
case 'a':
case 'A':
case 'e':
case 'E':
case 'i':
case 'I':
 case 'o':
case 'O':
case 'u':
case 'U': v++;
break;
default: c++;
}
}

while(k!='.' && k!='\n');

printf("Numarul de vocale este %u\n",v);

printf("Numarul de consoane este %u\n",c);

getchar();
int z;
scanf("%d", z);
}

13) Sa se contorizeze numarul de vocale si cel de consoane din alfabet, folosind

instructiunea de salt "goto".
#include<stdio.h>
void main()
{
int v=0;
int c=0;
char litera='A';
eticheta:
switch (litera)
{

case 'A':
case 'E':
case 'I':
case 'O':
case 'U': v++;
break;
default: c++;
}
litera++;
if(litera<='Z') goto eticheta;
printf("Numarul de vocale este %d\n",v);
printf("Numarul de consoane este %d\n",c);

getchar();
int var;
scanf("%d", var);
}
14) Sa se afiseze din intregul alfabet doar literele caractere mari pana la 'M'. Bucla
se va incheia in mod voit, prin folosirea instructiunii "break".
#include<stdio.h>
void main()
{
for(char litera='A'; litera<='Z'; litera++)
{
if(litera=='M') break;
printf("%c", litera);
}
getchar();
int var;
scanf("%d", var);
}

15) Sa se transforme un numar din baza 10 intr -o baza p, 2<=p<=10.

/* Vom împarti succesiv pe x (numarul dat) la p, retinând cifrele din baza p

într-un
numar xpi, care va fi apoi rasturnat, pentru a obtine numarul xp, vazut ca
reprezentarea în baza p a lui x. Pentru a nu avea probleme în cazul în care
prima
cifra a lui xpi ar fi 0, folosim o incrementare cu 1 a cifrelor la
transformarea
x->xpi, respectiv o decrementare la transformarea xpi->xp. */

#include<stdio.h>
void main ()
{
int x,xpi,xp,p;
printf ("Dati x in baza 10:");
scanf ("%d",&x);
printf("Dati noua baza p:");
scanf("%d",&p);
//un alt mod de a scrie o instructiune for
for (xpi=0; x; xpi=10*xpi+x%p+1,x=x/p);
for (xp=0; xpi; xp=10*xp+(xpi-1)%10,xpi=xpi/10);
printf("Numarul in baza %d este:%d",p,xp);

getchar();
int var;
scanf("%d", var);
}

/* De remarcat, in acest exemplu, folosirea operatorului "," in cadrul

instructiunii for. De pilda, primul for se interpreteaza astfel:
- se initializeaza xpi cu 0;
- cat timp x este diferit de 0 executa:
- xpi devine 10*xpi+x%p+1
- x se imparte la p (si se face conversia la int).*/
16) Sa se realizeze un program care intr-o bucla "while" calculeaza suma cifrelor
unui numar introdus de la tastatura si afiseaza inversul lui.
#include<stdio.h>
#include<math.h>
void main()
{
int nr;
int s=0; //suma cifrelor
int inv=0; //inversul numarului
printf("Introduceti numarul: ");
scanf("%d",&nr);
while (nr) //sau while(n!=0)
{
s=s+nr%10;
inv=inv*10+nr%10;
nr/=10;
}
/* instructiunea repetitiva de mai sus se mai putea scrie si asa:
while(ninv*=10,ninv+=n%10,s+=n%10,n/=10); */
printf("Suma este: %d",s);
printf("\nInversul este: %d",inv);

getchar();
int var;
scanf("&d", var);
}

17) Fiind furnizate 3 numere intregi sa se verifice daca acestea pot fi masurile unui
triunghi, si in caz afirmativ sa se calculeze perimetrul.
#include<stdio.h>
int triunghi(int a,int b,int c)
{
if((a>0)&&(b>0)&&(c>0)&&(a<b+c)&&(b<a+c)&&(c<a+b))
return 1;
else
return 0;
}
void main()
{
int a,b,c,s=0;
printf("a= ");scanf("%d",&a);
printf("b= ");scanf("%d",&b);
printf("c= ");scanf("%d",&c);
if(triunghi(a,b,c)==1)
{
s=a+b+c;
printf("Perimetrul triunghiului ABC este: %d",s);
}
else
 printf("Nu este triunghi");

getchar();
int var;
scanf("&d", var);
}

18) Sa se calculeze valoarea functiei f definita pe multimea numerelor reale pentru

un x citit:
| x-3, ptr. x<5
F=| x+1, ptr. 5>x>25
| x-5x+6,ptr. x>25
#include<stdio.h>
void main()
{
int x;
printf("Introduceti numarul: ");
scanf("%d",&x);

if(x>=5&&x<=25)
printf("F(x)= %d",x+1);
else
{
if(x<5)
printf("F(x)= %d",x-3);
else
printf("F(x)= %d",x-5*x+6);
}
getchar();
int var;
scanf("&d", var);
}

19) Sa se afiseze suma cifrelor unui numar natural dat. Indicatie: se detaseaza
fiecare cifra de la sfarsitul numarului calculand restul impartirii numarului la 10;
numarul ramas dupa desprinderea cifrei este catul impartirii la 10.
#include<stdio.h>
void main()
{
int n,s=0;
printf("n= ");scanf("%d",&n);
while(n!=0)
{
s=s+n%10;
n=n/10;
}
printf("Suma cifrelor este: %d",s);
 getchar();
int var;
scanf("&d", var);
}

20) Sa se calculeze suma S=1!+2!+3!+…+n!

#include<stdio.h>
int factorial(int n)
{
int p=1;
for(int i=1;i<=n;i++)
p*=i;
return p;
}
void main()
{
int m,i,s=0;
printf("\n\tIntroduceti nr: ");scanf("%d",&m);
for(i=1;i<=m;i++)
s=s+factorial(i);
printf("\tSuma este: %d",s);
getchar();
int var;
scanf("&d", var);
}

21) Sa se calculeze produsul: P=2*4*6*8*10*…*n, unde n=2k.

#include<stdio.h>
void main()
{
int n,i,p=1;
printf("Introduceti nr: ");
scanf("%d",&n);
n=n*2;

for(i=2;i<=n;i++)
{
if (!(i%2)) //se mai putea scrie if(i%2==0) <=> testeaza
dc e par
p*=i;
}
printf("Produsul este: %d",p);
getchar();
int var;
scanf("&d", var);
}

22) Sa se calculeze suma S=1^2+2^2+3^2+4^2+...+n^2.

#include<stdio.h>
void main()
{
int n,s=0,i;
printf("n= ");
scanf("%d",&n);

for(i=1;i<=n;i++)
s=s+i*i;

printf("Suma este egala cu: %d",s);

getchar();
int var;
scanf("&d", var);
}

23) Sa se calculeze suma S=1-1*2+1*2*3-...±1*2*3*...*n.

#include<stdio.h>
int factorial(int n)
{
int p=1;
for(int i=1;i<=n;i++)
p*=i;
return p;}

void main()

{
int n,i,s=0,semn=1;
printf("n= ");scanf("%d",&n);
for(i=1;i<=n;i++)
{
s=s+semn*factorial(i);
semn=-1;
}
printf("Suma este egala cu: %d",s);

getchar();
int var;
scanf("&d", var);
}

24) Sa se transforme un numar din baza 10 în baza p<10.

#include<stdio.h>
void main()
{
int n,m,p,y=0,c;
printf("Nr in baza 10 este: ");scanf("%d",&n);
 printf("Baza in care se converteste: ");scanf("%d",&p);

while(n!=0)
{
c=n%p;
y=y*10+c;
n=n/p;
}

printf("Nr. in baza %d este: %d",p,y);

getchar();
int var;
scanf("&d", var);
}