Arbori #include <stdio.h> #include <malloc.

h> typedef struct celltype { int value; struct celltype *left, *right; } tree_element; int inserare(int val, tree_element **ppvarf) { if (*ppvarf) { if (val <= (*ppvarf)->value) return inserare(val, &((*ppvarf)->left)); else return inserare(val, &((*ppvarf)->right)); } *ppvarf = (tree_element*)malloc(sizeof(tree_element)); if (*ppvarf == NULL) { printf("eroare la alocare!\n"); return -1; } (*ppvarf)->value = val; (*ppvarf)->left = (*ppvarf)->right = NULL; return 0; } int stergere(int val, tree_element **ppvarf) { tree_element *q; tree_element **pp; if (*ppvarf == NULL) { printf("nu s-a gasit elementul %d in arbore\n", val); return 0; } if (val < (*ppvarf)->value) return stergere(val, &((*ppvarf)->left)); else if (val > (*ppvarf)->value) return stergere(val, &((*ppvarf)->right)); pp = &((*ppvarf)->left); while (*pp)

pp = &((*pp)->right); *pp = (*ppvarf)->right; q = *ppvarf; *ppvarf = (*ppvarf)->left; free(q); return 0; } int traversareSRD(tree_element *pvarf) { if (pvarf) { traversareSRD(pvarf->left); printf("%d ", pvarf->value); traversareSRD(pvarf->right); } return 0; } int traversareSDR(tree_element *pvarf) { if (pvarf) { traversareSDR(pvarf->left); traversareSDR(pvarf->right); printf("%d ", pvarf->value); } return 0; } int traversareRSD(tree_element *pvarf) { if (pvarf) { printf("%d ", pvarf->value); traversareRSD(pvarf->left); traversareRSD(pvarf->right); } return 0; }

int main() { tree_element *pvarf = NULL; int ret_val = 0, optiune, val; while (ret_val >= 0)

{ printf("\n1. inserare element in arbore\n"); printf("2. traversare SRD\n"); printf("3. traversare SDR\n"); printf("4. traversare RSD\n"); printf("5. stergere element\n"); printf("9. iesire\n"); printf("introduceti optiunea dvs:"); scanf("%d", &optiune); switch(optiune) { case 1: printf("introduceti elementul de inserat: "); scanf("%d", &val); ret_val = inserare(val, &pvarf); break; case 2: ret_val = traversareSRD(pvarf); break; case 3: ret_val = traversareSDR(pvarf); break; case 4: ret_val = traversareRSD(pvarf); break; case 5: printf("introduceti elementul de sters: "); scanf("%d", &val); ret_val = stergere(val, &pvarf); break; case 9: return 0; } } } Aranjamente #include<stdio.h> #include<conio.h> int a[50],k,n; void tipareste() { int i; for(i=1;i<=k;i++) printf("%d",a[i]); putchar('\n'); } int valid(int x)

{ int i; for(i=1;i<x;i++) if(a[x]==a[i]) return(0); return 1; } void aranjamente(int i) { int j; for(j=1; j<=n; j++) { a[i]=j; if(valid(i)==1) if(i==k) tipareste(); else aranjamente(i+1); } } void main(void) { printf("Aranjamente de : "); scanf("%d",&n); printf("Luate cate: "); scanf("%d",&k); aranjamente(1); } Backtracking bancnote #include <stdio.h> int n, suma, p, b[100], i; void main(void) {

printf("n="); scanf("%d", &n); for(i=0;i<n;i++) { printf("b[%d]=",i); scanf("%d",&b[i]); } printf("Introduceti suma de bani:"); scanf("%d", &suma); for(i=0; i<n; i++) { p=suma/b[i]; //p imi retine de cate ori se cuprinde bancnota i in suma de bani; suma=suma%b[i]; printf("suma are %d bancnote de %d lei\n", p, b[i]);

} } BK calul #include<stdio.h> #include<conio.h> int a[8]={2,1,-1,-2,-2,-1,1,2}, b[8]={1,2,2,1,-1,-2,-2,-1}; int t[10][10],m,n; void tipareste(void) { int p,r; for(p=0;p<m;p++) { for(r=0; r<n; r++) printf("%3d",t[p][r]); putchar('\n'); } getch(); } void cal(int i, int j, int k) { int i1,j1,d; for(d=0;d<8;d++) { i1=i+a[d]; j1=j+b[d]; if((i1<m)&&(j1<n)&&(i1>=0)&&(j1>=0)&&(!t[i1][j1])) { t[i1][j1]=k; if(k<m*n) cal(i1,j1,k+1); else { tipareste(); putchar('\n'); t[i1][j1]=0; } } } t[i][j]=0; } void main(void) { int i,j;

printf("Introdu nr de lin: "); scanf("%d",&m); printf("Introdu nr de col: "); scanf("%d",&n); for(i=0;i<m;i++) for(j=0;j<n;j++) t[i][j]=0; t[0][0]=1; cal(0,0,2); } Backtracking Combi #include<stdio.h> #include<conio.h> int a[50],n,k; void tipareste() { int i; for(i=1;i<=n;i++) printf("%d",a[i]); putchar('\n'); } void combinari(int x) { int i; for(i=a[x-1]+1;i<=n-k+x;i++) { a[x]=i; if(x==k) tipareste(); else combinari(x+1); } } void main(void) { clrscr(); printf("dati nr de combinari: "); scanf("%d",&n); printf("dati nr de elem luate: "); scanf("%d",&k); combinari(1); } Bk combinari #include<stdio.h> #include<conio.h> int m,n,a[20]; void tipareste(void) { int i; for(i=0;i<n;i++) printf("%d",a[i]+1);

putchar('\n'); } void combinari(int k) { int i; for(i=0;i<m;i++) { a[k]=i; if((k==0)||(a[k]>a[k-1])) if(k==n-1) tipareste(); else combinari(k+1); } } void main(void) { printf("Combinari de: "); scanf("%d",&m); printf("Luate cate: "); scanf("%d",&n); combinari(0); getch(); } Bk descompunerea unui nr nat #include<stdio.h> #include<conio.h> int a[10], n; void tipareste(int nr) { int i; printf("%d= %d",n,a[1]); for(i=2; i<=nr; i++) printf(" + %d",a[i]); putchar('\n'); } int valid(int i, int s) { if(s+a[i]<=n) return 1; return 0; } void bkr(int i, int s) { int j; for(j=1; j<=n-s; j++) { a[i]=j;

if(valid(i,s)==1) if(s+a[i]==n) tipareste(i); else bkr(i+1,s+a[i]); } } void main(void) { printf("Introduceti numarul: "); scanf("%d",&n); bkr(1,0); } Bk generarea partilorunei multimi #include<stdio.h> #include<conio.h> int a[10], n; void tipareste(int nr) { int i; printf("{ %d",a[1]); for(i=2;i<=nr; i++) printf(", %d",a[i]); printf(" }"); putchar('\n'); } void bkr(int i) { int j; for(j=a[i-1]+1; j<=n; j++) { a[i]=j; tipareste(i); bkr(i+1); } } void main(void) { printf("Introduceti numarul: "); scanf("%d",&n); printf("\n"); a[0]=0; printf("{ }\n"); bkr(1); }

Bk labirint #include<stdio.h> #include<conio.h> int a[10][10], rez[10][10], n; void scrie(void) { int i,j; for(i=0;i<n;i++) { for(j=0;j<n;j++) printf("%4d",rez[i][j]); putchar('\n'); } putchar('\n'); getch(); } void labirint(int x, int y) { if((x==0)||(x==n-1)||(y==0)||(y==n-1)) { rez[x][y]=1; scrie(); } else { if((x+1<n)&&(rez[x+1][y]==0)&&(a[x+1][y]==1)) { rez[x+1][y]=1; labirint(x+1,y); rez[x+1][y]=0; } if((x-1>=0)&&(rez[x-1][y]==0)&&(a[x-1][y]==1)) { rez[x-1][y]=1; labirint(x-1,y); rez[x-1][y]=0; } if((y-1>=0)&&(rez[x][y-1]==0)&&(a[x][y-1]==1)) { rez[x][y-1]=1; labirint(x,y-1); rez[x][y-1]=0; } if((y+1<n)&&(rez[x][y+1]==0)&&(a[x][y+1]==1)) { rez[x][y+1]=1; labirint(x,y+1);

rez[x][y+1]=0; } } } void main(void) { int i,j,xi,yi; printf("Introdu dimensiunea matricii:"); scanf("%d",&n); printf("Introdu valorile matricii labirint:\n"); for(i=0;i<n;i++) for(j=0;j<n;j++) { printf("a[%d][%d]=",i,j); scanf("%d",&a[i][j]); rez[i][j]=0; } printf("Introdu linia de pornire:"); scanf("%d",&xi); printf("Introdu coloana de pornire: "); scanf("%d",&yi); rez[xi][yi]=1; labirint(xi,yi); } Bk mingea #include<stdio.h> #include<conio.h> int a[8]={1,1,0,-1,-1,-1,0,1}, b[8]={0,1,1,1,0,-1,-1,-1}; int tablou[10][10], drum[10][10], m, n; void tipareste() { int p,r; for(p=0;p<m;p++) { for(r=0;r<n; r++) printf("%3d",drum[p][r]); putchar('\n'); } putchar('\n'); getch(); } void minge(int i, int j) { int i1, j1, d;

if((i==0)||(i==m-1)||(j==0)||(j==n-1)) { tipareste(); drum[i][j]=0; } else for(d=0;d<8;d++) { i1=i+a[d]; j1=j+b[d]; if((i1<m)&&(j1<n)&&(i1>=0)&&(j1>=0)&&(tablou[i1][j1]<tablou[i][j])&&( !drum[i1][j1])) { drum[i1][j1]=1; minge(i1,j1); drum[i1][j1]=0; } } drum[i][j]=0; } void main(void) { int i,j,xi,yi; printf("Introdu nr de linii: "); scanf("%d",&m); printf("Introdu nr de coloane: "); scanf("%d",&n); printf("Introdu cotele: \n"); for(i=0;i<m;i++) for(j=0;j<n;j++) { drum[i][j]=0; printf("tabloul[%d][%d]= ",i,j); scanf("%d",&tablou[i][j]); } printf("Introdu linia de pornire: "); scanf("%d",&xi); printf("Introdu coloana de pornire: "); scanf("%d",&yi); drum[xi][yi]=1; minge(xi,yi); } Bk monede #include <stdio.h> int n, suma, p, m[100], i; void main(void)

{ printf("Introduceti numarul tipurilor de monede:"); scanf("%d", &n); printf("\n"); for(i=0;i<n;i++) { printf("m[%d]=",i); scanf("%d",&m[i]); } printf("Introduceti suma de bani:"); scanf("%d", &suma); for(i=0; i<n; i++) { p=suma/m[i]; //p imi retine de cate ori se cuprinde moneda i in suma de bani; suma=suma%m[i]; printf("Suma are %d monede de %d lei\n", p, m[i]); } } Backtracking tipariti toate sirurile de n note muzicale din gama DO #include<stdio.h> #include<conio.h> char b[10]; int a[10],n; void tipareste() { int i; for(i=1;i<=n;i++) printf("%s",b[a[i]]); putchar('\n'); } void bkr(int i) { int j; for(i=1;i<8;i++) { a[i]=j; if(i==n) tipareste(); else bkr(i+1); } } void main(void) { printf("dati nr de note: "); scanf("%d",&n); b[1]='DO'; b[2]='Re'; b[3]='Mi'; b[4]='Fa'; b[5]='So'; b[6]='La';

b[7]='Si'; bkr(1); } Backtracking Numerele de n cifre formate doar din cifre pare #include<stdio.h> #include<conio.h> int a[50],n; void tipareste() { int i; for(i=1;i<=n;i++) printf("%d",a[i]); putchar('\n'); } int valid(int x) { return (x==1)&&(a[x]>0)||(x>1); } void bkr(int i) { int j; for(j=0;j<=4;j++) { a[i]=2*j; if (valid(i)==1) if(i==n) tipareste(); else bkr(i+1); } } void main(void) { clrscr(); printf("dati nr de cifre: "); scanf("%d",&n); bkr(1); } Backtracking permutari stiva #include<stdio.h> int stiva[10],n,k; void tipareste() { int i; for(i=1;i<=n;i++) printf("%d",stiva[i]); putchar('\n'); } int valid() {

int i; for(i=1;i<k;i++) if(stiva[i]==stiva[k]) return (0); return (1); } void permutari() { k=1; while(k>0) if(stiva[k]<n) {stiva[k]++; if(valid()==1) if(k==n) tipareste(); else {k++; stiva[k]=0;} } else k--; } void main(void) { printf("n= "); scanf("%d",&n); permutari(); } Bk permutari #include<stdio.h> #include<conio.h> int a[50],n; void tipareste() { int i; for(i=1;i<=n;i++) printf("%d",a[i]); putchar('\n'); } int valid(int k) { int i; for(i=1;i<k;i++) if(a[i]==a[k]) return(0); return 1; } void permutari(int i) { int j;

for(j=1;j<=n;j++) { a[i]=j; if(valid(i)==1) if(i==n) tipareste(); else permutari(i+1); } } void main(void) { printf("Permutari de: "); scanf("%d",&n); permutari(1); getch(); } Bk produs cartezian #include<stdio.h> #include<conio.h> int a[100],n; void tipareste() { int i; for(i=1;i<=n;i++) printf("%d",a[i]); putchar('\n'); } void cartezian(int i) { int j; for(j=1;j<=n;j++) { a[i]=j; if (i==n) tipareste(); else cartezian(i+1); } } void main(void) { printf("Introduceti numarul: "); scanf("%d",&n); cartezian(1); } Bk regina

#include<stdio.h> #include<stdlib.h> #include<conio.h> int a[10], nr=0, n; void tipareste() { int i; for(i=0; i<n; i++) printf("Regina de pe linia %d pe coloana %d\n",i+1,a[i]+1); putchar('\n'); } void reg(int i) { int k,j,l; if(i==n) { tipareste(); putchar('\n'); getch(); } else for(l=0; l<n; l++) { a[i]=l; for(k=j=0; j<i; j++) if((a[i]==a[j])||(abs(a[i]-a[j])==(i-j))) k=1; if(!k) reg(i+1); } } void main(void) { int j; printf("Introdu dimensiunea tabelei: "); scanf("%d",&n); for(j=0; j<n; j++) a[j]=0; printf("\n"); reg(0); } Bk tipariti nr de k cifre in baza q #include<stdio.h> #include<conio.h> int a[50],k,p; void tipareste() { int i;

for(i=1;i<=k;i++) printf("%d",a[i]); putchar('\n'); } int valid(int x) { return (x==1)&&(a[x]>0)||(x>1); } void bkr(int i) { int j; for(j=0;j<p;j++) { a[i]=j; if(valid(i)==1) if(i==k) tipareste(); else bkr(i+1); } } void main(void) { printf("dati k: "); scanf("%d",&k); printf("dati p: "); scanf("%d",&p); bkr(1); } Backtracking Tipariti sirul de n litere mari distincte din primele m litere ale alfabetului (A de n luate cate m) #include<stdio.h> #include<conio.h> #include<stdlib.h> int a[10],nr=0,n; void tipareste() { int i; printf("Solutia numarul: %d\n",nr++); for(i=0;i<n;i++) printf("Regina de pe linia %d pe coloana %d\n",(i+1),a[i]+1); putchar('\n'); } void reg(int i) { int k,j,l; if(i==n) { tipareste(); putchar('\n'); getch(); } else for(l=0;l<n;l++) { a[i]=l; for(k=j=0;j<i;j++) if((a[i]==a[j])||(abs(a[i]-a[j])==(i-j))) k=1; if(!k) reg(i+1); }

} void main(void) { int j; printf("Introduceti dimeniunea tabelei: \n"); scanf("%d",&n); for(j=0;j<=n;j++) a[j]=0; reg(0); } Backtracking generarea tuturor numerelor de k ciffre care au suma cifrelor egala cu s #include<stdio.h> #include<conio.h> int a[10], k, s; void tipareste() { int i; for(i=1;i<=k;i++) printf("%d",a[i]); putchar('\n'); } void bkr(int i, int s1) { int j,x; if(i==1) x=1; else x=0; for(j=x;j<=9;j++) { a[i]=j; if(i<k) bkr(i+1,s1+a[i]); else if(s1+a[i]==s) tipareste(); } } void main(void) { clrscr(); printf("dati nr de cif: "); scanf("%d",&k); printf("dati suma cif: "); scanf("%d",&s); bkr(1,0); } Backtracking Toate elem de 4 cifre, cif in ord strict crescatoare de la stanga la dreapta #include<stdio.h> #include<conio.h> int a[10]; void tipareste() { printf("%d %d %d %d",a[1],a[2],a[3],a[4]);

putchar('\n'); } void bkr(int i) { int j; for(j=a[i-1]+1;j<=5+i;j++) { a[i]=j; if(i==4) tipareste(); else bkr(i+1); } } void main(void) { clrscr(); a[0]=0; bkr(1); } Backtracking un sir cu n elem si o val k, afisati elem sirului luate cate k #include<stdio.h> #include<conio.h> int a[50],b[50],n,k,i; void tipareste() { int i; for(i=1;i<=k;i++) printf("%d ",b[a[i]]); putchar('\n'); } int valid(int i) { int j; for(j=1;j<i;j++) if(a[i]=a[j]) return 0; return 1; } void bkr(int i) { int j; for(j=1;j<=n;j++) { a[i]=j; if(valid(i)==1) tipareste(); else bkr(i+1); } } void main(void) { clrscr(); printf("dati dimensiune sirului: "); scanf("%d",&n); printf("nr de elem luate din sir: "); scanf("%d",&k);

for(i=1;i<=n;i++) { printf("a[%d]= ",i); scanf("%d",b+i); } bkr(1); } Cele mai multe caractere #include<stdio.h> #include<string.h> int main() { char s[20][100], cuvant[100]; int n,i, max; printf("Introduceti numarul de siruri:"); scanf("%d", &n); gets(s[0]); for(i=0; i<n; i++) { printf("Introduceti sirul s[%d]:", i); gets(s[i]); } max = strlen(s[0]); strcpy(cuvant, s[0]); for (i=0; i<n; i++) { if(strlen(s[i])>max) { max = strlen(s[i]); strcpy(cuvant,s[i]); } } printf("Numarul maxim din sir este: %d si propozitia este :%s\n", max,cuvant);

return 0; } Cifra minima para recursiv #include<stdio.h> #include<conio.h> int min(int a, int b) { if (a<b) return a; else return b; } int cif_pmin(int n) { if(n<10) if(n%2==0) return n; else return 1;

else if((n%10)%2==0) return min(n%10, cif_pmin(n/10)); else cif_pmin(n/10); } void main(void) { int n; clrscr(); printf("dati nr: "); scanf("%d",&n); printf("cifra minima para din %d este %d ",n,cif_pmin(n)); } Cozi //COADA #include<stdio.h> #include<stdlib.h> #include<conio.h> struct coada { int info; coada* urm; }; typedef coada* nod; nod v, sf; int n; void push(int n) { nod c; if(!v) { v=(nod)malloc(sizeof(coada)) ; v->info=n; v->urm=0; sf=v; } else { c=(nod)malloc(sizeof(coada)); sf->urm=c; c->info=n; c->urm=0; sf=c; } } void pop() { nod c; if(v) { printf("Am extras elem %d\n",v->info); c=v; v=v->urm; free(c); } } void tipareste() { nod c=v; printf("Trasam coada: "); if(!c) printf("Coada este goala!"); while(c) { printf("%d ",c->info);

c=c->urm; } printf("\n\n"); } void main(void) { do { printf("Introduceti elem (-1 pt extragere, 0 pt iesire): "); scanf("%d",&n); if(n) if(n!=(-1)) { push(n); tipareste(); } else { pop(); tipareste(); } } while(n); }

Depune (la sfarsit) si extrage (la inceput) elemente dintr-o coada #include<stdio.h> #include<stdlib.h> struct queue { int info; queue* urm; }; typedef queue* nod; nod v, sf; //v este un pointer ce contine adresa vrfului cozii (adresa //elementului care urmeaza sa fie extras) (extragerea se face // de la nceput); sf este un pointer care contine adresa // sfrsitului cozii (adresa elementului dupa care se poate // adauga un nou element n coada) (adaugarea se face la // sfrsit) int n; void push(int n) //functia de adaugare a unui element n coada (la sfrsitul listei) { nod c; if(!v) { v=(nod)malloc(sizeof(queue)); v->info=n; v->urm=0; sf=v; } else { c=(nod)malloc(sizeof(queue)); sf->urm=c; c->info=n; c->urm=0; sf=c; }

} void pop(void)

//functia de extragere a unui element din coada (de la //nceputul listei)

{ nod c; if(v) { printf("Am extras elementul %d\n",v->info); c=v; v=v->urm; free(c); } } void traversare() //functia de traversare a cozii { nod c=v; printf("Traversam coada: "); if (!c) printf("Coada este goala!"); while (c) { printf("%d ",c->info); c=c->urm; } printf("\n\n"); } void main() { do { printf("Introduceti elementul (-1 pentru extragere, 0 pentru iesire): "); scanf("%d",&n); if(n) if (n!=(-1)) { push(n); traversare(); } else { pop(); traversare(); } } while (n); } Depune (la inceput) si extrage (la sfarsit) elemente dintr-o coada #include<stdio.h> #include<stdlib.h> #include<conio.h> #define SIZE 50 int queue[SIZE]; int ind_d=0; void push(int i)

{ int j; if (ind_d<SIZE) { for(j=ind_d;j>0;j--) queue[j]=queue[j-1]; queue[0]=i; ind_d++; printf("Am depus elementul %d\n",i); printf("Traversarea cozii:"); for(j=ind_d-1;j>=0;j--) printf("%d ",queue[j]); putchar('\n'); } else { printf("Coada este plina!\n"); exit(1); } } int pop(void) { if(ind_d>0) { ind_d--; return(queue[ind_d]); } else { printf("coada vida"); exit(1); } } void main(void) { int val,k; do { printf("Introduceti un nr intreg pt depunere (-1 pt iesire si 0 pt extragere):"); scanf("%d",&val); if(val!=0&&val!=-1) push(val); else if(!val) { printf("Am extras elementul %d\n",pop()); printf("Traversarea cozii:"); for(k=ind_d-1;k>=0;k--) printf("%d ",queue[k]); putchar('\n'); } } while(val!=-1); } Cozi //Adaugati int-o coada toate nr super prime de 2 cifre #include<stdio.h> #include<stdlib.h> #include<conio.h> #include<math.h> struct coada { int info; coada* urm; };

typedef coada* nod; nod v, sf; void push(int n) { nod c; if(!v) { v=(nod)malloc(sizeof(coada)); v->info=n; v->urm=0; sf=v; } else { c=(nod)malloc(sizeof(coada)); sf->urm=c; c->info=n; c->urm=0; sf=c; } } void pop() { nod c; if(v) { printf("Eliminam elem: %d",v->info); c=v; v=v->urm; free(c); } } void tipareste() { nod c=v; printf("Traversam coada: "); if(!c) printf("Coada este vida!"); while(c) { printf("%d ",c->info); c=c->urm; } printf("\n\n"); } int prime(int n) { int y=2; while(y<=sqrt(n)) if(n%y==0) return 0; return 1; } int super(int n) { int m=n,nr=0 ; while(m) { nr++; m=m/10; } nr--; while(nr) if(prime(n/nr*10)==0) return 0; else nr--; return 1; }

void main(void) { int i,n,x=22; clrscr(); do { printf("Introduceti elem: (-1 pt extragere sau 0 pt iesire) "); scanf("%d",&n); if(n) if(n!=(-1)) { for(i=1; i<=n; i++) { if(super(x)==1) push(x); x++; } tipareste(); } else { pop(); tipareste(); } } while(n); }

Cozi Un program care citeste 2 numare (n si b). Introduceti intr-o coada perechile distincte //de nr mai mici decat n care au cmmdc egal cu b #include<stdio.h> #include<stdlib.h> #include<conio.h> struct coada { int info; coada* urm; }; typedef coada* nod; nod v, sf; void push(int n) { nod c; if(!v) { v=(nod)malloc(sizeof(coada)); v->info=n; v->urm=0; sf=v; } else { c=(nod)malloc(sizeof(coada)); sf->urm=c; c->info=n; c->urm=0; sf=c; } } void pop() { nod c; if(v) { printf("Eliminam elem: %d",v->info); c=v; v=v->urm; free(c); } } void tipareste() {

nod c=v; printf("Traversam coada"); if(!c) printf("Coada este vida!"); while(c) { printf("%d ",c->info); c=c->urm; } printf("\n\n"); } int cmmdc(int a, int b) { while(a!=b) if(a>b) a=a-b; else b=b-a; return a; } void main(void) { int n,b,i,j; clrscr(); do { printf("Intrdodu elem (-1 pt extragere sau 0 pt iesire): "); scanf("%d",&n); if(n) if(n!=(-1)) { printf("dati valoarea cmmdc-ul impus: "); scanf("%d",&b); for(i=1;i<n-1;i++) for(j=i+1;j<n;j++) if(cmmdc(i,j)==b) { push(i); push(j); } tipareste(); } else { pop(); tipareste(); } } while(n); } Cozi //Divizori unui nr #include<stdio.h> #include<stdlib.h> #include<conio.h> struct coada { int info; coada* urm; }; typedef coada* nod; nod v, sf; int n; void push(int n) { nod c; if(!v) { v=(nod)malloc(sizeof(coada)); v->info=n; v->urm=0; sf=v; } else { c=(nod)malloc(sizeof(coada));

sf->urm=c; c->info=n; c->urm=0; sf=c; } } void pop() { nod c; if(v) { printf("Am extras elem: %d\n",v->info); c=v; v=v->urm; free(c); } } void tipareste() { nod c=v; printf("Traversam coada: "); if(!c) printf("Coada este vida!\n"); while (c) { printf("%d ",c->info); c=c->urm; } printf("\n\n"); } void main(void) { int i; clrscr(); do { printf("Introduceti elem: (-1 pt eleminare si 0 pt iesire) "); scanf("%d",&n); if(n) { if(n!=(-1)) { for(i=1; i<=n; i++) if(n%i==0) push(i); tipareste(); } else { pop(); tipareste(); } } } while(n); } Cozi //Introduceti toate elem pare din [a;b] folosind coada #include<stdio.h> #include<stdlib.h> #include<conio.h> struct coada { int info; coada* urm; }; typedef coada* nod; nod v, sf; int n; void push(int n) { nod c;

if(!v) { v=(nod)malloc(sizeof(coada)); v->info=n; v->urm=0; sf=v; } else { c=(nod)malloc(sizeof(coada)); sf->urm=c; c->info=n; c->urm=0; sf=c; } } void pop() { nod c; if(v) { printf("Am eliminat elem: %d\n",v->info); c=v; v=v->urm; free(c); } } void tipareste() { nod c=v; printf("Traversam coada: "); if(!c) printf("Coada este vida!"); while (c) { printf("%d ",&c->info); c=c->urm; } printf("\n\n"); } void main(void) { int a,b,i; clrscr(); do { printf("Introduceti elem: (-1 pt elim sau 0 pt iesire) \n"); printf("a= "); scanf("%d",&a); if(a) if(a!=(-1)) { printf("b= "); scanf("%d",&b); for(i=a;i<=b;i++) { if(i%2==0) push(i); tipareste(); } else { pop(); tipareste(); } }while(a); } Divide et impera divizori //a) produsul elem impare din sir //b) se cit o val k, afiseaza mesj daca se gaseste in sir //c) elem divizibile cu 3

//d) suma divizorilor nr al n-lea din sir #include<stdio.h> #include<conio.h> int a[10],n,i,k; int prod(int st, int dr) { int m; if(st==dr) if(a[st]%2!=0) return a[st]; else return 1; else { m=(st+dr)/2; return prod(st,m)*prod(m+1,dr); } } int verif(int st, int dr, int k) { int m; if(st==dr) if(a[st]==k) return 1; else return 0; else { m=(st+dr)/2; if(k<=a[st]) return verif(st,m,k); else return verif(m+1,dr,k); } } void divi(int st, int dr) { int m; if(st==dr) if(a[st]%3==0) printf("%d ",a[st]); else { m=(st+dr)/2; divi(st,m); divi(m+1,dr); } } int suma(int st, int dr) { int m; if(st==dr) if(a[n-1]%st==0) return st; else return 0; else { m=(st+dr)/2; return suma(st,m)+suma(m+1,dr); } } void main(void) { clrscr(); printf("introdu dimensiunea sirului: "); scanf("%d",&n); for(i=0;i<n;i++) { printf("a[%d]= ",i); scanf("%d",a+i); }

divi(0,n-1); printf("produsul elem impare: %d\n",prod(0,n-1)); printf("dati valoarea cautata: "); scanf("%d",&k); if(verif(0,n-1,k)==1) printf("valoarea %d se afla in sir \n",k); else printf("valoarea %d nu se afla in sir \n",k); printf("suma divizorilor ultimului elem: %d",suma(1,n)); } Divide et impera elem>=0 ale unui sir #include<stdio.h> #include<conio.h> int a[10],n,i; int nr(int st, int dr) { int m; if(st==dr) if(a[st]>=0) return 1; else return 0; else { m=(st+dr)/2; return nr(st,m) + nr(m+1,dr); } } void main(void) { clrscr(); printf("dati dimensiunea: "); scanf("%d",&n); for(i=0;i<n;i++) { printf("a[%d]= ",i); scanf("%d",a+i); } printf("nr de elem pozitive: %d",nr(0,n-1)); } Divide et impera interclasare #include<stdio.h> #include<conio.h> void merge(int a[], int l, int r) { int m; if(l<r) { m=(l+r)/2; merge(a,l,m); merge(a,m+1,r); sortare(a,l,m,r); } } void main(void) { clrscr(); printf("dimen sirului: ");

scanf("%d",&n); for(i=0;i<n;i++) { printf("a[%d]= ",i); scanf("%d",a+i); } inter(0,n/2,n); } Divide et impera litere mici din sir #include<stdio.h> #include<conio.h> #include<string.h> #include<ctype.h> char a[10]; char litere(int st, int dr) { int m; if(st==dr) if(isalpha(a[st])!=0) return a[st]; else return ' '; else { m=(st+dr)/2; return litere(st,m) + litere(m+1,dr); } } void main(void) { clrscr(); gets(a); printf("literele mici din sir sunt: %s",litere(0,strlen(a)-1)); } Divide et impera nr de spatii dintr-un sir #include<stdio.h> #include<conio.h> #include<string.h> char a[10]; int spatii(int st, int dr) { int m; if(st==dr) if(a[st]==' ') return 1; else return 0; else { m=(st+dr)/2; return spatii(st,m)+ spatii(m+1,dr); } } void main(void) { clrscr(); gets(a); printf("nr de spatii din sir: %d",spatii(0,strlen(a)-1)); }

Divide et impera Suma elem unui sir #include<stdio.h> #include<conio.h> int a[10],n,i; int suma(int st, int dr) { int m; if(st==dr) return a[st]; else { m=(st+dr)/2; return suma(st,m) + suma(m+1,dr); } } void main(void) { clrscr(); printf("dati dimensiunea sirului: "); scanf("%d",&n); printf("intro elem: \n"); for(i=0;i<n;i++) { printf("a[%d]= ",i); scanf("%d",a+i); } printf("suma elem este: %d",suma(0,n-1)); } Divide et impera turnurile din hanoi #include<stdio.h> #include<conio.h> int n; void tipareste(char a, char b) { printf("Muta discul pe %c pe %c\n",a,b); } void muta(int n, char a, char b, char c) { if(n==1) { tipareste(a,b); return; } else { muta(n-1,a,c,b); tipareste(a,b); muta(n-1,c,b,a); } } void main(void) { clrscr(); printf("introdiceti nr de turnuri: "); scanf("%d",&n); muta(n,'S','M','D'); getch(); }

Divide et impera valoarea maxima sir #include<stdio.h> #include<conio.h> int a[10],n,i; int comp(int a, int b) { if(a>=b) return a; else return b; } int max(int st, int dr) { int m; if(st==dr) return a[st]; else { m=(st+dr)/2; return comp(max(st,m),max(m+1,dr)); } } void main(void) { clrscr(); printf("introdu dim: "); scanf("%d",&n); for(i=0;i<n;i++) { printf("a[%d]= ",i); scanf("%d",a+i); } printf("maximul= %d",max(0,n)); } Descompune numar in suma de nr #include<stdio.h> #include<conio.h> int a[100],n; void afisare(int k) { for(int i=1;i<=k;i++) printf("%d ",a[i]); } int suma(int k) { int i, s=0; for(i=1;i<=k;i++) s+=a[i]; return s; } void back(int i) { for (int j=a[i-1];j<=n-1;j++)

{ a[i]=j; if(suma(i)<=n) if (suma(i)==n) { afisare(i); putchar('\n');} else back(i+1);} } void main(void) { printf("Introduceti numarul: "); scanf("%d",&n); a[0]=1; back(1); getch(); } exercitare functie nr de elemente #include<stdio.h> int strlen(char a[]) { int n; for(n=0;a[n];n++); return(n); } void main(void) { char a[30]; printf("introduceti sirul:"); scanf("%s",a); printf("\n Lungimea sirului este:"); printf("%d\n",strlen(a)); } exercitare functie nr negativ #include<stdio.h> int strcmp(char a[], char b[]) { int i; for(i=0;a[i]&&b[i]&&a[i]==b[i];i++); if(a[i]<b[i]) return(-1); else if(a[i]>b[i]) return(1); else return(0); } void main(void) { char a[30], b[30]; printf("Introduceti primul sir:"); scanf("%s",a); printf("Introduceti sirul 2:"); scanf("%s",b); printf("dif celor 2 siruri este %d\n",strcmp(a,b));

} Graf Eulerian #include<stdio.h> #include<conio.h> int a[10][10],viz[10],n,m; void df_r(int nod) { int k; printf("%d",nod); viz[nod]=1; for(k=1;k<=n;k++) if(a[nod][k]&&!viz[k]) df_r(k); } void main() { int x,y,in,nr_n_viz=0,par=0,grad,i,j; printf("Introduceti numarul de noduri:"); scanf("%d",&n); printf("Introduceti numarul de muchii:"); scanf("%d",&m); for(i=1;i<=n;i++) for(j=1;j<=n;j++) a[i][j]=0; for(i=1;i<=m;i++) { printf("De la nodul:"); scanf("%d",&x); printf("La nodul"); scanf("%d",&y); a[x][y]=a[y][x]=1; } printf("Introduceti nodul de la care se pornete:"); scanf("%d",&in); df_r(in); for(i=1;i<=n;i++) nr_n_viz+=viz[i]; if(nr_n_viz!=n) printf("\nGraful nu este conex!\n"); else { printf("\nGraful este conex!\n"); for(i=1;i<=n;i++) { grad=0; for(int j=1;j<=n;j++) grad+=a[i][j]; if(grad%2!=0) par=1; } if(par) printf("Exista noduri cu grade impare!\n"); else printf("Avem un graf eulerian!\n"); } getch();

} Parcurgerea in adancime a unui graf neorientat #include<stdio.h> #include<conio.h> int a[20][20],n; void parc_adancime() { int s[40],varf,k,nod,urm[20],viz[20],in; printf("Introduceti nodul initial de pornire="); scanf("%d",&in); for(nod=1;nod<=n;nod++) { urm[nod]=0; viz[nod]=0; } varf=1; s[varf]=in; viz[in]=1; printf("%d",in); while(varf>=1) { nod=s[varf]; k=urm[nod]+1; while((k<=n)&&((a[nod][k]==0)||((a[nod][k]==1)&&(viz[k]==1)))) { k++; urm[nod]=k; } if(k==n+1) varf--; else { varf++; s[varf]=k; viz[k]=1; printf("%d",s[varf]); } } } void main() { int x,y,i,j,m; printf("Introduceti numarul de noduri n= "); scanf("%d",&n); printf("Introduceti numarul de muchii m= "); scanf("%d",&m); for(i=1;i<=n;i++) for(j=1;j<=n;j++) for(i=1;i<=m;i++) { printf("De la nodul: "); scanf("%d",&x);

printf("La nodul: "); scanf("%d",&y); a[x][y]=a[y][x]=1; } parc_adancime(); getch(); } Parcurgerea in latime a unui graf neorientat #include<stdio.h> #include<conio.h> int a[20][20],n; void parc_latime() { int c[20],p,u,v,viz[20],in,nod,ind; printf("Dati nodul de pornire pentru parcurgere: "); scanf("%d",&in); for(nod=1;nod<=n;nod++) viz[nod]=0; p=1; u=1; c[1]=in; viz[in]=1; while(p<=u) { v=c[p]; for(nod=1;nod<=n;nod++) if((a[v][nod]==1)&&(viz[nod]==0)) { u++; c[u]=nod; viz[nod]=1; } p++; } for(ind=1;ind<=n;ind++) printf("%d ",c[ind]); } void main() { int x,y,i,j,m; printf("Introduceti numarul de noduri n= "); scanf("%d",&n); printf("Introduceti numarul de muchii m= "); scanf("%d",&m); for(i=1;i<=n;i++) for(j=1;j<=n;j++) for(i=1;i<=m;i++) { printf("De la nodul: "); scanf("%d",&x); printf("La nodul: "); scanf("%d",&y); a[x][y]=a[y][x]=1; } parc_latime();

getch(); } Imparte suma in bancnote si monede #include <stdio.h> int main() { int n, suma, p; int b[100], i; printf("n="); scanf("%d", &n); for(i=0; i<n; i++) { printf("b[i]=", i); scanf("%d", &b[i]); } printf("Introduceti suma de bani:"); scanf("%d", &suma); for(i=0; i<n; i++) { p=suma/b[i]; suma=suma%b[i]; printf("suma are %d bancnote de %d lei\n", p, b[i]); }

return 0; } Impl arbore binar cautare #include<stdio.h> #include<stdlib.h> #define max(x,y) ((x<y)?(y):(x)) struct Btree { int Data; Btree *left,*right; }; typedef struct Btree arbore; int init() //functia de initializare a arborelui binar de cautare { return(NULL); } arbore* inserare(arbore *bt,int n) //functia de inserare a unui nod n arborele //binar de cautare { if (!bt) { bt=(arbore*)malloc(sizeof(arbore));

if (!bt) return(0); bt->left=bt->right=0; bt->Data=n; return(bt); } else if (bt->Data< n) bt->right=inserare(bt->right,n); else bt->left=inserare(bt->left,n); return(bt); } arbore* constructie() //functia de constructie a arborelui binar //de cautare

{ int n; arbore *p=NULL; printf("n="); scanf("%d",&n); while (n>0) { p=inserare(p,n); printf("n="); scanf("%d",&n); } return(p); } arbore* cautare(arbore *bt,int q)

//functia de cautare ntr-un arbore //binar de cautare

{ if (!bt) return(NULL); if (bt->Data==q) return(bt); else if (bt->Data< q) return(cautare(bt->right,q)); else return(cautare(bt->left,q)); } void preordine(arbore *bt) //functia de parcurgere n preordine { if (bt) { printf("%d ",bt->Data); preordine(bt->left); preordine(bt->right); } } void inordine(arbore *bt) { if (bt) { inordine(bt->left); printf("%d ",bt->Data); inordine(bt->right); } } void postordine(arbore *bt) //functia de parcurgere n inordine

//functia de parcurgere n postordine

{ if (bt) { postordine(bt->left); postordine(bt->right); printf("%d ",bt->Data); } } int nivele(arbore *bt) //functia care returneaza numarul de niveluri { if (!bt) return(0); else return(1+max(nivele(bt->left),nivele(bt->right))); } int nod(arbore *bt) //functia care returneaza numarul tuturor nodurilor { if (!bt) return(0); else return(1+nod(bt->left)+nod(bt->right)); } int frunze(arbore *bt) //functia care returneaza numarul de frunze { if (!bt) return(0); if ((!bt->right)&&(!bt->left)) return(1); return(frunze(bt->left)+frunze(bt->right)); } void distrugere(arbore *bt) //functia de eliberare a memoriei { if (bt) { if (bt->left) distrugere(bt->left); if (bt->right) distrugere(bt->right); delete(bt); } }void main() { int v; arbore *bt=NULL; init(); printf("Vom crea arborele pana la introducerea unui nr negativ sau 0:\n"); bt=constructie(); printf(" Introduceti valoarea care sa se insereze in arbore:"); scanf("%d",&v); if (cautare(bt,v)) printf("Elementul exista in arbore!"); else inserare(bt,v); if (bt) { printf("\n Afisare in inordine:"); inordine(bt); } else printf("Arborele este gol!\n"); if (bt) { printf("\n Afisare in preordine:"); preordine(bt); } else printf("Arborele este gol!\n");

if (bt) { printf("\n Afisare in postordine:"); postordine(bt); } else printf("Arborele este gol!\n"); printf("\n Numarul de niveluri este: %d",nivele(bt)); printf("\n Numarul de noduri este: %d",nod(bt)); printf("\n Numarul de frunze este: %d\n",frunze(bt)); distrugere(bt); printf("Am eliberat memoria!\n"); } Impl arbore binar #include<stdio.h> #include<conio.h> #include<alloc.h> typedef struct_nod_arb { int nr; struct_nod_arb *stg, *dr; } NOD_ARB; NOD_ARB*rad; void preordine(NOD_ARB *p) { if(p) { printf("%d",p->nr); preordine(p->stg); preordine(p->dr); } void inordine(NOD_ARB *p) { if(p) { inordine(p->stg); printf("%d",p->nr); inordine(p->dr); } void postordine(NOD_ARB *p) { if(p) { postordine(p->stg); postordine(p->dr); printf("%d",p->nr); } NOD_ARB *creare()

{ NOD_ARB *p; int inf; printf("Introduceti informatia: "); scanf("%d",&inf); if(inf==0) return(0); else { p=(NOD_ARB *)malloc(sizeof(NOD_ARB)); p->inf=nr; p->stg=creare(); p->dr=creare(); } return(p); } void main(void) { rad=creare(); printf("Traversare in preordine: "); preordine(rad); putchar('\n'); printf("Traversare in inordine: "); inordine(rad); putchar('\n'); printf("Traversare in postordine: "); postordine(rad); putchar('\n'); getch(); } } Impl stiva - structura dinamica(pointeri) #include<stdio.h> #include<stdlib.h> struct stack { int info; stack* urm; }; typedef stack* nod; nod v; //v contine vrful stivei (adresa ultimului nod introdus), respectiv //0 daca stiva este vida int n; void push(int n) //functia de adaugare in stiva { nod c; //c pointer ce contine adresa noului nod introdus if(!v) { v=(nod)malloc(sizeof(stack)); v->info=n;

v->urm=0; } else { c=(nod)malloc(sizeof(stack)); c->info=n; c->urm=v; //legam noul vrf al stivei de urmatorul element (fostul vrf) v=c; //v va indica n continuare noul vrf al stivei } } void pop(void) //functia de extragere a unui element din stiva { nod c; //c va retine adresa nodului extras if(!v) printf("Stiva este vida\n"); else { c=v; printf("Am extras elementul: %d\n",c->info); v=v->urm; //noul vrf al stivei free(c); } } void traversare(void) //functia de afisare a stivei { nod c=v; //pointerul c este initializat cu adresa vrfului stivei printf("Traversam stiva: "); if (!c) printf("Stiva este goala!\n"); while (c) //att timp ct c este diferit de 0 deci nu am ajuns la // ultimul element al stivei { printf("%d ",c->info); c=c->urm; //continuam cu urmatorul element al stivei } printf("\n\n"); } void main(void) { do { printf("Introduceti elementul (-1 pentru extragere element, 0 pentru iesire):"); scanf("%d",&n); if(n) if (n!=(-1)) { push(n); traversare(); } else { pop(); traversare(); } } while (n); //iesim cand n=0 }

Impl stiva tablou unidimensional (extragere) #include<stdio.h> #include<stdlib.h> #define STCKSIZE 50 void push(int i); //prototipul functiei de depunere n stiva int pop(void); //prototipul functiei de extragere din stiva int *p1, *tos, stack[STCKSIZE]; //variabile globale; n tabloul stack simulam stiva void main(void) { int value; p1=stack; tos=p1; do { printf("Introduceti un nr pozitiv pentru depunere, -1 pt iesire si 0 pt extragere: "); scanf("%d",&value); if(value) push(value); else printf("Am extras elementul: %d\n",pop()); } while (value!=-1); } void push(int i) { p1++; if(p1==(tos+STCKSIZE)) {printf("Stiva plina!"); exit(1); } *p1=i; //depunem n stiva elementul i } int pop(void) { if(p1==tos) { printf("Stiva vida!\n"); exit(1); } p1--; return(*(p1+1)); //returnam elementul curent (nainte de //decrementarea pointerului p1) } Interclasarea a 2 siruri #include<stdio.h> void main(void) { int m,n,i,j,k,a[21],b[21],c[40]; printf("Introduceti dimensiunea I sir: "); scanf("%d",&n); for(i=0;i<n;i++) {

printf("a[%d]= ",i); scanf("%d",a+i); //a+i este acelas lucru cu & } printf("Introduceti elementele sirului II: "); scanf("%d",&m); for(j=0;j<m;j++) { printf("b[%d]= ",j); scanf("%d",b+j); } a[n]=b[m-1]+1; b[m]=a[n-1]+1; for(i=0,j=0,k=0;k<m+n;k++) if(a[i]<=b[j]) c[k]=a[i++]; else c[k]=b[j++]; printf("Sirul concatenat este: "); for(k=0;k<m+n;k++) printf("%d ",c[k]); } List pointer #define __LISTPOINTER #include "list.h" // returneaza pointer la ultimul element din lista list* end(list head) { list* p = &head; while(p->next) p = p->next; return p; } void makenull(list* l) { l->next = 0; } // insereaza elementul x pe pozitia poz in lista int insert(elementtype x, int poz, list* head) { list *p, *q; int i = 0; if (poz<0) return -1; p = head; while((i<poz) && p) { p = p->next; i++; } if (p==0) return -1; // s-a trecut de capatul listei

q = (list*)malloc(sizeof(list)); // alocare memorie pentru o celula q->element = x; q->next = p->next; p->next = q; return 1; } int locate(elementtype x, list head) { list* p; int i; for(i=0, p=head.next; p; i++, p = p->next) { if (p->element == x) return i; } return -1; // elementul x nu a fost gasit in lista } elementtype* retrieve(int poz, list head) { list* p; int i; if (poz < 0) return 0; for(i=0, p=head.next; (i<poz) && (p->next); i++, p = p->next); if (i<poz) return 0;// s-a indicat o pozitie in afara listei return &(p->element); } // sterge elementul de pe pozitia poz in lista // se foloseste tehnica cu pointer la pointer // care nu necesita memorarea adresei elementului anterior, deoarece aceasta // e memorata in pointerul la pointer int delete(int poz, list* head) { list **p, *q; int i = 0; if (poz<0) return -1; // eroare, pozitie in afara listei p = &(head->next); while ((i<poz) && (*p)) { p = &((*p)->next); i++; } if (i<poz) return -1; // eroare, pozitie in afara listei q = *p; *p = q->next; free(q); // trebuie eliberata memoria pt elementul sters din lista

// altfel, acesta ramane referinta agatata } elementtype* next(int poz, list head) { list* p; int i; if (poz<0) return 0; for (i=0, p=head.next; (i<poz+1) && (p->next); i++, p = p->next); if (i<poz+1) return 0; // pozitie in afara listei sau sfarsit de lista return &(p->element); } elementtype* previous(int poz, list head) { list* p; int i; if (poz<=0) return 0; for (i=0, p=head.next; (i<poz-1) && (p->next); i++, p = p->next); if (i<poz-1) return 0; return &(p->element); } elementtype* first(list head) { if (head.next==0) return 0; // lista vida return &(head.next->element); } void printlist(list head) { list* p; for(p=head.next; p; p = p->next) printf("%d ", p->element); } void citeste(elementtype* x) { scanf("%d", x); } void afiseaza(elementtype x) { printf("%d", x); } Lista sir #ifndef __LISTSIR #define __LISTSIR #endif #include <stdio.h>

#include "list.h"

void citeste(elementtype* x) { scanf("%d", x); } void afiseaza(elementtype x) { printf("%d", x); } int end(list l) { if (l.last == maxlength-1) { /* eroare, nu se mai pot aloca elemente in lista, spatiul alocat s-a epuizat */ fprintf(stderr, "s-a ajuns la capatul spatiului alocat listei"); return -1; } return l.last + 1; } int locate(elementtype x, list l) { int i; for (i=0; i<=l.last; i++) if (x==l.elements[i]) return i; return -1; /* nu s-a gasit elementul x in lista l */ } elementtype* retrieve(int p, list l) { /* returneaza referinta la elementul de pe pozitia p */ if (p<0 || p>l.last) return 0; return &l.elements[p]; } elementtype* next(int p, list l) { if (p<0 || p>l.last-1) return 0; return &l.elements[p+1]; } elementtype* previous(int p, list l) { if (p<1 || p>l.last) return 0; return &l.elements[p-1]; } // trebuie sa transmitem lista prin referinta deoarece dorim

// sa efectuam modificari pe lista, // la transmiterea prin valoare, modificarile realizeaza void makenull(list* l) { l->last = -1; } elementtype* first(list l) { if (l.last>=0) return l.elements; return 0; } int insert(elementtype x, int p, list* l) { int ll,i; if ((p==0) && (l->last == -1)) { // lista vida, inserare pe prima pozitie l->elements[0] = x; l->last = 0; return 1; } if (p==l->last+1) { // inserare pe ultima pozitie l->elements[p] = x; l->last++; return 1; } if (p<0 || p>l->last) return -1; // eroare, p in afara listei ll = l->last+1; for (i=ll-1; i>=p; i--) l->elements[i+1] = l->elements[i]; l->elements[p] = x; l->last = ll; return 1; // inserare cu success } int delete(int p, list* l) { int ll, i; if (p<0 || p>l->last) return -1; // eroare, p in afara listei for (i=p; i<l->last; i++) l->elements[i] = l->elements[i+1]; l->last--; return 1; // stergere cu success } void printlist(list l) { int i; for (i=0; i<=l.last; i++) printf("%d ", l.elements[i]); printf("\n"); } LISTA

#include<stdio.h> #include<stdlib.h> #include<conio.h> typedef struct LISTA { int cheie; struct LISTA *urm; } lista; lista *prim, *p, *q; void creaza() { prim=NULL; p=(lista*)malloc(sizeof(lista)); scanf("%d",&p->cheie); p->urm=NULL; prim=p; } void adauga() { p=(lista*)malloc(sizeof(lista)); printf("Inserare in capul listei valoarea: "); scanf("%d",&p->cheie); p->urm=prim; prim=p; } void tipareste() { for(p=prim;p;p=p->urm) printf("%d\n",p->cheie); putchar('\n'); } void main(void) { clrscr(); creaza(); tipareste(); } Liste + stergere #include <stdio.h> #include <malloc.h> typedef struct celltype { int valoare; struct celltype *pnext; } list_element;

int afisare(list_element *pvarf) { list_element *p;

p=pvarf; while (p) { printf("%d ", p->valoare); p = p->pnext; } printf("\n"); return 0; } int insert_first(list_element **ppvarf, int val) { list_element *p_nou; p_nou = (list_element*)malloc(sizeof(list_element)); if (p_nou == NULL) { fprintf(stderr, "Eroare la alocare\n"); return -1; } p_nou->valoare = val; p_nou->pnext = *ppvarf; *ppvarf = p_nou; return 0; } int stergere(int pozitie, list_element **ppvarf) { list_element **p = ppvarf; list_element *q; int i = 0; while(*p && i<pozitie) { i++; p = &((*p)->pnext); } if(*p) { q=*p; *p = (*p)->pnext; free(q); printf("Elementul a fost sters cu succes! \n"); } else { printf("elementul de pe pozitia %d nu exista in lista \n", pozitie); } return 0; }

int main() { list_element *pvarf = NULL; int selectie, val; int ret_val = 1; while(ret_val >= 0) { printf("1. Introducere la inceputul listei\n"); printf("2. Sterge element din lista\n"); printf("5. Afisare lista\n"); printf("9. Iesire din program\n"); printf("Selectati optiunea dvs:"); scanf("%d", &selectie); switch(selectie) { case 1: printf("introduceti valoarea de inserat: "); scanf("%d", &val); ret_val = insert_first(&pvarf, val); break; case 2: printf("INTRODUCETI POZITIA ELEMENTULUI CARE SE STERGE: "); scanf("%d", &val); ret_val = stergere(val, &pvarf); break; case 5: ret_val = afisare(pvarf); break; case 9: return 0; } } printf("in program a intervenit o eroare!\n"); return -1; } Operatii pe o lista circulara simplu inlantuita #include<stdio.h> #include<stdlib.h> #include<conio.h> typedef struct LISTA { int cheie; struct LISTA *urm; } lista; lista *p, *q, *r, *ultim, *x; void creaza()

{ ultim=NULL; p=(lista*)malloc(sizeof(lista)); scanf("%d",&p->cheie); ultim=p; p->urm=p; } void inser_sf() { p=(lista*)malloc(sizeof(lista)); printf("Dati elem: "); scanf("%d",&p->cheie); p->urm=ultim->urm; ultim->urm=p; ultim=p; } void inser_inaiN() { int key; printf("Introduceti valoarea inainte de care inseram: "); scanf("%d",&key); r=ultim; x=ultim; for(p=ultim->urm;p!=ultim&&p->cheie!=key;r=p,p=p->urm); if(p->cheie==key) { q=(lista*)malloc(sizeof(lista)); printf("Dati valoarea: "); scanf("%d",&q->cheie); r->urm=q; q->urm=p; printf("Nodul a fost inserat!\n"); printf("Introduceti %d (pt a nu pierde ultimul elem)=> ",x->cheie); inser_sf(); } else printf("Valoarea nu a fost gasita in lista!"); } void inser_dupaN() { int key; x=ultim; printf("Introduceti valoarea dupa care doriti inserarea: "); scanf("%d",&key); for(p=ultim->urm;p!=ultim&&p->cheie!=key;p=p->urm); if(p->cheie==key) { q=(lista*)malloc(sizeof(lista)); printf("Dati elem: "); scanf("%d",&q->cheie); q->urm=p->urm; p->urm=q; printf("Nodul a fost inserat!\n"); printf("Introduceti %d ( pt a nu pierde ultimul elem)=> ",x->cheie);

inser_sf(); } else printf("Valoarea nu a fost gasita in lista\n"); } void cauta() { int key; printf("Introduceti valoarea cauta: "); scanf("%d",&key); for(p=ultim->urm;p!=ultim&&p->cheie!=key;p=p->urm); if(p->cheie==key) printf("Valoarea a fost gasita!\n"); else printf("Valoarea nu a fost gasita!\n"); } void stergeN() { int key; printf("Introduceti cheia care va fi stearsa: "); scanf("%d",&key); for(p=ultim->urm;p!=ultim&&p->cheie!=key;p=p->urm); if(p->cheie==key) if(ultim->urm==ultim) { ultim=NULL; printf("Val gasita si nod sters!\n"); } else { if(p==ultim) ultim=r; r->urm=p->urm; free(p); printf("Val gasita si nod sters!\n"); } else printf("Valoarea nu a fost gasita!\n"); } void sterge() { while(ultim->urm!=ultim) { p=ultim->urm; ultim->urm=ultim->urm->urm; free(p); } free(ultim); } void scrie() { p=ultim->urm; while(p!=ultim) { printf("%d ",p->cheie); p=p->urm; } printf("\n\n"); } void main() { int i,n; clrscr(); printf("n= "); scanf("%d",&n); creaza();

for(i=1;i<n;i++) inser_sf(); //inser_inaiN(); inser_dupaN(); scrie(); cauta(); stergeN(); scrie(); sterge(); } Lista liniara dublu inaltuita #include<stdio.h> #include<stdlib.h> #include<conio.h> typedef struct LISTAD { int cheie; struct LISTAD *pred, *suc; } listad; listad *prim, *p, *q; void creaza() { prim=NULL; p=(listad*)malloc(sizeof(listad)); printf("Dati elem: "); scanf("%d",&p->cheie); p->pred=NULL; p->suc=NULL; prim=p; } void inser_ina() { p=(listad*)malloc(sizeof(listad)); printf("Dati elem: "); scanf("%d",&p->cheie); p->pred=NULL; p->suc=prim; prim->pred=p; prim=p; } void inser_inaN() { int key; printf("Dati cheia inaintea careia se insereaza: "); scanf("%d",&key); for(p=prim;p&&p->cheie!=key;p=p->suc); if(p) if(p==prim) { q=(listad*)malloc(sizeof(listad)); printf("Dati elem: "); scanf("%d",&q->cheie); q->pred=NULL; q->suc=prim;

prim->pred=q; prim=q; printf("Elem a fost inserat ca prim elem in lista!\n"); } else { q=(listad*)malloc(sizeof(listad)); printf("Dati elem: "); scanf("%d",&q->cheie); q->pred=p->pred; q->suc=p; p->pred->suc=q; printf("Elementul a fost inserat in lista!\n"); } else printf("Cheia cautata nu a fost gasita!\n"); } void inser_dupaN() { int key; printf("Dati cheia dupa care se insereaza: "); scanf("%d",&key); for(p=prim;p&&p->cheie!=key;p=p->suc); if(p) { q=(listad*)malloc(sizeof(listad)); printf("Dati elem: "); scanf("%d",&q->cheie); q->suc=p->suc; q->pred=p; if(p->suc) p->suc->pred=q; p->suc=q; printf("Elementul a fost inserat!\n"); } else printf("Elementul cautat nu afost gasit!\n"); } void cautaN() { int key; printf("Dati cheia cautata: "); scanf("%d",&key); for(p=prim;p&&p->cheie!=key;p=p->suc); if(p) printf("Elementul a fost gasit!\n"); else printf("Valoarea cautata nu a fost gasita!\n"); } void sterge() { if(prim->suc==NULL) { free(prim); printf("Elementul cap de lista a fost sters!\n"); printf("Lista vida!"); prim=NULL; } else { p=prim; prim=prim->suc; free(p); printf("Elementul cap de lista a fost sters!\n"); } }

void stergeN() { int key; printf("Dati cheia pt stergere: "); scanf("%d",&key); for(p=prim;p&&p->cheie!=key;p=p->suc); if(p) { if(p==prim) { p=prim; p=prim->suc; free(p); printf("Elemetul este cap de lista!\n"); printf("Capul de lista a fost sters!\n"); } else if(p==prim) { p->pred->suc=p->suc; if(p->suc) p->suc->pred=p->pred; free(p); printf("Elementul a fost sters!\n"); } } else printf("Valoarea cautata nu a fost gasita!\n"); } void sterge_tot() { p=prim; prim=prim->suc; free(p); printf("Lista este vida!\n"); } void scrie() { p=prim; while(p) { printf("%d ",p->cheie); p=p->suc; } printf("\n\n"); } void main() { int n,i; clrscr(); printf("Dati nr de elem din lista: "); scanf("%d",&n); creaza(); for(i=1;i<n;i++) inser_ina(); scrie(); inser_inaN(); scrie(); inser_dupaN(); scrie(); cautaN(); sterge(); scrie(); stergeN();

scrie(); sterge_tot(); getch(); } Toate operatiile pe o lista liniara simplu inlantuita #include<stdio.h> #include<stdlib.h> #include<conio.h> typedef struct LISTA { int cheie; struct LISTA *urm; } lista; lista *prim, *p, *q, *r; void creaza() { prim=NULL; p=(lista*)malloc(sizeof(lista)); scanf("%d",&p->cheie); p->urm=NULL; prim=p; } void inser_cap_lista() { p=(lista*)malloc(sizeof(lista)); printf("Dati elem: "); scanf("%d",&p->cheie); p->urm=prim; prim=p; } void inser_sf_lista() { for(p=prim;p->urm;p=p->urm); q=(lista*)malloc(sizeof(lista)); printf("Dati elem: "); scanf("%d",&q->cheie); p->urm=q; q->urm=NULL; } void inser_dupaN() { int key; printf("Cheia dupa care se insereaza: "); scanf("%d",&key); for(p=prim;p!=NULL&&p->cheie!=key;p=p->urm); if(p!=NULL) { q=(lista*)malloc(sizeof(lista)); printf("Dati elem: "); scanf("%d",&q->cheie); q->urm=p->urm; p->urm=q; }

else printf("Nu exista cheia specificata!\n"); } void inser_inaN() { int key; printf("Cheia inaintea careia se insereaza: "); scanf("%d",&key); for(p=prim;p!=NULL&&p->cheie!=key;r=p,p=p->urm); if(p!=NULL) { q=(lista*)malloc(sizeof(lista)); printf("Dati elem: "); scanf("%d",&q->cheie); q->urm=p; r->urm=q; } else printf("Nu exista cheia cautata \n"); } void stergeN() { int key; printf("Nodul ce trebuie sters: "); scanf("%d",&key); for(p=prim;p!=NULL&&p->cheie!=key;r=p,p=p->urm); if(p) if(prim!=p) { r->urm=p->urm; free(p); } else { prim=p->urm; free(p); } else printf("Nu exista cheia specificata!\n"); } void sterge() { while(prim) { p=prim; prim=prim->urm; free(p); } } void scrie() { for(p=prim;p;p=p->urm) printf("%d ",p->cheie); printf("\n\n"); } void main() { int n,i; clrscr(); printf("n= "); scanf("%d",&n); creaza(); for(i=1;i<n;i++) //inser_cap_lista(); inser_sf_lista();

//inser_dupaN(); inser_inaN(); stergeN(); scrie(); sterge(); } Lista liniara simplu inlantuita #include<stdio.h> #include<stdlib.h> #include<conio.h> typedef struct LISTA { int cheie; struct LISTA *urm; } lista; lista *prim, *p, *q, *r; void creare() { prim=NULL; p=(lista*)malloc(sizeof(lista)); scanf("%d",&p->cheie); p->urm=NULL; prim=p; } void inserare_sf() { for(p=prim;p->urm;p=p->urm); q=(lista*)malloc(sizeof(lista)); scanf("%d",&q->cheie); p->urm=q; q->urm=NULL; } void inserare_ina() { p=(lista*)malloc(sizeof(lista)); printf("Inserare in capul listei val: "); scanf("%d",&p->cheie); p->urm=prim; prim=p; } void inserare_dupaN() { int key; printf("Cheia dupa care se insereaza: "); scanf("%d",&key); for(p=prim;p!=NULL&&p->cheie!=key;p=p->urm); if(p!=NULL) { q=(lista*)malloc(sizeof(lista)); printf("Noul elem: ");

scanf("%d",q->cheie); q->urm=p->urm; p->urm=q; } else printf("Nu exista cheie specificata!\n"); } void inserare_inaN() { int key; printf("Cheia inaintea careia se insereaza: "); scanf("%d",&key); for(p=prim;p!=NULL&&p->cheie!=key;r=p,p=p->urm); if(p!=NULL) { q=(lista*)malloc(sizeof(lista)); printf("Noul elem "); scanf("%d",q->cheie); q->urm=p; r->urm=q; } else printf("Nu exista cheia cautata\n"); } void sterge() { int key; printf("Nodul ce trebuie sters: "); scanf("%d",&key); for(p=prim;p!=NULL&&p->cheie!=key;r=p,p=p->urm); if(p) if(prim!=p) { r->urm=p->urm; free(p); } else { prim=p->urm; free(p); } else printf("Nu exista cheia specificata!\n"); } void afisare() { for(p=prim;p;p=p->urm) printf("%d ",p->cheie); printf("\n\n"); } void main() { int n,i; clrscr(); printf("n= "); scanf("%d",&n); creaza(); for(i=1; i<n; i++) inserare_sf(); afisare(); sterge(); afisare(); }

Adaugare, stergere lista simplu inlantuita

#include <stdio.h> #include <stdlib.h> #include <string.h> #include <ctype.h>

typedef struct elem { float info; struct elem *urm; } nod;

/* cauta in lista indicata de p nodul cu campul info = inf si returneaza pointerul catre acel nod, daca nodul cautat nu exista returneaza NULL */ nod *caut(nod *p, float inf) { for ( ; p!=NULL && p->info<inf; p=p->urm); /* cautam doar pana la primul element mai mare decat inf (daca el nu exista), deoarece lista e ordonata, deci nu mai are sens sa parcurgem mai departe*/ if (p!=NULL && inf==p->info) return p; /* daca info a fost gasit in lista */ return NULL; /* daca nu a fost gasita */ }

/* Functia listez parcurge lista si pentru fiecare nod

afiseaza informatia memorata. void listez(nod *p) {

*/

printf("Un nod ocupa %d octeti, pointerul catre nod ocupa %d octeti\n", sizeof(*p), sizeof(p)); for ( ; p!=NULL; p=p->urm) printf("(adr=%p) |%6g| %p | \n",p,p->info, p->urm); }

/* Functia sterg elimina din lista (indicata de pointerul p) nodul ce are campul info egal cu argumentul inf nod *sterg(nod *radacina, float inf) { nod *aux, *p; if (radacina==NULL){ // lista vida printf("Eroare: lista e vida\n"); return NULL; } else if (radacina->info==inf){ // sterg primul element aux=radacina; radacina=radacina->urm; free(aux); return radacina; } */

else{ // parcurgem lista pana gasim nodul cu info=infonou sau pana la sfarsit for(p=radacina; p->urm!=NULL && p->urm->info<inf; p=p->urm); if (p->urm != NULL && p->urm->info==inf) // nodul cautat exista { aux=p->urm; p->urm=aux->urm; // adica p->urm=p->urm->urm; free(aux); } else // nodul cautat nu exista

printf("Eroare: identificatorul %f nu apare in lista\n", inf); return radacina; } }

/*Functia introduc insereaza un nod in lista ordonata, Functia returneaza pointerul catre inceputul listei modificate */ nod * introduc(nod *radacina, float infonou) { nod *nou, *p; if ((nou=(nod *)malloc(sizeof(nod)))==NULL) { printf("Eroare: memorie insuficienta\n"); return NULL; } nou->info=infonou; /* se salveaza infonou in nodul nou */ nou->urm=NULL; if (radacina==NULL) // lista vida radacina=nou; else if (p->info>infonou){ // iintroduc la inceput nou->urm=radacina; radacina=nou;

} else{ // inserare in int listei sau la sfarsit for(p=radacina; p->urm!=NULL && p->urm->info<infonou; p=p->urm); nou->urm=p->urm; p->urm=nou; } return radacina; } void main(void) { char o; float val; nod *radacina=NULL, *p; /* pastreaza inceputul listei */ puts(""); while(1) { puts(""); /* se afiseaza meniul programului * puts("a : adauga un nod"); puts("c : cauta si tiparese un nod"); puts("s : sterge un nod"); puts("l : listeaza tot"); puts("t : termina programul"); printf("\nOptiunea: "); while(isspace(o=getchar()) ); puts(""); switch (tolower(o)) { case 'a': { printf("adauga nr="); scanf("%f", &val); radacina=introduc(radacina, val); break;} case 'c': { puts("cauta si tipareste un nod"); printf("nr="); scanf("%f", &val); if ((p=caut(radacina, val))!=NULL) /* cauta nodul in lista */ printf(" Valoare:%f\n", p->info); else printf("Eroare: Identificator nedefinit\n"); break; } case 's':{ printf("stergere nr="); scanf("%f", &val); radacina=sterg(radacina, val); /* sterge nodul din lista */ break;} case 'l':{ puts("listare"); listez(radacina); break;}

case 't': return; default: printf("Eroare : Comanda inexistenta\n"); } } } Maxim triunghiul deasupra diagonalei matrice #include <stdio.h> #include <conio.h > int a[10][10],i,j,m,max; void main() { clrscr(); printf("dati m"); scanf("%d",&m); for (i=0;i<m;i++) for (j=0;j<m;j++) { printf("\n dati a[%d][%d]=",i,j); scanf("%d",&a[i][j]); } max=a[0][1]; for (i=0;i<(m-1)/2;i++) for (j=i+1;j<m-1-i;j++) if (a[i][j]>max) max=a[i][j]; printf("maximul este= %d",max); getch(); } Maxim #include<stdio.h> #include<conio.h> int max(int a, int b) { if (a>b) return a; else return b; } int max_cif(int n) { if(n<10) return n; else return max(n%10, max_cif(n/10)); } void main(void) { clrscr(); int n; printf("dati nr: ");

scanf("%d",&n); printf("%d",max_cif(n)); } Minim triunghiul sub diagonala matrice #include <stdio.h> #include <conio.h> int a[10][10],i,j,m,min; void main() { clrscr(); printf("dati m"); scanf("%d",&m); for (i=0;i<m;i++) for (j=0;j<m;j++) { printf("\n dati a[%d][%d]=",i,j); scanf("%d",&a[i][j]); } min=a[m-1][1]; for (i=m/2+1;i<m;i++) for (j=m-i-1;j<i;j++) if (a[i][j]<min) min=a[i][j]; printf("minimul este %d ",min); getch(); } Numar de divizori pari #include<stdio.h> #include<conio.h> int pari(int n, int i) { if(i>n) return 0; else if((n%i==0)&&(i%2==0)) { printf("divizor par: %d\n",i); return 1 + pari(n,i+1); } else return pari(n,i+1); } void main(void) { int n; clrscr(); printf("dati nr: "); scanf("%d",&n); printf("numarul de divizori pari a lui %d este %d ",n,pari(n,1)); } Numar de divizori proprii #include<stdio.h>

#include<conio.h> int nr_prop(int n, int i) { if (i>=n) return 0; else if (n%i==0) return 1 + nr_prop(n,i+1); else return nr_prop(n,i+1); } void main(void) { int n; clrscr(); printf("dati nr: "); scanf("%d",&n); printf("numarul de divizori proprii a lui %d este %d",n,nr_prop(n,2)); } Palindrom recursiv #include<stdio.h> #include<conio.h> int rasturnat(int n) { if(n<10) return n; else return (n%10) * 10 + rasturnat(n/10); } int palindrom(int n) { if(n<10) return 1; else if(rasturnat(n)!=n) return 0; else return 1; } void main(void) { int n; clrscr(); printf("dati nr: "); scanf("%d",&n); printf("rasturnatul lui %d este: %d\n",n,rasturnat(n)); if(palindrom(n)==1) printf("numarul %d este palindrom \n",n); else printf("numarul %d nu este palindrom \n",n); } Partitiile unei multimi #include<stdio.h> #include<conio.h> int n, x[10], max[10]; void afis (int p) //p este nr de submultimi din partitia curenta { for( int i=1;i<p;i++) { printf("{ "); for(int j=1;j<=n;j++)

if(x[j]==x[i]) printf("%d ",j); printf("}+"); } printf("{ "); for(int j=1;j<=n;j++) if(x[j]==p) printf("%d ",j); printf("}"); putchar('\n'); } void partitii(int i) { for (int j=1;j<=1+max[i-1];j++) { x[i]=j; if(x[i]>max[i-1]) max[i]=x[i]; else max[i]=max[i-1]; if(i==n) afis(max[i]); else partitii(i+1); } } void main(void) { printf("n=..."); scanf("%d",&n); max[0]=0; partitii(1); getch(); } Permutari backtracking elementar #include<stdio.h> #include<conio.h> int stiva[20],n,k; void tipareste() { int i; for(i=1;i<=n;i++) printf("%d",stiva[i]); putchar('\n'); } int valid() { int i; for(i=1;i<k;i++) if(stiva[i]==stiva[k]) return(0); return(1); } void permutari() { k=1; while(k>0) if (stiva[k]<n) { stiva[k]++; if (valid()==1) if(k==n) tipareste();

else {k++; stiva[k]=0; } } else k--; } void main(void) { printf("Introduceti valoarea lui n:"); scanf("%d",&n); permutari(); } Cozi //Primele n nr prime se introduc intr-o coada, din coada in stiva #include<stdio.h> #include<stdlib.h> #include<conio.h> struct CS { int info; CS* urm; }; typedef CS* nod; nod vc, vs, sf; void pushc(int n) { nod c; if(!vc) { vc=(nod)malloc(sizeof(CS)); vc->info=n; vc->urm=0; sf=vc; } else { c=(nod)malloc(sizeof(CS)); sf->urm=c; c->info=n; c->urm=0; sf=c; } } void popc() { nod c; if(vc) { printf("Am extras elem: %d\n",vc->info); printf("Am adaugat elem: %d la stiva \n",vc->info); vc=vc->urm; free(c); } } void tiparestec() { nod c=vc; printf("Traversam coada: "); if(!c) printf("Coada este vida!"); while(c) { printf("%d ",c->info);

c=c->urm; } printf("\n\n"); } void pushs(int n) { nod c; if(!vs) { vs=(nod)malloc(sizeof(CS)); vs->info=n; vs->urm=0; } else { c=(nod)malloc(sizeof(CS)); c->info=n; c->urm=vs; } } void pops() { nod c; if(!vs) printf("Stiva este goala!"); else { printf("Elimin elem: %d\n",vs->info); c=vs; vs=vs->urm; free(c); } } void tiparestes() { nod c=vs; printf("Traversam stiva: "); if(!c) printf("Stiva este vida!\n"); while(c) { printf("%d ",c->info); c=c->urm; } printf("\n\n"); } void main(void) { int n,a[20],i,j; clrscr(); do { printf("Introduceti elem: (-1 pt elim sau 0 pt iesire) "); scanf("%d",&n); if(n) if(n!=(-1)) { pushc(n); tiparestec(); } else { popc(); tiparestec(); } } while(n); } Problema recursivitate 1 #include<stdio.h> int suma(int n)

{ if (n==0) return 0; else return (n%10)+suma(n/10); } void main(void) { int n; printf("dati nr: "); scanf("%d",&n); printf("%d",suma(n)); } Problema recursivitate 2 #include<stdio.h> int s_par(int n) { if (n==0) return 0; else if (n%2==0) return (n%10)+s_par(n/10); else return s_par(n/10); } void main(void) { int n; printf("dati nr: "); scanf("%d",&n); printf("%d",s_par(n)); } Problema recursivitate 4 #include<stdio.h> #include<conio.h> int nr_imp(int n) { if (n==0) return 0; else if (n%2!=0) return 1 + nr_imp(n/10); else return nr_imp(n/10); } void main(void) { clrscr(); int n; printf("dati nr: "); scanf("%d",&n); printf("%d",nr_imp(n)); } Problema recursivitate 5 #include<stdio.h> #include<conio.h>

int max(int a, int b) { if (a>b) return a; else return b; } int max_cif(int n) { if(n<10) return n; else return max(n%10, max_cif(n/10)); } void main(void) { clrscr(); int n; printf("dati nr: "); scanf("%d",&n); printf("%d",max_cif(n)); } Problema recursivitate 6 #include<stdio.h> #include<conio.h> int divi3(int n) { if (n==0) return 1; else if (n%3==0) return n%10 * divi3(n/10); else return divi3(n/10); } void main(void) { clrscr(); int n; printf("dati nr: "); scanf("%d",&n); printf("%d",divi3(n)); } Problema recursivitate 7 #include<stdio.h> #include<conio.h> int suma_divi(int n, int i) { if(i==n) return n; else if(n%i==0) return i + suma_divi(n,i+1); else return suma_divi(n,i+1); } void main(void) { int n; printf("dati nr: ");

scanf("%d",&n); printf("suma divizorilor lui %d este %d ",n,suma_divi(n,1)); } Problema recursivitate 8 #include<stdio.h> #include<conio.h> int pari(int n, int i) { if(i>n) return 0; else if((n%i==0)&&(i%2==0)) { printf("divizor par: %d\n",i); return 1 + pari(n,i+1); } else return pari(n,i+1); } void main(void) { int n; clrscr(); printf("dati nr: "); scanf("%d",&n); printf("numarul de divizori pari a lui %d este %d ",n,pari(n,1)); } Problema recursivitate 9 #include<stdio.h> #include<conio.h> int nr_prop(int n, int i) { if (i>=n) return 0; else if (n%i==0) return 1 + nr_prop(n,i+1); else return nr_prop(n,i+1); } void main(void) { int n; clrscr(); printf("dati nr: "); scanf("%d",&n); printf("numarul de divizori proprii a lui %d este %d",n,nr_prop(n,2)); } Problema recursivitate 10 #include<stdio.h> #include<conio.h> int suma_patr(int n) { if(n==0) return 0; else return (n%10)*(n%10)+ suma_patr(n/10); }

void main(void) { int n; clrscr(); printf("dati nr: "); scanf("%d",&n); printf("suma patratelor cifrelor lui %d este %d",n,suma_patr(n)); } Problema recursivitate 11 #include<stdio.h> #include<conio.h> int min(int a, int b) { if (a<b) return a; else return b; } int cif_pmin(int n) { if(n<10) if(n%2==0) return n; else return 1; else if((n%10)%2==0) return min(n%10, cif_pmin(n/10)); else cif_pmin(n/10); } void main(void) { int n; clrscr(); printf("dati nr: "); scanf("%d",&n); printf("cifra minima para din %d este %d ",n,cif_pmin(n)); } Problema recursivitate 12 #include<stdio.h> #include<conio.h> int baza (int n, int b) { if(n==0) return 0; else return (n%b)+10*baza(n/b,b); } void main(void) { int n, b; clrscr(); printf("dati nr: \n"); scanf("%d",&n); printf("dati baza: \n"); scanf("%d",&b); printf("numarul %d in baza %d este %d",n,b,baza(n,b));

} Problema recursivitate 13 #include<stdio.h> #include<conio.h> int baza10(int n, int b) { if (n==0) return 0; else return (n%10)+b*baza10(n/10,b); } void main(void) { int n,b; clrscr(); printf("dati nr: \n"); scanf("%d",&n); printf("dati baza: \n"); scanf("%d",&b); printf("numarul %d in baza %d in baza 10 va fi: %d",n,b,baza10(n,b)); } Problema recursivitate 14 #include<stdio.h> #include<conio.h> #include<math.h> int suma_pcif(int x) { if(x<10) if(x%2==0) return x; else return 0; else if((x%10)%2==0)return (x%10) + suma_pcif(x/10); else return suma_pcif(x/10); } int prop(int x, int j) { if(j>=x) return 0; else if(x%j==0) return 1 + prop(x,j+1); else return prop(x,j+1); } int prim(int x, int i) { if (i>sqrt(x)) return 1; else if(x%i==0) return 0; else return prim(x,i+1); } 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);

} int nu(int x) { if(x==0) return 0; else if((x%10)%2!=0) return nu(x/10)*10+x%10; else return nu(x/10); } void main(void) { int a[50], i, n, m; clrscr(); printf("dati dimensiunea sirului: "); scanf("%d",&n); for(i=0;i<n;i++) { printf("a[%d]= ",i); scanf("%d",a+i); } printf("suma cifrelor pare pt fiecare elem: "); for(i=0;i<n;i++) printf("%d ",suma_pcif(a[i])); printf("\n"); printf("nrumarul de divizori pari a fiecarui elem: "); for(i=0;i<n; i++) printf("%d ",prop(a[i],2)); printf("\n"); printf("pozitiile din sir care detin elem prime: "); for(i=0;i<n;i++) if(prim(a[i],2)==1) printf("%d ",i); printf("\n"); printf("cmmdc-ul elem din sir: "); m=cmmdc(a[0],a[1]); for(i=2;i<n;i++) m=cmmdc(m,a[i]); printf("%d ",m); printf("\n"); printf("elem din sir fara cifrele pare: "); for(i=0;i<n;i++) printf("%d ",nu(a[i])); } Problema recursivitate 15 #include<stdio.h> #include<conio.h> int a[50], n; int suma(int n) { if(n==-1) return 0; else return a[n]+suma(n-1); } int nr_imp(int n) { if(n==-1) return 0; else if(a[n]%2!=0) return 1+nr_imp(n-1); else return nr_imp(n-1); }

int prod(int n) { if(n==-1) return 1; else if(a[n]%2==0) return a[n] * prod(n-1); else return prod(n-1); } int min(int a, int b) { if(a<=b) return a; else return b; } void main(void) { int i,m; clrscr(); printf("dati dimenisunea sirului: "); scanf("%d",&n); for(i=0;i<n;i++) { printf("a[%d]= ",i); scanf("%d",a+i); } printf("suma elem sirului: %d\n",suma(n)); printf("nr elem imp din sir: %d\n",nr_imp(n)); printf("produsul elem pare din sir: %d\n",prod(n)); m=a[0]; for(i=1;i<n;i++) m=min(m,a[i]); printf("minimul din sir: %d\n",m); }

Problema recursivitate 16 #include<stdio.h> #include<conio.h> int a[50], n; int prod(int n) { if(n==-1) return 1; else if((a[n]>0)&&(a[n]%2!=0)) return a[n]*prod(n-1); else return prod(n-1); } int pozitii(int n) { if(n<=-1) return 0; else if((n%2!=0)&&(a[n]>=0)) return 1 + pozitii(n-1); else return pozitii(n-1); } int exista(int n) { if (n==-1) return 0; else if(a[n]==0) return 1;

else return exista(n-1); } int val (int n, int x) { if(n==-1) return 0; else if(a[n]==x) return n; else return val(n-1,x); } void main(void) { int i,x; clrscr(); printf("dati dimensiunea sirului: "); scanf("%d",&n); for(i=0;i<n;i++) { printf("a[%d]= ",i); scanf("%d",a+i); } printf("produsul elementelor pozitive si impare: %d\n",prod(n)); printf("numarul elementelor pozitive de pe pozitiile impare din sir: %d\n",pozitii(n)); if(exista(n)==1) printf("exista cel putin un elem nul in sir \n"); else printf("nu exista nici un elem nul in sir \n"); printf("dati o valoare: "); scanf("%d",&x); printf("pozitia pe care se afla %d: %d\n",x,val(n,x)); } Problema recursivitate 17 #include<stdio.h> #include<conio.h> int suma(int n) { if(n==0) return 0; else if((n%10)%3==0) return (n%10) + suma(n/10); else return suma(n/10); } int mic3(int n) { if(n==0) return 0; else if((n%10)<3) return 1+ mic3(n/10); else return mic3(n/10); } int prod(int n) { if(n==0) return 1; else if((n%10)%2!=0) return n%10 * prod(n/10); else return prod(n/10); } int elimin(int n) { if(n==0) return 0;

else if (n%10==5) return elimin(n/10); else return n%10 + 10 * elimin(n/10); } void main(void) { int n; clrscr(); printf("dati nr: "); scanf("%d",&n); printf("suma cifrelor lui %d divizibile cu 3 este: %d\n",n,suma(n)); printf("numarul cifrelor mai mici ca 3 din %d este: %d\n",n,mic3(n)); printf("produsul cifrelor imparele a lui %d este: %d\n",n,prod(n)); printf("dupa eliminarea cifrei 5 din %d este: %d",n,elimin(n)); } Problema recursivitate 18 #include<stdio.h> #include<conio.h> int rasturnat(int n) { if(n<10) return n; else return (n%10) * 10 + rasturnat(n/10); } int palindrom(int n) { if(n<10) return 1; else if(rasturnat(n)!=n) return 0; else return 1; } void main(void) { int n; clrscr(); printf("dati nr: "); scanf("%d",&n); printf("rasturnatul lui %d este: %d\n",n,rasturnat(n)); if(palindrom(n)==1) printf("numarul %d este palindrom \n",n); else printf("numarul %d nu este palindrom \n",n); } Problema recursivitate 19 #include<stdio.h> #include<conio.h> int fibo1(int n) { if(n<=2) return 1; else return fibo1(n-1)+fibo1(n-2); } int fibo2(int n, int a, int b)

{ if(n==1) return a; else return fibo2(n-1, a+b, b); } void main(void) { int n; clrscr(); printf("dati nr: "); scanf("%d",&n); printf("al %d nr din sirul fibonaci: %d\n",n,fibo1(n)); printf("%d",fibo2(n,1,1)); } Problema recursivitate 20 #include<stdio.h> #include<conio.h> int prod(int a, int b) //a*b prin adunari repetate { if(b==0) return 0; else return a + prod(a,b-1); } int suma(int n) // 1+11+111+1111+...+111111111 { if(n==0) return 0; else return suma(n-1)*10+n; } int putere(int n) // 2 la puterea n { if(n==0) return 1; else return 2*putere(n-1); } void main(void) { int a, b, n; clrscr(); printf("dati nr1: "); scanf("%d",&a); printf("dati nr2: "); scanf("%d",&b); printf("%d * %d = %d\n",a,b,prod(a,b)); printf("dati nr de termeni pt suma: "); scanf("%d",&n); printf("suma este: %d\n",suma(n)); printf("2 la puterea %d este: %d",n,putere(n)); } Recursivitate 2 la o putere

#include<stdio.h> #include<conio.h> int prod(int a, int b) //a*b prin adunari repetate { if(b==0) return 0; else return a + prod(a,b-1); } int suma(int n) // 1+11+111+1111+...+111111111 { if(n==0) return 0; else return suma(n-1)*10+n; } int putere(int n) // 2 la puterea n { if(n==0) return 1; else return 2*putere(n-1); } void main(void) { int a, b, n; clrscr(); printf("dati nr1: "); scanf("%d",&a); printf("dati nr2: "); scanf("%d",&b); printf("%d * %d = %d\n",a,b,prod(a,b)); printf("dati nr de termeni pt suma: "); scanf("%d",&n); printf("suma este: %d\n",suma(n)); printf("2 la puterea %d este: %d",n,putere(n)); } Problema drapelelor #include<stdio.h> char cul[7][11]={"alb","galben","portocaliu","rosu","verde","albastru","negru"}; int k,drapel[3]; void tipareste() {int i; for(i=1;i<=3;i++) printf("%s ",cul[drapel[i]-1]); putchar('\n'); } int valid() {int ok=1,i; if(k==2) if((drapel[k]!=1)&&(drapel[k]!=2)) ok=0; for(i=1;i<k;i++)

if(drapel[i]==drapel[k])ok=0; return ok; } void back() { k=1; while(k>0) if(drapel[k]<7) {drapel[k]++; if(valid()==1) if(k==3) tipareste(); else {k++; drapel[k]=0; } } else k--; } void main() { back(); }

Problema margelelor // n margele de m culorii (culori reprezentate prin nr de la 1 la m). sa se aranjeze margelele a.i. 2 margele alaturate sa aiba culori diferite #include<stdio.h> #include<conio.h> int n,m,a[10]; void afisare(void) { int i; for(i=1;i<=n;i++) printf("%d",a[i]); putchar('\n'); } int parcurs(int j) { if(a[j]==a[j-1]) return 0; return 1; } void inter(int i) { int j; for(j=1;j<=m;j++) { a[i]=j; if(parcurs(i)) if(i==n) afisare();

else inter(i+1); } } void main(void) { printf("n=..."); scanf("%d",&n); printf("m=..."); scanf("%d",&m); if(m==1) printf("Nu exista solutie!"); else inter(1); getch(); } Recursivitate nr dintr-o baza in alta #include<stdio.h> #include<conio.h> int baza (int n, int b) { if(n==0) return 0; else return (n%b)+10*baza(n/b,b); } void main(void) { int n, b; clrscr(); printf("dati nr: \n"); scanf("%d",&n); printf("dati baza: \n"); scanf("%d",&b); printf("numarul %d in baza %d este %d",n,b,baza(n,b)); } Recursivitate numere impare #include<stdio.h> #include<conio.h> int nr_imp(int n) { if (n==0) return 0; else if (n%2!=0) return 1 + nr_imp(n/10); else return nr_imp(n/10); } void main(void) { clrscr(); int n; printf("dati nr: "); scanf("%d",&n);

printf("%d",nr_imp(n)); } Sa se genereze primele n numere din sirul fibonacci cu recurivitate #include<stdio.h> #include<conio.h> void main (void) { int i,n; int fib(int); printf("Cate numere fibonacci doriti sa generati?: "); scanf("%d",&n); for(i=0;i<n;i++) printf("Fibonacci[%d]=%d\n",i,fib(i)); getch(); } int fib(int n) { if((n==0)||(n==1)) return(1); else return(fib(n-1)+fib(n-2)); } Problema calului 2 #include<stdio.h> #include<conio.h> int a[8]={2,1,-1,-2,-2,-2,1,2}, b[8]={1,2,2,1,-1,-2,-2,-1}; int t[10][10],m,n; void afiseaza(void) { int p,r; for(p=0;p<m;p++) { for(r=0;r<n;r++) printf("3%d",t[p][r]); putchar('\n'); } getch(); } void cal(int i, int j, int k) { int i1,j1,d; for(d=0;d<8;d++) { i1=i+a[d]; j1=j+b[d]; if((i1<m)&&(j1<n)&&(i1>=0)&&(j1>=0)&&(!t[i1][j1])) { t[i1][j1]=k; if(k<m*n) cal(i1,j1,k+1); else { afiseaza(); putchar('\n');

t[i1][j1]=0; } } } t[i][j]=0; }

void main(void) { int i,j; printf("Introduceti numarul de linii: "); scanf("%d",&m); printf("Introduceti numarul de coloane: "); scanf("%d",&n); for(i=0;i<n;i++) for(j=0;j<n;j++) t[i][j]=0; t[0][0]=1; cal(0,0,2); } Recursivitate suma cifrelor unui numar recursiv #include<stdio.h> int suma(int n) { if (n==0) return 0; else return (n%10)+suma(n/10); } void main(void) { int n; printf("dati nr: "); scanf("%d",&n); printf("%d",suma(n)); } Suma divizorilor recursivitate #include<stdio.h> #include<conio.h> int suma_divi(int n, int i) { if(i==n) return n; else if(n%i==0) return i + suma_divi(n,i+1); else return suma_divi(n,i+1); } void main(void) { int n; printf("dati nr: "); scanf("%d",&n);

printf("suma divizorilor lui %d este %d ",n,suma_divi(n,1)); } Rezolvarea ecuatiei ax2 + bx +c = 0 #include<stdio.h> #include<math.h> // se foloseste pt delta int main() { double a, b, c, d; printf("a="); scanf("%lf", &a); printf("b="); scanf("%lf", &b); printf("c="); scanf("%lf", &c); if (a==0) { if (b==0) { if (c==0) { printf("Orice x este solutie a ecuatiei\n"); } else { printf("Nu exista nici o solutie\n"); } } else { printf("Solutia ecuatiei este x = %lf\n", -c/b); } } else { d = (b*b)-(4*a*c); if (d>=0) { printf("x1 = %lf\nx2= %lf\n", (-b+sqrt(d))/(2*a), (-bsqrt(d))/(2*a)); // se foloseste sqrt pentru radical } else { printf("Nu exista solutie reala\n"); } } return 0; }

Ridicarea matricii la putere # include <stdio.h> int main () { int m,n,p,i,j,k; double a[100][100], c[100][100];

printf("m="); scanf("%d", &m); printf("n="); scanf("%d", &n); printf("Introduceti elementele matricii a\n"); for(i=0;i<m;i++) for(j=0;j<n;j++) { printf("a[%d],[%d]=",i,j);scanf("%lf",&a[i][j]); } printf("puterea="); scanf("%d", &p); for (i=0; i<p; i++) { for (i=0; i<m; i++) for (j=0; j<n; j++) { c[i][j]=0; for (k=0; k<n; k++) c[i][j]+=a[i][k]*a[k][j]; } for (i=0; i<m; i++) { for (j=0; j<n; j++) printf("%5.2lf ", c[i][j]); printf("\n"); } } return 0; } se citeste matricea adiacenta a unui graf.Sa se determine daca graful este hamiltonian #include<stdio.h> #include<conio.h> int stiva[100],n,m,k,nr_solutii,a[20][20]; int verifica() {

int i; if(!a[stiva[k-1]][stiva[k]]) return 0; else for(i=1;i<=k;i++) if(stiva[i]==stiva[k]) return 0; if(k==n) if(!a[stiva[1]][stiva[k]]) return 0; return 1; } void tipareste_solutie() { int i; for(i=1;i<=n;i++) printf("%d",stiva[i]); k=0; nr_solutii++; } void cauta() { k=1; while (k>0) if(stiva[k]<n) { stiva[k]++; if(verifica()) if(k==n) tipareste_solutie(); else { k++; stiva[k]=0; } } else k--; } void main() { int i,j; printf("Introduceti numarul de noduri: "); scanf("%d",&n); printf("Introduceti matricea adiacenta:\n"); for(i=1;i<=n;i++) for(j=1;j<=n;j++) { printf("a[%d][%d]= ",i,j); scanf("%d",&a[i][j]); } cauta(); if(nr_solutii=0) printf("Nu exista solutie!\n"); getch();

} sa se genereze toate nr de lungime n formate numai cu cifre pare #include<stdio.h> #include<conio.h> int n, x[10]; void afis() { int i; for(i=1;i<=n;i++) printf("%d",x[i]); putchar('\n'); } void cifre(int i) { int j; for(j=0;j<=8;j=j+2) { x[i]=j; if(i==n) afis(); else cifre(i+1); } } void main() { printf("n=..."); scanf("%d",&n); cifre(1); getch(); } Se citeste mat de adiacenta.graful este hamiltonian #include<stdio.h> #include<conio.h> int stiva[100],n,m,k,nr_solutii,a[20][20]; int verifica() { int i; if(!a[stiva[k-1]][stiva[k]]) return 0; else for(i=1;i<=k;i++) if(stiva[i]==stiva[k]) return 0; if(k==n) if(!a[stiva[1]][stiva[k]]) return 0; return 1; } void tipareste_solutie() {

int i; for(i=1;i<=n;i++) printf("%d",stiva[i]); k=0; nr_solutii++; } void cauta() { k=1; while (k>0) if(stiva[k]<n) { stiva[k]++; if(verifica()) if(k==n) tipareste_solutie(); else { k++; stiva[k]=0; } } else k--; } void main() { int i,j; printf("Introduceti numarul de noduri: "); scanf("%d",&n); printf("Introduceti matricea adiacenta:\n"); for(i=1;i<=n;i++) for(j=1;j<=n;j++) { printf("a[%d][%d]= ",i,j); scanf("%d",&a[i][j]); } cauta(); if(nr_solutii=0) printf("Nu exista solutie!\n"); getch(); } Sortare ordinara #include<stdio.h> #include<conio.h> void sortare_ordinara(int a[], int n) { int i,k,elem; do { for(i=0,k=0;i<n-1;i++) if(a[i]>a[i+1])

{ elem=a[i]; a[i]=a[i+1]; a[i+1]=elem; k=1; } } while(k); } void main(void) { int n,a[100],i; printf("Introduceti dimensiunea sirului: "); scanf("%d",&n); printf("Introduceti elementele sirului:\n"); for(i=0;i<n;i++) { printf("a[%d]= ",i); scanf("%d",a+i); } sortare_ordinara(a,n); printf("Sirul sortat este: "); for(i=0;i<n;i++) printf("%d",a[i]); getch(); } Sortare prin bubble sort #include<stdio.h> #include<conio.h> void bubble_sort(int a[],int n) { int i,j,elem; for(i=n-1;i>0;i--) for(j=1;j<=i;j++) if(a[j-1]>a[j]) { elem=a[j-1]; a[j-1]=a[j]; a[j]=elem; } } void main(void) { int n,a[100],i; printf("Introduceti dimensiunea sirului: "); scanf("%d",&n); printf("Introduceti elementele sirului:\n"); for(i=0;i<n;i++) { printf("a[%d]= ",i); scanf("%d",a+i);

} bubble_sort(a,n); printf("Sirul sortat este: "); for(i=0;i<n;i++) printf("%d",a[i]); getch(); } Sortare prin insertie binara #include<stdio.h> #include<conio.h> int insertie_binara(int a[],int i) { int stanga,dreapta,m; stanga=0; dreapta=i-1; while(stanga<=dreapta) { m=(stanga+dreapta)/2; if(a[m]<a[i]) stanga=m+1; else if(a[m]>a[i]) dreapta=m-1; else return(m); } return(stanga); } void main(void) { int n,a[100],i,j,elem,index;; printf("Introduceti dimensiunea sirului: "); scanf("%d",&n); printf("Introduceti elementele sirului:\n"); for(i=0;i<n;i++) { printf("a[%d]= ",i); scanf("%d",a+i); } for(i=1;i<n;i++) { index=insertie_binara(a,i); elem=a[i]; for(j=i-1;j>=index;j--) a[j+1]=a[j]; a[index]=elem; } printf("Sirul sortat este: "); for(i=0;i<n;i++) printf("%d",a[i]); getch(); }

Sortare prin insertie diminuarea incrementului #include<stdio.h> #include<conio.h> void shell_sort(int a[],int n) { int i,j,elem,h; for(h=1;h<=n/9;h=3*h+1); for(;h>0;h/=3) for(i=h+1;i<=n;i+=h) { elem=a[i]; j=i; while(j>h&&a[j-h]>elem) { a[j]=a[j-h]; j-=h; } a[j]=elem; } } void main(void) { int n,a[100],i; printf("Introduceti dimensiunea sirului: "); scanf("%d",&n); printf("Introduceti elementele sirului:\n"); for(i=1;i<=n;i++) { printf("a[%d]= ",i); scanf("%d",a+i); } shell_sort(a,n); printf("Sirul sortat este: "); for(i=1;i<=n;i++) printf("%d",a[i]); getch(); } Sortare prin insertie directa #include<stdio.h> #include<conio.h> void insertie(int a[],int n) { int i,j,elem; for(i=1;i<n;i++) { elem=a[i]; j=i-1; while((j>=0)&&(elem<=a[j]))

{ a[j+1]=a[j]; j--; } a[j+1]=elem; } } void main(void) { int n,a[100],i; printf("Introduceti dimensiunea sirului: "); scanf("%d",&n); printf("Introduceti elementele sirului:\n"); for(i=0;i<n;i++) { printf("a[%d]= ",i); scanf("%d",a+i); } insertie(a,n); printf("Sirul sortat este: "); for(i=0;i<n;i++) printf("%d",a[i]); getch(); } Sortare prin insertie santinela #include<stdio.h> #include<conio.h> #include<values.h> void insertie_cu_santinela(int a[],int n) { int i,j,elem; a[0]=-MAXINT; for(i=2;i<=n;i++) { elem=a[i]; j=i-1; while(a[j]>elem) { a[j+1]=a[j]; j--; } a[j+1]=elem; } } void main(void) { int n,a[100],i; printf("Introduceti dimensiunea sirului: "); scanf("%d",&n); printf("Introduceti elementele sirului:\n");

for(i=0;i<n;i++) { printf("a[%d]= ",i); scanf("%d",a+i); } insertie_cu_santinela(a,n); printf("Sirul sortat este: "); for(i=0;i<n;i++) printf("%d",a[i]); getch(); }

Sortare prin interclasare #include<stdio.h> #include<conio.h> void merge(int a[],int l,int m,int r) { int b[100],i=1,j=m+1,k=1,ind; while((i<=m)&&(j<=r)) { if(a[i]<=a[j]) b[k]=a[i++]; else b[k]=a[j++]; k++; } if(i>m) for(ind=j;ind<=r;ind++,k++) b[k]=a[ind]; else for(ind=i;ind<=m;ind++,k++) b[k]=a[ind]; for(ind=l;ind<=r;ind++) a[ind]=b[ind]; } void merge_sort(int a[], int l,int r) { int m; if(l<r) { m=(l+r)/2; merge_sort(a,1,m); merge_sort(a,m+1,r); merge(a,1,m,r); } } void main(void) { int n,a[100],i; printf("Introduceti dimensiunea sirului: "); scanf("%d",&n); printf("Introduceti elementele sirului:\n"); for(i=0;i<n;i++) { printf("a[%d]= ",i); scanf("%d",a+i); }

merge_sort(a,0,n-1); printf("Sirul sortat este: "); for(i=0;i<n;i++) printf("%d",a[i]); getch(); } Sortare prin numarare #include<stdio.h> #include<conio.h> #define N 100 int a[N],count[N],n,vmin,vmax; int count_sort(void) { int i,indice; for(i=0;i<vmax-vmin+1;i++) count[i]=0; for(i=0;i<n;i++) { if((a[i]<vmin)||(a[i]>vmax)) return(0); count[a[i]-vmin]++; } indice=0; for(i=0;i<vmax-vmin+1;i++) while(count[i]) { a[indice]=i+vmin; indice++; count[i]--; } return(1); } void main(void) { int i,k; printf("Introd vmin:"); scanf("%d",&vmin); printf("Introd vmax:"); scanf("%d",&vmax); printf("Introd nr de elemente ale sirului:"); scanf("%d",&n); for(i=0;i<n;i++) { printf("a[%d]=",i); scanf("%d",&a[i]); } k=count_sort(); if(k) { printf("Sirul sortat este:"); for(i=0;i<n;i++)printf("%d",a[i]); putchar('\n');

} else printf("Sirul nu respecta conditiile\n"); getch(); } Sortare prin selectie #include<stdio.h> #include<conio.h> void selectie(int a[],int n) { int i,j,k,min; for(i=0;i<=n-1;i++) { k=i; min=a[i]; for(j=i+1;j<n;j++) if(a[j]<min) k=j,min=a[j]; a[k]=a[i]; a[i]=min; } } void main(void) { int n,a[100],i,j,k,min; printf("Introduceti dimensiunea sirului: "); scanf("%d",&n); printf("Introduceti elementele sirului:\n"); for(i=0;i<n;i++) { printf("a[%d]= ",i); scanf("%d",a+i); } selectie(a,n); printf("Sirul sortat este: "); for(i=0;i<n;i++) printf("%d",a[i]); getch(); } Sortare rapida #include<stdio.h> #include<conio.h> #include<values.h> void qs(int a[],int l, int r) { int v,i,j,elem; if(r>1) { v=a[r];

i=l-1; j=r; for(;;) { while(a[++i]<v); while(a[--j]>v); if(i>=j) break; elem=a[i]; a[i]=a[r]; a[r]=elem; } elem=a[i]; a[i]=a[r]; a[r]=elem; qs(a,l,i-1); qs(a,i+1,r); } } void main(void) { int n,a[100],i; printf("Introduceti dimensiunea sirului: "); scanf("%d",&n); printf("Introduceti elementele sirului:\n"); for(i=1;i<=n;i++) { printf("a[%d]= ",i); scanf("%d",a+i); } a[0]=-MAXINT qs(a,1,n); printf("Sirul sortat este: "); for(i=1;i<=n;i++) printf("%d",a[i]); getch(); } Sortarea radix directa #include<stdio.h> #include<conio.h> void straight_radix_sort(int a[],int b[], int n) { int k,trecere,count[2]; unsigned int BitMask=1; //pornim cu bitul masca avnd valoarea 1 //reprezentat ca 0...001 (8*sizeof(int) pozitii) for (trecere=0;trecere<8*sizeof(int);trecere++ ) { count[0]=count[1]=0; //la fiecare nceput de trecere, initializam cu 0 //numarul de aparitii pentru bitul 0 si 1 for (k=1;k<=n;k++) //pentru fiecare element, n functie de valoarea bitului corespunzator

// trecerii (0 sau 1), vom incrementa pozitia corespunzatoare din sirul ce //contine numarul de aparitii if (a[k] & BitMask) count[1]++; else count[0]++; count[1]=count[1]+count[0]; for (k=n;k>=1;k--) //fiecare element va fi plasat la pozitia corespunzatoare, n functie de // valoarea 0 sau 1 a bitului corespunzator trecerii dupa care // decrementam n sirul de aparitii valoarea corespunzatoare if (a[k] & BitMask) b[count[1]]=a[k], count[1]--; else b[count[0]]=a[k], count[0]--; for (k=1;k<=n;k++) a[k]=b[k]; //mutam elementele din sirul provizoriu b n a decalam la stnga cu o BitMask<<=1; //pozitie pentru a duce valoarea 1 cu o pozitie la stnga si a putea //obtine masca pentru aflarea urmatorului bit (spre stnga) } //se nchide ciclul for } void main(void) { int i,n,a[100],b[100]; printf("Introduceti dimensiunea sirului: "); scanf("%d",&n); printf("Introduceti elementele sirului:\n"); for(i=1;i<=n;i++) { printf("a[%d]= ",i); scanf("%d",a+i); } straight_radix_sort(a,b,n); printf("Sirul sortat este: "); for(i=1;i<=n;i++) printf("%d ",a[i]); getch(); } Sortarea radix prin interschimbare #include<stdio.h> #include<conio.h> int n,a[100]; unsigned bit(unsigned x, int k) { return((x>>k)&1); } void radix_interschimbare(int s, int d, int b) { int i,j,elem; if((d>s)&&(b>=1)) { i=s;j=d;b--; //pornim cu i de la marginea stnga, cu j de la marginea dreapta //decrementam b (pornim cu b de la 8*sizeof(int)=16 iar prima /decalare se face cu //15 pozitii pentru a obtine bitul cel mai semnificativ; ultima decalare se face cu b=0 pozitii) do

//i va pastra indicele primului element (pornind din stnga) // avnd bitul cautat 1 (fara a depasi j) while((bit(a[j],b)==1)&&(i<j)) j--; //j va pastra indicele primului element (pornind din dreapta) // avnd bitul cautat 0 (fara a scadea sub i) elem=a[i]; a[i]=a[j]; a[j]=elem; //inversam cele doua elemente (a[i] cu a[j]) } while(!(j==i)); //repetam att timp ct i diferit de j if(bit(a[d],b)==0) j++; //daca toti bitii testati sunt 0 se reface lungimea partitiei radix_interschimbare(s,j-1,b); //aplicam Divide et Impera pentru partitia (s,j-1) radix_interschimbare(j,d,b); //aplicam Divide et Impera pentru partitia (j,d) } //se ncheie if((d>s)&&(b>=1)) } void main(void) { int i; printf("Introduceti dimensiunea sirului: "); scanf("%d",&n); printf("Introduceti elementele sirului:\n"); for(i=0;i<n;i++) { printf("a[%d]= ",i); scanf("%d",a+i); } radix_interschimbare(0,n-1,8*sizeof(int)); printf("Sirul sortat este: "); for(i=0;i<n;i++) printf("%d",a[i]); getch(); }

{ while((bit(a[i],b)==0)&&(i<j)) i++;

Stiva //Se introduc nr intro stiva, cele prime intr-o a 2 stiva, restu in a 3 stiva //din prima stiva se vor elim elem dupa introducerea in celalalte 2 sive #include<stdio.h> #include<stdlib.h> #include<conio.h> #include<math.h> struct stiva { int info; stiva* urm; }; typedef stiva* nod; nod v,v1,v2; int n; void push(int n) { nod c; if(!v) { v=(nod)malloc(sizeof(stiva)); v->info=n; v->urm=0; } else { c=(nod)malloc(sizeof(stiva)); c->info=n; c->urm=v;

v=c; } } void push1(int n) { nod c; if(!v1) { v1=(nod)malloc(sizeof(stiva)); v1->info=n; v1->urm=0; } else { c=(nod)malloc(sizeof(stiva)); c->info=n; c->urm=v1; v1=c; } } void push2(int n) { nod c2; if(!v2) { v2=(nod)malloc(sizeof(stiva)); v2->info=n; v2->urm=0; } else { c2=(nod)malloc(sizeof(stiva)); c2->info=n; c2->urm=v2; v2=c2; } } void pop() { nod c; if(!v) printf("Stiva este goala!"); else { c=v; printf("Am extras elem: %d\n"); v=v->urm; free(c); } } void tipareste() { nod c=v; printf("Traversam stiva: "); if(!v) printf("Stiva este goala!"); while(c) { printf("%d ",c->info); c=c->urm; } printf("\n\n"); } void tipareste1() { nod c=v; printf("Traversam stiva: "); if(!v1) printf("Stiva este goala!"); while(c) { printf("%d ",c->info);

c=c->urm; } printf("\n\n"); } void tipareste2() { nod c=v; printf("Traversam stiva: "); if(!v2) printf("Stiva este goala!"); while(c) { printf("%d ",c->info); c=c->urm; } printf("\n\n"); } int prim(int n) { int y=2; while(y<=sqrt(n)) if(n%y==0) return 0; else y++; return 1; } void main(void) { do { printf("Introduceti elem: "); scanf("%d",&n); if(n!=-1) push(n); tipareste(); } while(n); do { if(prim(v->info)==1) push1(v->info); else push2(v->info); pop(); } while(v->info); tipareste1(); tipareste2(); } Stiva //Introduceti intr-o stiva primii n termeni ai sirului lui fibonacci #include<stdio.h> #include<stdlib.h> #include<conio.h> struct stiva { int info; stiva* urm; }; typedef stiva* nod; nod v; int n; void push(int n) { nod c; if(!v) { v=(nod)malloc(sizeof(stiva)); v->info=n; v->urm=0; } else { c=(nod)malloc(sizeof(stiva));

c->info=n; c->urm=v; v=c; } } void pop() { nod c; if(!n) printf("Stiva este vida\n"); else { c=v; printf("Am extras elem: %d\n",c->info); v=v->urm; free(c); } } void tipareste() { nod c=v; printf("Traversam stiva: "); if(!c) printf("Stiva este goala!\n"); while(c) { printf("%d ",c->info); c=c->urm; } printf("\n\n"); } void main(void) { int a=1, b=1, c; clrscr(); do { printf("Introduceti elem (-1 pentru extragere elem, 0 pt iesire): "); scanf("%d",&n); if(n) { if(n!=(-1)) while (n!=0) { push(a); c=a+b; a=b; b=c; n--; } tipareste(); } else { pop(); tipareste(); } }while(n); printf("dati -1 pentru extragere elem, 0 pt iesire): "); scanf("%d",&n); while(n!=0) { if(n==-1) { pop(); tipareste(); } printf("dati -1 pentru extragere elem, 0 pt iesire): "); scanf("%d",&n); } } Stiva //Intr-o stiva introduceti cmmdc-ul a m perechi #include<stdio.h>

#include<stdlib.h> #include<conio.h> struct stiva { int info; stiva* urm; }; typedef stiva* nod; nod v; int n; void push(int n) { nod c; if(!v) { v=(nod)malloc(sizeof(stiva)); v->info=n; v->urm=0; } else { c=(nod)malloc(sizeof(stiva)); c->info=n; c->urm=v; v=c; } } void pop() { nod c; if(!v) printf("Stiva este vida!"); else { c=v; printf("Am extras elem: %d\n",c->info); v=v->urm; free(c); } } void tipareste() { nod c=v; if(!c) printf("Stiva este goala!\n"); while(c) { printf("%d ",c->info); c=c->urm; } printf("\n\n"); } int cmmdc(int a, int b) { while(a!=b) if(a>b) a=a-b; else b=b-a; return a; } void main(void) { int a, b, m, i; clrscr(); printf("dati nr de perechi: "); scanf("%d",&m); do { for(i=1; i<=m; i++) { printf("perechea %d: \n",i);

printf("a= "); scanf("%d",&a); printf("b= "); scanf("%d",&b); push(cmmdc(a,b)); } tipareste(); }while(n); } Stiva //introduce in stiva toti divizori #include<stdio.h> #include<stdlib.h> #include<conio.h> struct stiva { int info; stiva* urm; }; typedef stiva* nod; nod v; int n; void push(int n) { nod c; if(!v) { v=(nod)malloc(sizeof(stiva)); v->info=n; v->urm =0; } else { c=(nod)malloc(sizeof(stiva)); c->info=n; c->urm=v; v=c; } } void pop(void) { nod c; if(!v) printf("Stiva este vida\n"); else { c=v; printf("Am extras elem: %d\n",c->info); v=v->urm; free(c); } } void tipareste() { nod c=v; printf("Travesrsam stiva: "); if(!c) printf("Stiva este goala!\n"); while(c) { printf("%d ",c->info); c=c->urm; } printf("\n\n"); } void main(void)

{ int i; clrscr(); do { printf("Introduceti elem (-1 pentru extragere,0 pt iesire): "); scanf("%d",&n); if(n) if(n!=(-1)) { for (i=1;i<=n;i++) if(n%i==0) push(i); tipareste(); } else { pop(); tipareste(); } }while(n); } Stiva //Introduceti in stiva rasturnatele nr citite //Extrageti pana la jumate din stiva elem introduse #include<stdio.h> #include<stdlib.h> #include<conio.h> struct stiva { int info; stiva* urm; }; typedef stiva* nod; nod v; int n; void push(int n) { nod c; if(!v) { v=(nod)malloc(sizeof(stiva)); v->info=n; v->urm=0; } else { c=(nod)malloc(sizeof(stiva)); c->info=n; c->urm=v; v=c; } } void pop() { nod c; if(!v) printf("Stiva este vida \n"); else { c=v; printf("Am extras elem: %d\n",c->info); v=v->urm; free(c); } } void tipareste() { nod c=v; printf("Traversam stiva: ") ;

if(!c) printf("Stiva este goala!\n"); while(c) { printf("%d ",c->info); c=c->urm; } printf("\n\n"); } int rast(int n) { int r=0; while(n!=0) { r=r*10+n%10; n=n/10; } return r; } void main(void) { int nr=0; clrscr(); do { printf("Introduceti elem: (0 pt iesire) "); scanf(" %d",&n); if(n) if(n!=(-1)) { push(rast(n)); nr++; } } while (n); tipareste(); printf("Dati -1 pt a elimina jumate din stiva sau 0 pt a iesi: "); scanf(" %d",&n); nr=nr/2; if(n==-1) while (nr!=0) { pop(); nr--; } tipareste(); } Stiva //Un sir de nr reale se introduc intr-o stiva; Din stiva se vor elimina elem si se vor construi alte 2 stive. //Una care sa contina elem<x(cit de la tastatura), cealalta celalalte elem #include<stdio.h> #include<stdlib.h> #include<conio.h> struct stiva { int info; stiva* urm; }; typedef stiva* nod; nod v, v1, v2; int n; void push(int n) { nod c; if(!v) { v=(nod)malloc(sizeof(stiva)); v->info=n; v->urm=0; }

else { c=(nod)malloc(sizeof(stiva)); c->info=n; c->urm=v; v=c; } } void push1(int n) { nod c; if(!v1) { v1=(nod)malloc(sizeof(stiva)); v1->info=n; v1->urm=0; } else { c=(nod)malloc(sizeof(stiva)); c->info=n; c->urm=v1; v1=c; } } void push2(int n) { nod c; if(!v2) { v2=(nod)malloc(sizeof(stiva)); v2->info=n; v2->urm=0; } else { c=(nod)malloc(sizeof(stiva)); c->info=n; c->urm=v2; v2=c; } } void pop() { nod c; if(!v) printf("Stiva este vida\n"); else { c=v; printf("Am extras elem: %d\n",c->info); v=v->urm; free(c); } } void tipareste() { nod c=v; printf("Traversam stiva: "); if(!c) printf("Stiva este goala!\n"); while(c) { printf("%d ",c->info); c=c->urm; } printf("\n\n"); } void tipareste1() { nod c=v1;

printf("Traversam stiva: "); if(!c) printf("Stiva este goala!\n"); while(c) { printf("%d ",c->info); c=c->urm; } printf("\n\n"); } void tipareste2() { nod c=v2; printf("Traversam stiva: "); if(!c) printf("Stiva este goala!\n"); while(c) { printf("%d ",c->info); c=c->urm; } printf("\n\n"); } void main(void) { int x,i; do { printf("Introduceti elem (-1 pt extragere, 0 pt iesire): "); scanf("%d",&n); if(n!=(-1)) push(n); tipareste(); } while(n); printf("dati val dupa care se imparte stiva: %d"); scanf("%d",&x); do { if(v->info<=x) push1(v->info); else push2(v->info); pop(); } while(v->info); tipareste1(); tipareste2(); } Stiva #include<stdio.h> #include<stdlib.h> #define max 100

static int stiva[max]; static int next=0; //inserare elemnent in stiva// int push(int x) { if (next<max) { stiva[next++]=x; return (0); }

else return (1); } int pop(void) { if (next>0) return (stiva[next--]); } int top (void) { if (next > 0) return (stiva[next-1]); } void clear (void) { next=0; } int full (void) { return (next==max); } int emplty (void) { return (next==0); } void main (void) { int n,k,j; printf("dati valori pt n,k,j"); scanf("%d\n",&k); scanf("%d\n",&j); scanf("%d\n",&n); push (n); push (k); printf ("stiva are %d lemente \n",next); j=pop(); printf("elementul scos din stiva este : %d",j); j=top(); printf ("elementu din varful liste este : %d",j); printf ("stiva are %d elemente \n",next); } Suma cf div cu 3, nr cifre mai mici k 3, prod cifrelor imp, el cifra 5 #include<stdio.h> #include<conio.h> int suma(int n) {

if(n==0) return 0; else if((n%10)%3==0) return (n%10) + suma(n/10); else return suma(n/10); } int mic3(int n) { if(n==0) return 0; else if((n%10)<3) return 1+ mic3(n/10); else return mic3(n/10); } int prod(int n) { if(n==0) return 1; else if((n%10)%2!=0) return n%10 * prod(n/10); else return prod(n/10); } int elimin(int n) { if(n==0) return 0; else if (n%10==5) return elimin(n/10); else return n%10 + 10 * elimin(n/10); } void main(void) { int n; clrscr(); printf("dati nr: "); scanf("%d",&n); printf("suma cifrelor lui %d divizibile cu 3 este: %d\n",n,suma(n)); printf("numarul cifrelor mai mici ca 3 din %d este: %d\n",n,mic3(n)); printf("produsul cifrelor imparele a lui %d este: %d\n",n,prod(n)); printf("dupa eliminarea cifrei 5 din %d este: %d",n,elimin(n)); } suma cif pare, div pari, poz care contin nr prime, cmmdc, el din sir fara cifre pare #include<stdio.h> #include<conio.h> #include<math.h> int suma_pcif(int x) { if(x<10) if(x%2==0) return x; else return 0; else if((x%10)%2==0)return (x%10) + suma_pcif(x/10); else return suma_pcif(x/10); } int prop(int x, int j) { if(j>=x) return 0;

else if(x%j==0) return 1 + prop(x,j+1); else return prop(x,j+1); } int prim(int x, int i) { if (i>sqrt(x)) return 1; else if(x%i==0) return 0; else return prim(x,i+1); } 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); } int nu(int x) { if(x==0) return 0; else if((x%10)%2!=0) return nu(x/10)*10+x%10; else return nu(x/10); } void main(void) { int a[50], i, n, m; clrscr(); printf("dati dimensiunea sirului: "); scanf("%d",&n); for(i=0;i<n;i++) { printf("a[%d]= ",i); scanf("%d",a+i); } printf("suma cifrelor pare pt fiecare elem: "); for(i=0;i<n;i++) printf("%d ",suma_pcif(a[i])); printf("\n"); printf("nrumarul de divizori pari a fiecarui elem: "); for(i=0;i<n; i++) printf("%d ",prop(a[i],2)); printf("\n"); printf("pozitiile din sir care detin elem prime: "); for(i=0;i<n;i++) if(prim(a[i],2)==1) printf("%d ",i); printf("\n"); printf("cmmdc-ul elem din sir: "); m=cmmdc(a[0],a[1]); for(i=2;i<n;i++) m=cmmdc(m,a[i]); printf("%d ",m); printf("\n"); printf("elem din sir fara cifrele pare: "); for(i=0;i<n;i++) printf("%d ",nu(a[i]));

Suma elemente deasupra diagonalei matrice #include <stdio.h>; #include <conio.h>; int a[10][10],i,j,m,n,s; void main() { clrscr(); printf("dati nr de linii "); scanf("%d",&n); for (i=1;i<=n;i++) for (j=1;j<=n;j++) { printf("dati a[%d][%d]=",i,j); scanf("%d",& a[i][j]); } s=0; for (i=1;i<=n-1;i++) for (j=i+1;j<=n;j++) { s=s+a[i][j]; } printf("\n suma elementelor de deasupra diag principale= %d",s); getch(); }

Suma patratelor cifrelor unui numar recursiv #include<stdio.h> #include<conio.h> int suma_patr(int n) { if(n==0) return 0; else return (n%10)*(n%10)+ suma_patr(n/10); } void main(void) { int n; clrscr(); printf("dati nr: "); scanf("%d",&n); printf("suma patratelor cifrelor lui %d este %d",n,suma_patr(n)); } Verificare graf conex si afisare componente #include<stdio.h> #include<conio.h> int n,m,a[20][20],viz[20],nrc=0;

void viziteaza(int nod) { int i; viz[nod]=nrc; for(i=1;i<=n;i++) if(a[nod][i]==1&&viz[i]==0) viziteaza(i); } void main() { int nod,x,y,i,j; printf("Introduceti numarul de noduri n= "); scanf("%d",&n); printf("Introduceti numarul de muchii m= "); scanf("%d",&m); for(i=1;i<=n;i++) for(j=1;j<=n;j++) for(i=1;i<=m;i++) { printf("De la nodul: "); scanf("%d",&x); printf("La nodul: "); scanf("%d",&y); a[x][y]=a[y][x]=1; } for(nod=1;nod<=n;nod++) if(viz[nod]==0) { nrc++; viziteaza(nod); } if(nrc==1) printf("Graful este conex!\n"); else printf("Graful nu este conex!\n"); printf("Componentele conexe sunt: \n"); for(i=1;i<=nrc;i++) { printf("Componenta %d: ",i); for(j=i;j<=n;j++) if(viz[j]==i) printf("%d",j); } getch(); }