Sda PDF

//Sa se evalueze din punct de vedere al timpului de executie algoritmii de sortare quicksort si
heapsort, folosind functiie din timer.h/timer.c si sa se compare performantele acestora pentru

acelasi set de date (ex. N1=10 000, N2= 20 000, ... N10=100 000). Sa se scrie timpii de
executie intr-un fisier txt in urmatorul format, pe cate o linie separata:
Algoritm, N1, timp_executie
....
/* fisierul timer.h */
void starton(void);
float startoff(void);
/* fisierul timer.c */
#include <time.h>
#include "timer.h"
clock_t aux;
void starton(void)
{ aux=clock();
}
float startoff(void)
{ return(clock()-(float)aux)/CLK_TCK;
}
// fisier main.c
#include "timer.h"
#include <stdio.h>
#include <stdlib.h>
int *a = NULL,n;
void deplasare(int s, int d) { //globale:tipElement a[],int n
int i = s, j = 2 * s, x = a[i - 1], ret = 0;
while (j <= d && !ret) {
if (j<d && a[j - 1]<a[j])j++;
(x<a[j - 1]) ? (a[i - 1] = a[j - 1], i = j, j = 2 * i) : (ret = 1);
}
a[i - 1] = x;
}
void heapsort() { //globale: tipElement a[],int N
//constructie ansamblu
int s = n / 2 + 1, d = n; //ATENTIE: N trebuie sa fie mai mare strict decat 0
while (s - 1)deplasare(--s, n);
//sortare ansamblu
while (d - 1) {
int x = a[0]; a[0] = a[d - 1]; a[d - 1] = x;
deplasare(1, --d);
}
}
void quicksort(int s, int d) { //tipElement a[],int n
int i = s, j = d, x = a[(s + d) / 2];
do {
while (a[i]<x)i++;
while (a[j]>x)j--;
if (i <= j) {
int temp = a[i];
a[i] = a[j];
a[j] = temp;
i++; j--;
}
} while (i <= j);
if (s<j)quicksort(s, j);
if (d>i)quicksort(i, d);
}
void generate_a()
{
a = realloc(a, n*sizeof(int));
if (!a)
{
printf("Alocare dinamica esuata\n");
exit(1);
}
int i;
for (i = 0; i < n; i++)
a[i] = n - i - 1;
}
void main(void)
{
FILE *f;
f = fopen("Fisier.txt", "w");
if (!f)
{
perror("Fisierul nu a putut fi accesat\n");
exit(1);
}
int i;
double time;
for (i = 1; i <=10 ; i++)
{
n = 10000*i;
generate_a();
starton();
heapsort();
time = startoff();
fprintf(f, "Heapsort,%d,%lf\n", n, time);
generate_a();
starton();
quicksort(0,n-1);
time = startoff();
fprintf(f, "Quicksort,%d,%lf\n", n, time);
}
free(a);
fclose(f);
}
//Se da un fisier continand date despre optiunile unor studenti cu privire la un set de materii
optionale. Fisierul este disponibil in sectiunea resurse laborator 2. Fisierul contine 10.000 de
linii, fiecarui elev revenindu-i 2 linii consecutive din fisier. Pe prima linie din cele doua se afla
numele studentului iar pe cea de a doua se afla o serie de 4 coduri reprezentand tot atatea
optiuni. Cunoscand ca sunt in total 5.000 de studenti si ca numele nici unui student nu ocupa
mai mult de 35 de caractere, se cere:
· Sa se citeasca datele din fisier intr-un tablou de 5.000 de elemente de forma < nume ,
optional1, optional2, opptional3, optional4 >
· Stiind ca studentii sunt ordonati alfabetic dupa nume, sa se aplice un algoritm de cautare
optim, din cele studiate in cadrul acestui laborator si sa se contorizeze numarul de comparatii
pentru gasirea studentului MATEI STEFAN.
· Sa se aplice algoritmul de cautare liniara pentru localizarea tuturor studentilor care au

ales un anumit optional, dat de la tastatura si sa se afiseze numele acestora.
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
typedef struct fac
char nume[35],optional[4][3];
}student;
int cautare_binara_performanta(student *list)
int m, s, d, count = 0;;
s = 0;
d = 5000;
while (s<d)
m = (s + d) / 2;
if (strcmp(list[m].nume, "MATEI STEFAN") < 0)
s = m + 1;
count++;
else
d = m;
count++;
if (d >= 5000)
return -1;
else
if (strcmp(list[d].nume, "MATEI STEFAN") == 0)

return count;
else
return -1;
void cautare_liniara(student *list, char op[3])
for (int i = 0; i < 4999; i++)
if ((strcmp(list[i].optional[0], op) == 0) || (strcmp(list[i].optional[1], op) == 0) ||

(strcmp(list[i].optional[2], op) == 0) || (strcmp(list[i].optional[3], op) == 0))
puts(list[i].nume);
int main()
student *list;
FILE *f;
char op[3];
fopen_s(&f, "FisierTestStudentiAlfabetic.txt","r");
if (!f)
perror("Fisierul nu a putut fi accesat");
exit(1);
list = (student*)malloc(5000 * sizeof(student));
if (!list)
{
printf("Alocare dinamica esuata");
exit(1);
int i;
for (i = 0; i < 4999; i++)
fgets(list[i].nume, 35, f);
list[i].nume[strlen(list[i].nume)-1] = '\0';
fscanf(f, "%s %s %s %s \n", list[i].optional[0], list[i].optional[1], list[i].optional[2],

list[i].optional[3]);
printf("Numarul de comparatii pana la gasirea persoanei cautate:%d\n",

cautare_binara_performanta(list));
scanf("%s", op);
cautare_liniara(list, op);
free(list);
fclose(f);
return 0;
//Se da un fisier continand date despre ocupatiile din Romania. Fisierul este disponibil in
sectiunea resurse laborator 2. Fiecarei ocupatii ii corespunde o linie din fisier: nr_crt
cod_ocupatie nume_ocupatie. Presupunand ca numele nici unei ocupatii nu ocupa mai mult de
255 de caractere, se cere:
· Sa se citeasca datele din fisier intr-un tablou de forma <ocupatie, cod >
· Stiind ca aceste ocupatii sunt ordonate alfabetic dupa nume, sa se aplice un algoritm de
cautare optim, din cele studiate in cadrul acestui laborator si sa se contorizeze numarul de
comparatii pentru determinarea codului ocupatiei "programator".
· Sa se aplice algoritmul de cautare liniara pentru localizarea ocupatiilor a caror cod este
cuprins intre 20000 si 30000.
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
typedef struct fac
char ocupatie[255];
long cod;
}meserie;
int cautare_binara_performanta(meserie *list,int n)
int m, s, d, count = 0;;
s = 0;
d = n-1;
while (s<d)
m = (s + d) / 2;
if (strcmp(list[m].ocupatie, "programator") < 0)
s = m + 1;
count++;
else
d = m;
count++;
if (d >= n)
return -1;
else
if (strcmp(list[d].ocupatie, "programator") == 0)
return count;
else
return -1;
void cautare_liniara(meserie *list,int n)
printf("Ocupatiile al caror cod se afla intre 20000 si 30000 sunt:");
for (int i = 0; i < n; i++)
if (list[i].cod >= 200000 && list[i].cod <= 300000)
printf("%d ", i);
puts("");
int main()
{
meserie *list=NULL;
FILE *f;
fopen_s(&f, "FisierCORalfabetic.txt","r");
if (!f)
exit(1);
int n;
while((fscanf_s(f,"%d",&n)!=EOF))
list = (meserie*)realloc(list, n*sizeof(meserie));
fscanf_s(f, "%li ", &list[n - 1].cod);
fgets(list[n - 1].ocupatie, 254, f);
list[n - 1].ocupatie[strlen(list[n - 1].ocupatie) - 1] = '\0';
printf("Numarul de comparatii necesare pentru gasirea meseriei de programator

este:%d\n", cautare_binara_performanta(list, n));
cautare_liniara(list, n);
free(list);
fclose(f);
return 0;
//Se da un fisier continand date despre optiunile unor studenti cu privire la un set de materii
optionale. Acest fisier poate fi gasit in sectiunea resurse laborator 3. Fisierul contine 10.000 de
linii, fiecarui elev revenindu-i 2 linii consecutive din fisier. Pe prima linie din cele doua se afla
numele studentuluiiar pe cea de a doua se afla o serie de 4 coduri reprezentand tot atatea
optiuni. Cunoscand ca sunt in total 5.000 de studenti si ca numele nici unui student nu ocupa
mai mult de 35 de caractere, se cere:
Sa se citeasca datele din fisier intr-un tablou de 5.000 de elemente de forma
< nume , optional1, optional2, opptional3, optional4 >
· Utilizand algoritmul de sortare prin amestecare (ShakerSort), sa se afiseze studentii

alfabetic si apoi invers, si sa se contorizeze comparatiile si atribuirile care se fac in timpul
sortarii
· Utilizand algoritmul de sortare prin insertie (InsertSort), sa se afiseze optionalele unui

student in ordinea alfabetica a acestora.
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
typedef struct lis
char nume[36], optionale[4][3];
}student;
void shakersort(student *a)
int j, ultim, sus, jos;
student temp;
int comp = 0,atrb = 0;
sus = 1; jos = 4999; ultim = 4999;
do {
for (j = jos; j >= sus; j--)
if (strcmp(a[j - 1].nume,a[j].nume)>0)
{
temp = a[j - 1]; a[j - 1] = a[j]; a[j] = temp;
ultim = j;
atrb = atrb + 3;
comp++;
} /*FOR*/
sus = ultim + 1;
for (j = sus; j <= jos; j++)
if (strcmp(a[j - 1].nume, a[j].nume)>0)
ultim = j;
comp++;
atrb = atrb + 3;
} /*FOR*/
jos = ultim - 1;
} while (!(sus>jos));
fprintf_s(stdout, "Se vor afisa studentii in ordine alfabetica\n");
for (j = 0; j <= 4999; j++)
fprintf_s(stdout, "%s\n", a[j].nume);
fprintf_s(stdout, "Se vor afisa studentii invers\n");
for (j = 4999; j >= 0; j--)
fprintf_s(stdout, "%s\n", a[j].nume);
fprintf_s(stdout, "Numarul de comparatii este:%d\nNumarul de atribuiri este:%d\n",

comp, atrb);
}
void insertie(student a)
int i, j;
for (i = 2; i >= 0; i--)
strncpy(a.optionale[4], a.optionale[i], 2);
j = i + 1;
while (strcmp(a.optionale[j], a.optionale[4]) < 0) {
strncpy(a.optionale[j - 1], a.optionale[j], 2); j++;
strncpy(a.optionale[j - 1], a.optionale[4], 2);
printf_s("Optionalele in ordine alfabetica sunt:\n");
for (i = 0; i < 3; i++)
printf_s("%s\n", a.optionale[i]);
int main()
student a[5000];
FILE *f;
int n = 0;
fopen_s(&f, "Studenti1.txt", "r");
if (!f)
exit(1);
}
while (fgets(a[n].nume, 35, f) != NULL)
a[n].nume[strlen(a[n].nume) - 1] = '\0';
fscanf_s(f, "%s %s %s %s\n",

a[n].optionale[0],(unsigned)_countof(a[n].optionale[0]),
a[n].optionale[3],(unsigned)_countof(a[n].optionale[3]));
n++;
shakersort(a);
printf_s("Introdu numarul studentului:\n");
scanf_s("%d", &n);
if (n<0 || n>4999)
printf_s("Ai introdus un numar invalid\n");
exit(1);
insertie(a[n]);
fclose(f);
return 0;
//Se da un fisier continand date despre rezultatele unor elevi la admiterea in liceu. Acest fisier
poate fi gasit in sectiunea resurse laborator 3. Fisierul contine 10.000 de linii, fiecarui elev
revenindu-i 2 linii consecutive din fisier. Pe prima linie din cele doua se afla numele elevului iar
pe cea de a doua se afla media de intrare sub forma unui numar real intre 1.0 si 10.0.
Cunoscand ca sunt in total 5.000 de elevi si ca numele nici unui elev nu ocupa mai mult de 35
de caractere, se cere:
● Sa se citeasca datele din fisier intr-un tablou de 5.000 de elemente de forma

< nume , medie >
● Utilizand algoritmul de sortare prin selectie (SelSort), sa se afiseze elevii crescator si
apoi descrescator, in ordinea mediilor si sa se contorizeze comparatiile si atribuirile
care se fac in timpul sortarii
● Utilizand algoritmul de sortare prin interschimbare (BubbleSort), sa se afiseze elevii
crescator si apoi descrescator, in ordinea numelor si sa se contorizeze comparatiile
si atribuirile care se fac in timpul sortarii
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
typedef struct lis
char nume[36];
double medie;
}student;
void sortare_prin_selectie(student *a)
int i, j, min; student temp;
int comp = 0, atrb = 0;
for (i = 0; i <= 4998; i++)
min = i; temp = a[i];
atrb=atrb+1;
for (j = i + 1; j < 5000; j++)

{
if (a[j].medie < temp.medie)
comp++;
min = j; temp = a[j];
atrb = atrb + 1;
a[min] = a[i]; a[i] = temp;
atrb = atrb + 2;
printf_s("Se vor afisa elevii in ordinea crescatoare a mediilor\n");
for (i = 0; i <= 4999; i++)
printf_s("%s\n", a[i].nume);
printf_s("Se vor afisa elevii in ordinea descrescatoare a mediilor\n");
for (i = 4999; i >= 0; i--)
printf_s("Numarul atribuirilor este:%d\nNumarul comparatiilor este:%d\n", atrb, comp);
void bubblesort(student *a)
int i, j; student temp;
int comp = 0, atrb = 0;
for (i = 0; i < 5000; i++)
for (j = 4999; j>i; j--)

{
if (strcmp(a[j - 1].nume, a[j].nume) > 0)
comp++;
atrb = atrb + 3;
printf_s("Se vor afisa studentii in ordinea alfabetica a numelui\n");
for (i = 0; i <= 4999; i++)
printf_s("Se vor afisa studentii in ordinea inversa a numelui\n");
for (i = 4999; i >= 0; i--)
printf_s("Numarul atribuirilor este:%d\nNumarul comparatiilor este:%d\n", atrb, comp);
int main()
student a[5000];
FILE *f;
int n = 0;
fopen_s(&f, "Studenti2.txt", "r");
if (!f)
exit(1);
}
while (fgets(a[n].nume, 35, f) != NULL)
a[n].nume[strlen(a[n].nume) - 1] = '\0';
fscanf_s(f, "%lf\n",&a[n].medie);
n++;
sortare_prin_selectie(a);
getchar();
bubblesort(a);
fclose(f);
return 0;
//Se dă un fișier, numit filme.txt, conținând date despre o colecție de filme. Acest fișier are
următoarea structură, pe prima linie se află următorul antet:
An Durata Titlu Categorie Premii
Începând cu a doua linie se află informațiile despre filme, fiecărui film revenindu-i câte o linie cu
următoarele informații, separate prin tab (‘\t’):
Anul apariției(de tip întreg) Durata(de tip întreg) Titlul(de tip sir de caractere,
poate conține și spatii) Categoria(șir de caractere) Premii(Da/Nu)
Se cere:
● Să se citească elementele într-un tablou de structuri de forma: <an, durata,
titlu, categorie, premii>
● Știind ca fișierul conține datele ordonate după durata filmului și că doar un singur film
are durata de 159 (minute), sa se determine titlul acestui film.

● Să se sorteze filmele alfabetic după nume și să se scrie datele după această
sortare într-un fișier nume_filme.txt
● Știind ca performanța algoritmului quicksort scade pentru tablouri care conțin
mai multe elemente cu aceeași valoare a cheii după care se face sortarea, să se
îmbunătățească algoritmul de sortare quicksort pentru a permite partiționarea în trei
intervale (unul pentru elemente cu valori ale cheii mai mici decât valoarea fanionului,
unul pentru elemente cu valori egale si unul pentru elemente cu valori mai mari) și să
se folosească noul algoritm pentru sortarea tabloului de structuri după categorie. Să
se scrie datele după această sortare într-un fișier categorii_filme.txt
● Să se ordoneze, printr-o singură parcurgere a tabloului, filmele în următorul
mod: pe primele poziții se vor afla filmele premiate (cele care au valoarea Da la
câmpul premii), iar pe ultimele poziții filmele nepremiate.
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
typedef struct lit
int an, durata;
char titlu[90],categoria[90],premii[90];
}film;
void cautare_binara(film *a, int n)

{
int s = 0, d = n - 1, gasit = 0, m;
while ((s <= d) && (!gasit))
m = (s + d) / 2;
if (a[m].durata == 159)
gasit = 1;
else
if (a[m].durata < 159)
s = m + 1;
else
d = m - 1;
if (gasit)
printf_s("Titlu filmului cu durata respectiva este:%s\n", a[m].titlu);
else
{
printf_s("Nu exista filmul cu durata respectiva\n");
void la_centrus(film *a,int s, int d, film x)
int i = s;
while (strcmp(a[i].categoria,x.categoria) != 0 && i != (s + d) / 2)
i++;
int p = (s + d) / 2;
while (strcmp(a[p].categoria,x.categoria) == 0 && p > i)
p--;
if (p != i)
film temp;
temp = a[i];
a[i] = a[p];
a[p] = temp;
void la_centrud(film *a,int s, int d, film x)
int j = d;
while (strcmp(a[j].categoria,x.categoria)!= 0 && j != (s + d) / 2)
j--;
int p = (s + d) / 2;
while (strcmp(a[p].categoria,x.categoria) == 0 && p < j)
p++;
if (p != j)
film temp;
temp = a[j];
a[j] = a[p];
a[p] = temp;
void quicksort(film *a,int s, int d) {
int i = s, j = d;
film x = a[(s + d) / 2];
do {
while (strcmp(a[i].titlu,x.titlu)<0) i++;
while (strcmp(a[j].titlu,x.titlu)>0) j--;
if (i <= j) {
film temp = a[i];
a[i] = a[j];
a[j] = temp;
i++; j--;
} while (i <= j);

if (s<j) quicksort(a,s, j);
if (d>i) quicksort(a,i, d);
void quicksort_modificat(film *a,int s, int d) {
int i = s, j = d;
film x = a[(s + d) / 2];
la_centrus(a, s, d, x);
la_centrud(a, s, d, x);
do {
while (strcmp(a[i].categoria,x.categoria)<0) i++;
while (strcmp(a[j].categoria,x.categoria)>0) j--;
if (strcmp(a[i].categoria, a[j].categoria) == 0)
i++;
j--;
else
if (i <= j) {
film temp = a[i];

a[i] = a[j];
a[j] = temp;
i++; j--;
} while (i <= j);
if (s<j) quicksort_modificat(a,s, j);
if (d>i) quicksort_modificat(a,i, d);
void sortare_singura_parcurgere(film *a, int n)
int j = 0;
while (strcmp(a[j].premii, "Da") == 0)
j++;
for (int i = j+1; i < n; i++)
if (strcmp(a[i].premii, "Da") == 0)
film temp = a[i];

a[i] = a[j];
a[j] = temp;
j++;
int main()
FILE *f;
film *a = NULL;
int n = 0;
char linie[40];
fopen_s(&f, "filme.txt", "r");
if (!f)
exit(1);
fgets(linie, 40, f);

a = (film*)realloc(a,(n+1)*sizeof(film));
if (!a)
exit(1);
while (fscanf_s(f, "%d\t", &a[n].an)!=EOF)
fscanf_s(f, "%d\t", &a[n].durata);
fscanf_s(f, "%[^\t]\t", a[n].titlu, (unsigned)_countof(a[n].titlu));
fscanf_s(f, "%[^\t]\t", a[n].categoria,(unsigned)_countof(a[n].categoria));
fscanf_s(f, "%s\n", a[n].premii, (unsigned)_countof(a[n].premii));
n++;
a = (film*)realloc(a,(n + 1)*sizeof(film));
if (!a)
exit(1);
}
}
fclose(f);
cautare_binara(a, n);
quicksort(a, 0, n - 1);
fopen_s(&f, "nume_filme.txt", "w");
if (!f)
exit(1);
printf_s("Verifica fisierul nume_filme.txt\n");
for (int i = 0; i < n; i++)
fprintf_s(f, "%d %d %s\t%s\t%s\n", a[i].an, a[i].durata, a[i].titlu,
a[i].categoria, a[i].premii);
fclose(f);
fopen_s(&f, "categorii_filme.txt", "w");
if (!f)
{
exit(1);
quicksort_modificat(a, 0, n - 1);
printf_s("Verifica fisierul categorii_filme.txt\n");
for (int i = 0; i < n; i++)
fclose(f);
fopen_s(&f, "premii_filme.txt", "w");
if (!f)
exit(1);
printf_s("Verifica fisierul premii_filme.txt\n");
sortare_singura_parcurgere(a, n);
for (int i = 0; i < n; i++)

fclose(f);
return 0;
//Sa se evalueze din punct de vedere al timpului de executie o implementare recursiva si
una nerecursiva a calcului termenului n al seriei Fibonacci, folosind functiie din
timer.h/timer.c si sa se compare performantele acestor implementari pentru acelasi set
de date (ex. N1=5, N2= 10, ... N10=100). Sa se scrie timpii de executie intr-un fisier txt in
urmatorul format, pe cate o linie separata:
....
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include "timer.h"
long int fibor(int n)
{
if (n == 1)
return 0;
if (n == 2)
return 1;
return fibor(n - 1) + fibor(n - 2);
long int fibonr(int n)
int i;
long int *tab;
tab = (long*)malloc(n*sizeof(long));
if (!tab)
printf_s("Alocare dinamica esuata\n");
exit(1);
tab[0] = 0;
tab[1] = 1;
for (i = 2; i <= n - 1; i++)

tab[i] = tab[i - 1] + tab[i - 2];
return tab[n - 1];
int main()
int n = 5;
FILE *f;
fopen_s(&f, "out.txt", "w");
printf_s("%d %d", fibor(3), fibonr(3));
for (int i = 1; i <= 20; i++)
starton();
fibor(n*i);
float t;
t = startoff();
fprintf_s(f, "Fibonacci recursiv,%d,%f\n", n*i, t);
starton();
fibonr(n*i);
t = startoff();
fprintf_s(f, "Fibonacci nerecursiv,%d,%f\n", n*i, t);
fclose(f);
return 0;
//Se da un fisier continand date despre mineralele cunoscute. Fisierul este disponibil in
sectiunea resurse laborator 2. Fiecarui mineral ii corespunde o linie din fisier: nume_mineral
decriere. Presupunand ca numele niciunui mineral nu ocupa mai mult de 50 de caractere, si
nicio descriere nu ocupa mai mult de 255 de caractere, se cere:
· Sa se citeasca datele din fisier intr-un tablou de forma <nume, descriere>
· Stiind ca aceste minerale sunt ordonate alfabetic dupa nume, sa se aplice un algoritm de
cautare optim, din cele studiate in cadrul acestui laborator si sa se contorizeze numarul de
comparatii pentru determinarea localizarea mineralului "ONYX" si afisarea descrierii acestuia.
· Sa se aplice algoritmul de cautare liniara pentru localizarea mineralelor a caror denumire
incepe cu litera K.
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
typedef struct lit

{
char nume[51],descriere[256];
}mineral;
void cautare_binara(mineral *a, int n)
int s = 0, d = n - 1, gasit = 0,m;
int contor=0;
m = (s + d) / 2;
if (strcmp(a[m].nume,"ONYX")==0)
gasit = 1;
if (contor == 0)
contor = 1;
else
if (strcmp(a[m].nume, "ONYX") < 0)

{
s = m + 1;
contor++;
else
d = m - 1;
contor++;
if (contor == 0)
printf_s("Nu exista mineralul cautat\n");
else
printf_s("Au fost necesare %d comparatii :%s\n", contor, a[m].descriere);
void cautare_liniara(mineral *a, int n)
for (int i = 0; i < n;i++)

if (a[i].nume[0] == 'K')
int main()
FILE *f;
mineral *t;
int n = 0;
fopen_s(&f, "C:\\Users\\Alex N\\Downloads\\Anul II\\MineralsAlphabeticalList.txt", "r");
if (!f)
perror("Eroare la operatiile de intrare-iesire\n");
exit(1);
t = (mineral*)malloc((n + 1)*sizeof(mineral));
if (!t)
exit(1);
}
while (fscanf_s(f, "%s (", t[n].nume, (unsigned)_countof(t[n].nume)) != EOF)
fscanf_s(f, "%[^)\n])\n", t[n].descriere, (unsigned)_countof(t[n].descriere));
n++;
t = (mineral*)realloc(t, (n + 1)*sizeof(mineral));
if (!t)
exit(1);
cautare_binara(t, n);
cautare_liniara(t, n);
fclose(f);
return 0;
//Se da un fisier continand date despre rezultatele unor elevi la admiterea in liceu. Acest fisier
poate fi descarcat din sectiunea resurse laborator 2. Fisierul contine 10.000 de linii, fiecarui elev
revenindu-i 2 linii consecutive din fisier. Peprima linie din cele doua se afla numele elevului iar
pe cea de a doua se afla media de intrare sub forma unui numar real intre 1.0 si 10.0.
Cunoscand ca sunt in total 5.000 de elevi si ca numele nici unui elev nu ocupa mai mult de 35
de caractere, se cere:
● Sa se citeasca datele din fisier intr-un tablou de 5.000 de elemente de forma <
nume , medie >
● Stiind ca elevii sunt ordonati descrescator dupa medie, sa se aplice algoritmul de
cautare binara pentru a localiza elevul care a obtinut media 9.7 si sa se contorizeze
comparatiile care se fac pentru localizare
● Sa se aplice algoritmul de cautare prin interpolare pentru a localiza elevul care a
obtinut media 9.7 si sa se contorizeze comparatiile care se fac pentru localizare
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<math.h>
typedef struct lit
char nume[36];
float medie;
}elev;
void cautare_binara(elev *a)
int s = 0, d = 4999, gasit = 0;
int m, contor = 0;
float x = 9.700000;
m = (s + d) / 2;
if (a[m].medie==x )
gasit = 1;
contor++;
else
if (a[m].medie>x)
s = m + 1;
contor++;
}
else
d = m - 1;
contor++;
if (gasit) {
printf_s("%s:%d\n", a[m].nume, contor);
else {
printf_s("Nu exista elevul cautat\n");
void cautare_prin_interpolare(elev *a)
int m, s, d;
s = 0;
d = 4999;
int contor = 0;
float x = 9.700000;
do{
m = (int)(s + ((x - a[s].medie)*(d - s)) / (a[d].medie - a[s].medie));
if (x>a[m].medie) s = m + 1;
else d = m - 1;
contor++;
} while ((s<d) && (a[m].medie != x) && (a[d].medie != a[s].medie) && (x >= a[s].medie)
&& (x <= a[d].medie));
if ((a[m].medie == x) && (m<5000)) {
printf_s("%s:%d\n", a[m].nume, contor);
else { printf_s("Nu exista elevul cautat\n"); }
int main()
FILE *f;
elev t[5000];
int n = 0;
fopen_s(&f, "FisierTestStudentiMedie.txt", "r");
if (!f)
perror("Eroare la operatiile de intrare-iesire\n");
exit(1);
while (fgets(t[n].nume, 35, f) != NULL)
t[n].nume[strlen(t[n].nume) - 1] = '\0';
fscanf_s(f,"%f\n", &t[n].medie);
n++;
printf_s("Cautare binara\n");
cautare_binara(t);
printf_s("Cautare prin interpolare\n");
cautare_prin_interpolare(t);
fclose(f);
return 0;
}
// Se da un fisier binar continand 100.000 numere intregi. Acest fisier poate fi descarcat aici. Sunt
prezente toate numerele intregi intre 0 si 99.999, intr-o ordine aleatoare. Se cere:
● Sa se afiseze intr-un fisier text continutul fisierului binar de intrare. Fiecare din cei 100.000 de
intregi va ocupa propria sa linie
● Sa se foloseasca algoritmul de sortare prin interclasare naturala pentru a sorta descrescator
fisierul de intrare
● Sa se contorizeze cate operatii de citire din fisier si scriere in fisier executa algoritmul, precum
si numarul de comparatii executate
● Sa se afiseze intr-un alt fisier text continutul fisierului sortat, intr-un format similar celui de
mai sus
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<ctype.h>
long int c = 0, s = 0, comp = 0;
void copy(FILE* source, FILE* destination, long *last_item, int* eof_source, int* flag)
long int x; // aici trebuie folosit un element de tipul elementelor din fisier
fwrite(last_item, sizeof(long), 1, destination);
s++;
if (feof(source))
{
*flag = 1;
*eof_source = 1;
comp++;
else
comp++;
x = *last_item;
if (fread(last_item, sizeof(long), 1, source) < 1)
*flag = 1;
*eof_source = 1;
comp++;
c++;
return;
*flag = x < (*last_item);
comp++;
}
}
void copy_monotony(FILE* source, FILE* destination, long *last_item, int* eof_source)
int flag;
do
comp++;
copy(source, destination, last_item, eof_source, &flag);
} while (!flag);
void distribute(char* file_name, char* auxiliary1, char* auxiliary2)
FILE* source;
FILE* destination1;
FILE* destination2;
int eof_source;
long x; // aici trebuie folosit un element de tipul elementelor din fisier
source = fopen(file_name, "rb");
if (!source)
{
comp++;
printf("ERROR! File not available\n");
return;
destination1 = fopen(auxiliary1, "wb");
eof_source = feof(source);
if (!eof_source)
comp++;
if (fread(&x, sizeof(long), 1, source) < 1)
comp++;
c++;
return;
do
{
comp++;
copy_monotony(source, destination1, &x, &eof_source);
if (!eof_source)
comp++;
copy_monotony(source, destination2, &x, &eof_source);
} while (!eof_source);
fclose(source);
fclose(destination1);
void merge_monotony(FILE* source1, FILE* source2, FILE* destination, long *x, long *y, int*
eof1, int* eof2)
int flag;
do
{
comp++;
if (*x > *y)
comp++;
copy(source1, destination, x, eof1, &flag);
if (flag)
comp++;
copy_monotony(source2, destination, y, eof2);
else
comp++;
copy(source2, destination, y, eof2, &flag);
if (flag)
comp++;
copy_monotony(source1, destination, x, eof1);

}
} while (!flag);
void merge(char* file_name, char* auxiliary1, char* auxiliary2, int* repeat)
long x; // aici trebuie folosit un element de tipul elementelor din fisier
long y; // aici trebuie folosit un element de tipul elementelor din fisier
int eof1, eof2;
FILE* source1;
FILE* source2;
FILE* destination;
source1 = fopen(auxiliary1, "rb");
if (!source1)
comp++;
return;
}
if (!source2)
comp++;
return;
destination = fopen(file_name, "wb");
eof1 = feof(source1);
if (!eof1)
comp++;
if (fread(&x, sizeof(long), 1, source1) < 1)
c++;
comp++;
eof1 = 1;
}
}
if (!eof2)
comp++;
if (fread(&y, sizeof(long), 1, source2) < 1)
comp++;
c++;
eof2 = 1;
while (!eof2)
comp++;
merge_monotony(source1, source2, destination, &x, &y, &eof1, &eof2);
*repeat = *repeat + 1;
if (!eof1)
{
comp++;
copy_monotony(source1, destination, &x, &eof1);
*repeat = *repeat + 1;
fclose(source1);
fclose(source2);
fclose(destination);
void natural_sequence_merging(char* file_name, char* auxiliary1, char* auxiliary2)
int repeat;
do
comp++;
distribute(file_name, auxiliary1, auxiliary2);
repeat = 0;
merge(file_name, auxiliary1, auxiliary2, &repeat);
} while (repeat != 1);

printf_s("Numarul de citiri:%d.Numarul de scrieri:%d.Numarul de comparatii:%d\n", c, s,
comp);
void afisare_in_fisier(FILE *f, FILE *g)
long int nr;
while (fread_s(&nr, sizeof(long), sizeof(long), 1, f) == 1)
fprintf_s(g, "%li\n", nr);
//getchar();
int main()
FILE *f,*g;
fopen_s(&f, "data.bin", "rb");
if (!f)
{
exit(1);
fopen_s(&g, "out.txt", "w");
if (!g)
exit(1);
afisare_in_fisier(f, g);
fclose(g);
fclose(f);
natural_sequence_merging("data.bin", "data1.bin", "data2.bin");
fopen_s(&f, "data.bin", "rb");
if (!f)
exit(1);
}
fopen_s(&g, "out2.txt", "w");
if (!g)
exit(1);
fclose(f);
fclose(g);
return 0;
//. Se da un fisier binar continand 100.000 numere intregi. Acest fisier poate fi descarcat aici. Sunt
prezente toate numerele intregi intre 0 si 99.999, intr-o ordine aleatoare. Se cere:
● Sa se afiseze intr-un fisier text continutul fisierului binar de intrare. Fiecare din cei 100.000 de
intregi va fi delimitat de vecinii sai printr-un caracter '|'
● Sa se foloseasca algoritmul de sortare prin interclasare cu 3 benzi pentru a sorta descrescator
fisierul de intrare
● Sa se contorizeze cate operatii de citire din fisier si scriere in fisier executa algoritmul, precum
si numarul de comparatii executate
● Sa se afiseze intr-un alt fisier text continutul fisierului sortat, intr-un format similar celui de
mai sus
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<ctype.h>
long int c = 0, s = 0, comp = 0;
void move(FILE* source, FILE* destination, int size)
int i;
int x; // aici trebuie folosit un element de tipul elementelor din fisier
i = 0;
while (i < size && !feof(source))
comp++;
if (fread(&x, sizeof(int), 1, source) < 1)
//c++;
comp++;
break;
c++;
fwrite(&x, sizeof(int), 1, destination);
s++;
i++;
void distribute(char* file_name, char* auxiliary1, char* auxiliary2, int size)
FILE* source;
FILE* destination1;
FILE* destination2;
source = fopen(file_name, "rb");
if (!source)
comp++;
return;
}
while (!feof(source))
comp++;
move(source, destination1, size);
move(source, destination2, size);
fclose(source);
void merge(char* file_name, char* auxiliary1, char* auxiliary2, int size, int* repeat)
int i, j;
int x; // aici trebuie folosit un element de tipul elementelor din fisier
int y; // aici trebuie folosit un element de tipul elementelor din fisier
int eof1, eof2;
FILE* source1;
FILE* source2;
FILE* destination;
if (!source1)
comp++;
return;
if (!source2)
{
comp++;
return;
destination = fopen(file_name, "wb");
if (!eof1)
comp++;
if (fread(&x, sizeof(int), 1, source1) < 1)
comp++;
//c++;
eof1 = 1;
c++;
if (!eof2)
comp++;
if (fread(&y, sizeof(int), 1, source2) < 1)
comp++;
eof2 = 1;
c++;
do
comp++;
i = 0;
j = 0;
while (i < size && j < size && !eof1 && !eof2)
comp++;
if (x > y)
comp++;
s++;
i++;
if (feof(source1))
comp++;
eof1 = 1;
else if (fread(&x, sizeof(int), 1, source1) < 1)
comp++;
eof1 = 1;
c++;
else
comp++;
fwrite(&y, sizeof(int), 1, destination);
s++;
j++;
if (feof(source2))
comp++;
eof2 = 1;
else if (fread(&y, sizeof(int), 1, source2) < 1)
comp++;
eof2 = 1;
c++;
while (i < size && !eof1)
comp++;
s++;
i++;
if (feof(source1))
comp++;
eof1 = 1;
else if (fread(&x, sizeof(int), 1, source1) < 1)
comp++;
eof1 = 1;
c++;
while (j < size && !eof2)
comp++;
fwrite(&y, sizeof(int), 1, destination);

s++;
j++;
if (feof(source2))
comp++;
eof2 = 1;
else if (fread(&y, sizeof(int), 1, source2) < 1)
comp++;
eof2 = 1;
c++;
if (!eof1 || !eof2)
comp++;
*repeat = 1;
} while (!eof1 || !eof2);
fclose(source1);
fclose(source2);
fclose(destination);
void three_way_sequence_merging(char* file_name, char* auxiliary1, char* auxiliary2)
int size;
int repeat;
size = 1;
do
comp++;
distribute(file_name, auxiliary1, auxiliary2, size);
repeat = 0;
merge(file_name, auxiliary1, auxiliary2, size, &repeat);
size = size * 2;
} while (repeat != 0);
printf_s("Numarul de citiri:%d.Numarul de scrieri:%d.Numarul de comparatii:%d\n", c, s,

comp);
void afisare_in_fisier(FILE *f, FILE *g)
long int nr;
while (fread_s(&nr, sizeof(long), sizeof(long), 1, f) == 1)
fprintf_s(g, "%li|", nr);
//getchar();
int main()
FILE *f, *g;
fopen_s(&f, "data2.bin", "rb");
if (!f)
exit(1);
fopen_s(&g, "out.txt", "w");
if (!g)
exit(1);
}
fclose(f);
fclose(g);
if (!f)
exit(1);
fclose(f);
three_way_sequence_merging("data2.bin", "data3.bin", "data4.bin");
if (!f)
exit(1);
fopen_s(&g, "out2.txt", "w");
if (!g)
exit(1);
fclose(f);
fclose(g);
return 0;
//
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
typedef struct pacient
char nume[35];
int cod;
}pacient;
int cautare_binara(pacient *a,int n,char nume[35])
{ int s = 0, d = n - 1, gasit = 0;
int m;
m = (s + d) / 2;
if (strcmp(a[m].nume,nume)==0)
gasit = 1;
else
if (strcmp(a[m].nume,nume)<0)
s = m + 1;
else
d = m - 1;
if (gasit) {
return a[m].cod;
else {
return -1;
void cod_mai_mic(pacient *a, int n, int cod)
for (int i = 0; i < n;i++)
if (a[i].cod < cod)
printf_s("Nume:%s.Cod:%d\n", a[i].nume, a[i].cod);
int main()
int n;
pacient *t;
scanf_s("%d\n", &n);
t = (pacient*)malloc(n*sizeof(pacient));
if (!t)
exit(1);
for (int i = 0; i < n; i++)
scanf_s("%s\n", t[i].nume, (unsigned)_countof(t[i].nume));

t[i].cod = i;
char nume[35];
scanf_s("%s",nume, (unsigned)_countof(nume));
int x = cautare_binara(t, n, nume);
if (x == -1)
printf_s("Nu exista pacientul cautat\n");
else
printf_s("Codul pacientului este:%d\n", x);
cod_mai_mic(t, n, x);
return 0;
//
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
typedef struct elev
{
char nume[35];
char gen;
float marime_pantof;
}elev;
void sortare(elev *a, int n)
for (int i = 0; i < n - 1;i++)
for (int j = i; j < n; j++)
if (a[i].marime_pantof == a[j].marime_pantof)
if (strcmp(a[i].nume, a[j].nume)<0)
elev temp=a[i];
a[i]=a[j];
a[j] = temp;
else
elev temp = a[j];
a[j]=a[i];
a[i] = temp;
else
if (a[i].marime_pantof > a[j].marime_pantof)
elev temp = a[i];
a[i] = a[j];
a[j] = temp;
}
int main()
elev *a;
int n;
scanf_s("%d", &n);
a = (elev*)malloc(n*sizeof(elev));
if (!a)
exit(1);
for (int i = 0; i < n; i++)
fgets(a[i].nume, 34, stdin);
a[i].nume[strlen(a[i].nume) - 1] = '\0';
scanf_s("%c", &a[i].gen);
scanf_s("%f", &a[i].marime_pantof);
sortare(a, n);
for (int i = 0; i < n; i++)
printf_s("Nume:%s.Gen:%c.Marime pantof:%f.\n", a[i].nume, a[i].gen,

a[i].marime_pantof);
return 0;
//
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
typedef struct tara
char nume[35];
float suprafata;
int soldati;
}tara;
void sortare(tara *a, int n)
for (int i = 1; i < n-1; i = i + 2)
for (int j = i + 2; j < n;j=j+2)
if (a[i].suprafata < a[j].suprafata)
tara temp = a[i];
a[i] = a[j];
a[j] = temp;
}
int main()
FILE* f;
fopen_s(&f, "in.txt", "r");
if (!f)
exit(1);
int n;
fscanf_s(f, "%d\n", &n);
tara *a;
a = (tara*)malloc(n*sizeof(tara));
if (!a)
exit(1);
for (int i = 0; i < n; i++)
fgets(a[i].nume, 34, f);
fscanf_s(f, "%f", &a[i].suprafata);
fscanf_s(f, "%d\n", &a[i].soldati);
sortare(a, n);
for (int i = 0; i < n; i++)
printf_s("Nume:%s.Suprafata:%f.Soldati:%d\n", a[i].nume, a[i].suprafata,

a[i].soldati);
return 0;
//
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
typedef struct produs
char nume[35];
int cod;
}produs;
int cauta(produs *a, int n,char nume[35])
for (int i = 0; i < n;i++)
if (strcmp(a[i].nume, nume) == 0)
return a[i].cod;
return -1;
}
void afisare(produs *a, int n, unsigned cod)
for (int i = 0; i < n; i++)
if (strlen(a[i].nume) >= cod)
printf_s("Nume:%s.Cod:%d\n", a[i].nume, a[i].cod);
int main()
int n;
produs *a;
scanf_s("%d", &n);
a = (produs*)malloc(n*sizeof(produs));
if (!a)
exit(1);
for (int i = 0; i < n; i++)
a[i].cod = i;
char nume[35];
fgets(nume, 34, stdin);
nume[strlen(nume) - 1] = '\0';
int x = cauta(a, n, nume);
if (x == -1)
printf_s("Nu exista produsul cautat\n");
else
{
printf("Codul produsului este:%d\n", x);
afisare(a, n, x);
return 0;
//
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
typedef int boolean;
typedef struct eroare
char limbaj[35];
int cod_eroare;
boolean rezolvare;
}eroare;
void sortare(eroare *a, int n)
for (int i = 0; i < n-1; i++)
for (int j = i; j < n; j++)
if (strcmp(a[i].limbaj, a[j].limbaj) == 0)
if (a[i].cod_eroare>a[j].cod_eroare)
eroare temp=a[i];
a[i] = a[j];
a[j] = temp;
else
if (strcmp(a[i].limbaj, a[j].limbaj) > 0)
eroare temp = a[i];
a[i] = a[j];
a[j] = temp;
int main()
FILE *f;
eroare *a;
int n;
fopen_s(&f, "in.txt", "r");

if (!f)
exit(1);
fscanf_s(f,"%d\n", &n);
a = (eroare*)malloc(n*sizeof(eroare));
if (!a)
exit(1);
for (int i = 0; i < n; i++)
fgets(a[i].limbaj, 34, f);
a[i].limbaj[strlen(a[i].limbaj)-1] = '\0';
fscanf_s(f,"%d %d\n", &a[i].cod_eroare, &a[i].rezolvare);
sortare(a, n);
for (int i = 0; i < n; i++)
printf_s("Nume:%s.Cod eroare:%d.Rezolvare:%d\n", a[i].limbaj, a[i].cod_eroare,

a[i].rezolvare);
fclose(f);
return 0;
//
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
typedef struct produs
char nume[35];
int cod;
}produs;
void sortare(produs *a, int n)
int i, j;
for (i = 0; i < n - 1; i++)
for (j = i+1; j < n; j++)
if ((a[i].cod % 2 == 0) && (a[j].cod % 2 == 0) && (a[i].cod>a[j].cod))

{
produs temp = a[i];
a[i] = a[j];
a[j] = temp;
int main()
int n;
scanf_s("%d\n", &n);
produs *a;
a = (produs*)malloc(n*sizeof(produs));
if (!a)
exit(1);
for (int i = 0; i < n; i++)
a[i].cod = n - i;
sortare(a, n);
for (int i = 0; i < n; i++)
printf_s("Nume:%s.Cod:%d.\n", a[i].nume, a[i].cod);
return 0;
//
1. Un program bibliotecar tine evidenta cartilor imprumutate de diferiti cititori. Informatiile pentru
fiecare imprumut includ (primele patru campuri sunt alfanumerice): titlu carte, autor carte, nume
cititor, adresa cititor, termen (numar de zile pana la returnare). Sa se implementeze operatorii:
• vidare() - se initializeaza evidenta, nici o carte imprumutata;
• imprumut_nou(titlu_carte, autor_carte, nume_cititor, adresa_cititor, termen_returnare) -

adauga un imprumut nou, daca cititorul cu numele dat nu mai are carti imprumutate; daca are,
atunci imprumutul nu va fi efectuat;
• actualizare() - pentru fiecare carte imprumutata, se decrementeaza termenul de returnare cu o

unitate; dupa decrementare se afiseaza cititorii care nu au returnat cartile la timp in ordine
descrescatoare a intarzierilor;
• returnare(nume_cititor) - cartea detinuta de cititorul cu numele precizat este returnata, ea

trebuind stearsa din evidenta;
• afisare() - se afiseaza evidenta.

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
typedef enum{false,true} boolean;
typedef struct list{
char titlu[50], autor[50], cititor[50], adresa[50];
int termen;
struct list *urm;
}nod;
nod *root,*last;
void vidare()
root = NULL;
last = NULL;
nod *creeare(char titlu[100], char autor[100], char cititor[100], char adresa[100], int termen)
{
nod *p;
p =(nod*)malloc(sizeof(nod));
if (!p)
exit(1);
strcpy(p->titlu,titlu);
strcpy(p->autor, autor);
strcpy(p->cititor,cititor);
strcpy(p->adresa,adresa );
p->termen = termen;
p->urm = NULL;
return p;
void adauga(nod *p)
if (root->termen > p->termen)
p->urm = root;
root = p;
else
nod *q;
q = root;
while (q->urm != NULL && q->urm->termen<p->termen)
q = q->urm;
if (q->urm != NULL)
p->urm = q->urm;
q->urm = p;
else
last->urm = p;
last = p;
boolean imprumut_nou(char *titlu, char *autor, char *cititor, char *adresa, int termen)
nod *p;
if (root == NULL)
p = creeare(titlu, autor, cititor, adresa, termen);
root = p;
last = p;
return true;
else
p = root;
while (p != NULL)
if (strcmp(p->cititor, cititor) == 0)
return false;
p = p->urm;
p = creeare(titlu, autor, cititor, adresa, termen);
adauga(p);
return true;
void actualizare()
nod *p;
p = root;
while (p != NULL)
p->termen--;
p = p->urm;
p = root;
while (p != NULL)
if (p->termen < 0)
printf("%s %d|", p->cititor, p->termen);
else
break;
p = p->urm;
printf("\n");
void returnare(char *cititor)
nod *p;
p = root;
if (strcmp(root->cititor, cititor) == 0)
root = root->urm;
printf("Numele cartii este:%s\n", p->titlu);
free(p);
return;
else
nod *q;
while (p->urm != NULL && strcmp(p->cititor, cititor) != 0)
q=p;
p = p->urm;
if (p->urm != NULL)
printf("Numele cartii este:%s\n", p->titlu);
q->urm=p->urm;
free(p);
return;
else
if(strcmp(p->cititor,cititor)==0)
last=q;
last->urm=NULL;
free(p);
return;
void afisare()
{
nod *p;
for (p = root; p != NULL; p = p->urm)
printf("%s %s %s %s %d\n", p->titlu, p->autor, p->cititor, p->adresa, p->termen);
int main()
vidare();
imprumut_nou("Procesul", "Franz Kafka", "Stefan Mihai", "2413", 20);
imprumut_nou("Castelul", "Franz Kafka", "Stefan Mihai", "2413", 10);
imprumut_nou("Amerika", "Franz Kafka", "Matei Mihai", "213", 1);
imprumut_nou("Vremea dispretului", "Andrzej Sapkowski", "Petru Rares", "1413", 2);
imprumut_nou("Zece negri mititei", "Agatha Christie", "Stelian Cristian", "2513", 3);
afisare();
printf("-.-\n");
actualizare();
printf("-.-\n");
actualizare();
printf("-.-\n");
actualizare();
printf("-.-\n");
actualizare();
printf("-.-\n");
actualizare();
returnare("Stefan Mihai");
afisare();
return 0;
//Se considera o cutie postala care poate contine mesaje. Fiecare mesaj este caracterizat prin
prioritate (urgent sau ordinar), destinatar (sir de caractere) si continut (sir de caractere). Un mesaj
prioritar va fi plasat intotdeauna pe prima pozitie în cutia postala, unul ordinar va fi plasat astfel incat
mesajele ordinare din cutie sa fie in permanenta ordonate alfabetic dupa destinatarul lor. Astfel, pe
primele pozitii vor fi mesaje urgente neordonate dupa destinatar, iar cand se termina mesajele
urgente in lista vor urma mesaje ordinare ordonate alfabetic dupa destinatar (se va folosi o singura
lista pentru toate mesajele). Sa se implementeze urmatorii operatori:
• initializare() - initializeaza cutia postala, nici un mesaj;
• trimitere_mesaj(prioritate, destinatar, continut) - in cutia postala se adauga un mesaj nou avand

campurile date;
• primire_mesaj(destinatar) - persoana cu numele precizat isi ridica din cutia postala mesajul cel mai
prioritar care-i este adresat; se va afisa continutul mesajului si prioritatea sa;
• afisare() – se listeaza mesajele de prioritate mica (mesajele ordinare) in ordine alfabetica inversa,
dupa destinatarul lor.
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
typedef enum{urgent,ordinar} tip;
typedef struct list{
tip prioritate;
char destinatar[50];
char continut[100];
struct list *urm;
struct list *ant;
}nod;
nod *root,*last;
void initializare()
root=NULL;
last=NULL;
nod *creeare(tip prioritate,char destinatar[50],char continut[100])
{
nod *p;
p=(nod*)malloc(sizeof(nod));
if(!p)
exit(1);
p->prioritate=prioritate;
strcpy(p->destinatar,destinatar);
strcpy(p->continut,continut);
p->urm=NULL;
p->ant=NULL;
return p;
void trimitere_mesaj(tip prioritate,char destinatar[50],char continut[100])
nod *p;
p=creeare(prioritate,destinatar,continut);
if(root==NULL)
root=p;
last=p;
return;
if(prioritate==urgent)
p->urm=root;
root->ant=p;
root=p;
else
{
nod *q,*r;
r=root;
for(q=root->urm;q!=NULL;q=q->urm)
if(q->prioritate==ordinar && strcmp(q->destinatar,destinatar)>0)
r->urm=p;
p->ant=r;
p->urm=q;
q->ant=p;
return;
r=q;
last->urm=p;
p->ant=last;
last=p;
void primire_mesaj(char destinatar[50])
nod *p;
p=root;
while(p!=NULL)
if(strcmp(p->destinatar,destinatar)==0)
{
printf("Continut:%s|Prioritate:%u\n",p->continut,p->prioritate);
return;
p=p->urm;
printf("Nu exista un mesaj pentru %s\n",destinatar);
void afisare()
nod *p=last;
while(p!=NULL && p->prioritate!=urgent)
printf("%u %s:%s\n",p->prioritate,p->destinatar,p->continut);
p=p->ant;
int main()
initializare();
trimitere_mesaj(ordinar,"Nume1","Hsafjsidfiwrfji3fsa");
trimitere_mesaj(urgent,"Nume1","Hsafjsigadfsdxzcadfiwrfji3fsa");
trimitere_mesaj(urgent,"Nume3","gdfweasxsafjsidfiwrfji3fsa");
trimitere_mesaj(ordinar,"Nume0","rthrthrtjsidfiwrfji3fsa");
trimitere_mesaj(ordinar,"Nume","xvzxvzxvzHsafjsidfiwrfji3fsa");
primire_mesaj("Nume3");
primire_mesaj("Nume1");
afisare();
return 0;
}
//Se considera o tabla de sah de dimensiune 8 x 8. Sa se determine cel mai scurt traseu pe care il
poate parcurge un cal de la pozitia [A,1] pana la pozitia [H,8] (observatie: liniile au valori intre 1 si 8,
iar coloanele intre A si H).
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
int a[8][8];
int sol[8][8];
int min = 64;
Int nu=0;
int solutie(int i, int j)
return i == 7 && j == 7;
void afisare(int mat[8][8])
for (int i = 0; i < 8; i++)
for (int j = 0; j < 8; j++)
printf("%d ", mat[i][j]);
printf("\n");
int x[8] = { 2, 1, -1, -2, -2, -1, 1, 2 };
int y[8] = { 1, 2, 2, 1, -1, -2, -2, -1 };
int valid(int i, int j)
if ((i >= 0 && i < 8) && (j >= 0 && j < 8) && a[i][j]==0)
return 1;
return 0;
int det(int mat[8][8])

{
int nr = 0;
for (int i = 0; i < 8;i++)
for (int j = 0; j < 8;j++)
if (mat[i][j] == 1)
nr++;
return nr;
void copiere()
for (int i= 0; i < 8;i++)
for (int j = 0; j < 8; j++)
sol[i][j] = a[i][j];
void back(int i, int j)
int X,Y;
for (int p = 0; p < 8; p++)
X = i + x[p];
Y = j + y[p];
if (valid(X, Y))
a[X][ Y] = 1;
if (solutie(X, Y))
nu++;
if (det(a) < min)
{
copiere();
min = det(a);
Else
if(nu<1000)
back(X, Y);
a[X][Y]=0;
int main()
a[0][0]=0;
back(0, 0);
afisare(sol);
return 0;
//Se considera o suprafata caroiata de dimensiune N x N, in care fiecare patrat are una din culorile
galben, rosu, albastru sau verde. Configuratia suprafetei se citeste de la tastatura (sau dintr-un fisier).
Sa se determine si sa se tipareasca daca exista drumuri (minime) intre colturile opuse. Un drum
trebuie sa cuprinda doar patrate de aceeasi culoare, deplasarea dintr-un patrat putandu-se face in
oricare dintre cei maxim opt vecini.
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
int a[5][5];
int sol[5][5];
int min;
int nr=0;
if(nr==0)
return i==4 &&j==4;
if(nr==1)
return i==4 && j==0;
if(nr==2)
void afisare(int mat[5][5])
for (int i = 0; i < 5; i++)
for (int j = 0; j < 5; j++)
printf("%d ", mat[i][j]);
printf("\n");
printf("|-|\n");
int x[8] = { 0, 0, 1, -1, -1, 1, -1, 1 };
int y[8] = { 1, -1, 0, 0, -1, -1, 1, 1 };
int valid(int i, int j,int c)
return i>=0 && i<5 && j>=0 && j<5 && a[i][j]==c;
int det(int mat[5][5])
int nr = 0;
for (int i = 0; i < 5;i++)
for (int j = 0; j < 5;j++)
if (mat[i][j] == 0)
nr++;
return nr;
void copiere()
for (int i= 0; i < 5;i++)
for (int j = 0; j < 5; j++)
sol[i][j] = a[i][j];
void back(int i, int j,int c)
int X,Y;
for(int p=0;p<8;p=p+1)
X=i+x[p];
Y=j+y[p];
if(valid(X,Y,c))
a[X][Y]=0;
if(solutie(X,Y))
if(det(a)<min)
copiere();
min=det(a);
else
back(X,Y,c);
a[X][Y]=c;
int main()
FILE *f;
f=fopen("fis.txt","r");
if(!f)
exit(1);
for(int i=0;i<5;i++)
for(int j=0;j<5;j++)
fscanf(f,"%d",&a[i][j]);
//afisare(a);
int c;
c=a[0][0];
a[0][0]=0;
min=64;
back(0,0,c);
a[0][0]=c;
if(min!=64)
afisare(sol);
nr++;
c=a[0][4];
a[0][4]=0;
min=64;
back(0,4,c);
a[0][4]=c;
if(min!=64)
afisare(sol);
nr++;
c=a[4][0];
a[4][0]=0;
min=64;
back(4,0,c);
a[4][0]=c;
if(min!=64)
afisare(sol);
nr++;
c=a[4][4];
a[4][4]=0;
min=64;
back(4,4,c);
a[4][4]=c;
if(min!=64)
afisare(sol);
fclose(f);
return 0;
//Un participant la un joc de noroc porneste avand la start o suma de bani A. La fiecare tura a jocului,
jucatorul poate pierde sau castiga o suma in valoare fixa B. Sa se gaseasca toate posibilele variante
de desfasurare a jocului (secvente pierdere - castig), astfel incat dupa N runde, jucatorul sa aiba
aceeasi suma de bani (A) ca la start. A, B si N se citesc de la tastatura.
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
int A,B,n,C;
int *sol;
int solutie(int k)
return C==A && k==n;

}
void afisare()
for(int i=0;i<n;i++)
printf("%d ",sol[i]);
printf("\n");
void back(int k)
if(i==0)
C=C+B;
else
C=C-B;
sol[k]=C;
if(k==n-1)
if(C==A)
afisare();
else
back(k+1);
if(i==0)
C=C-B;
else
C=C+B;
int main()
{
printf("Introdu suma de bani:");
scanf("%d",&A);
printf("Introdu suma de bani cu care creste/scade:");
scanf("%d",&B);
printf("Introdu numarul de runde:");
scanf("%d",&n);
sol=(int*)malloc(n*sizeof(int));
C=A;
sol[0]=A;
if(n>1)
back(1);
else
printf("%d\n",A);
free(sol);
return 0;
//Intre N orase exista o retea de drumuri care permite ca dintr-un oras sa se ajunga in oricare din
celelalte. Intre 2 orase exista cel mult un drum direct, de lungime cunoscuta, iar timpul necesar
pentru parcurgerea unui drum este proportional cu lungimea sa. Se cere sa se realizeze programul
pentru determinarea traseului pe care se poate merge intre doua orase date, intr-un timp minim.
Datele se citesc de la tastatura sau dintr-un fisier.
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
int n;
int a[100][100];
int min=0,nr;
int fin;
typedef struct ceva
int nod;
int muchie;
}graf;
graf *sol,*s;
int det()
int s=0;
s=s+sol[i].muchie;
return s;
void copiere()
s[i].nod=sol[i].nod;
s[i].muchie=sol[i].muchie;
int cauta(int k,int c,int i)
for(int j=0;j<k;j++)
if(sol[j].nod==i)
return 1;
return 0;
void back(int k,int c)
if(a[c][i]>0 && cauta(k,c,i)==0)
sol[k].nod=i;
sol[k].muchie=a[c][i];
// printf("da");
if(i==fin)
if(nr==0)
min=det();
copiere();
nr=1;
else
if(det()<min)
min=det();
copiere();
nr=k;
else
back(k+1,i);
int main()
FILE *f;
f=fopen("fis.txt","r");
if(!f)
perror("FIsierul nu a putut fi accesat\n");
exit(1);
fscanf(f,"%d",&n);
for(int j=0;j<n;j++)
fscanf(f,"%d",&a[i][j]);
sol=(graf*)malloc(n*sizeof(graf));
s=(graf*)malloc(n*sizeof(graf));
sol[0].nod=0;
sol[0].muchie=0;
fin=6;
back(1,0);
for(int i=0;i<=nr;i++)
printf("(%d,%d) ",s[i].nod,s[i].muchie);
printf("\n");
return 0;
//
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
int sol[10];
int v=0;
void inter()
int aux;
aux=sol[3];
sol[3]=sol[4];
sol[4]=aux;
void afisare()
inter();
printf("%d",sol[i]);
printf("\n");
inter();
int solutie(int k)
int nr=0;
int ok=0;
inter();
if(sol[i]==0)
nr++;
if(sol[i-1]==0 && sol[i]==0)

ok=1;
inter();
return nr==3 && ok==1;
void back(int k)
if(k==10)
if(solutie(k))
afisare();
else
{for(int i=0;i<10;i++)
sol[k]=i;
back(k+1);
int main()
sol[0]=0;
sol[1]=7;
sol[2]=2;
sol[3]=4;
back(4);
//
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
typedef struct backu
int x,y,t;
}back;
typedef struct backi
back s;
back d;
}sol;
back *a;
sol *s;
int n;
void afisare()
printf("(%d,%d)->(%d,%d)\n",s[i].s.x,s[i].s.y,s[i].d.x,s[i].d.y);
}
int solutie(int k)
return k==n;
int valid(int k)
int i,j;
for(i=0;i<=k;i++)
if(s[i].s.t==s[i].d.t)
return 0;
for(i=0;i<=k-1;i++)
for(j=i+1;j<=k;j++)
if(s[i].s.y==s[j].s.y || s[i].d.y==s[j].s.y || s[j].d.y==s[i].s.y || s[i].d.y== s[j].d.y)
return 0;
return 1;
void backa(int k)
if(solutie(k))
afisare();
exit(1);
else
for(int j=n;j<2*n;j++)
{
s[k].s=a[i];
s[k].d=a[j];
if(valid(k))
backa(k+1);
int main()
printf("Introduceti numarul de puncte:");
scanf("%d",&n);
a=(back*)malloc(2*n*sizeof(back));
if(!a)
exit(1);
s=(sol*)malloc(2*n*sizeof(sol));
if(!s)
exit(1);
for(int i=0;i<2*n;i++)
scanf("%d %d",&a[i].x,&a[i].y);
if(i<n)
a[i].t=0;
else
a[i].t=1;
backa(0);
return 0;
//
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
int a[100][100];
int sol[100];
int s[100];
int m, n;
int dim = 0;
int mar=0;
int pi, pj, fi, fj;
//int suma=0;
int maxim=0;
void copiere()
for (int i = 0; i<dim; i++)
s[i] = sol[i];
int det()
int suma = 0;
for (int i = 1; i<dim; i++)
suma = suma + (sol[i] - sol[i - 1]);
return suma;
return i == fi && j == fj;
void afisare()
printf("\n");
for (int i = 0; i < mar; i++)
printf("%d ", s[i]);
printf("\n");
}
int valid(int i, int j)
return i>=0 && i<=m && j>=0 && j<=n && a[i][j] != -1 && a[i][j] >= sol[dim-1];
int dx[8] = { 1, 0, -1, 0, -1, -1, 1, 1 };
int dy[8] = { 0, 1, 0, -1, -1, 1, -1, 1 };
if (solutie(i, j))
if (det() > maxim)
maxim = det();
copiere();
mar = dim;
else
int X, Y,l;
for (l = 0; l < 8; l++)
X = i + dx[l];
Y = j + dy[l];
if (valid(X, Y))
sol[dim] = a[X][Y];
a[X][Y] = -1;
dim++;
back(X, Y);
dim--;
a[X][Y] = sol[dim];
}
int main()
scanf("%d %d", &m, &n);
//printf("%d %d", m, n);
for (int i = 0; i < m;i++)
for (int j = 0; j < n; j++)
scanf("%d", &a[i][j]);
//printf("%d", a[0][1]);
printf("Introduceti pozitia de start:");
scanf("%d %d",&pi,&pj);
printf("Introduceti pozitia de stop:");
scanf("%d %d",&fi,&fj);
sol[dim] = a[pi][pj];
a[pi][pj] = -1;
dim++;
back(pi, pj);
dim--;
a[pi][pj] = sol[dim];
afisare();
return 0;
//Metoda de testare algoritimi Knuth-Morris-Pratt si Boyer-Moore.
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
int mmax; //{lungime maxima model}

int nmax; //{lungime maxima sir sursa}
char m[100], n[100]; //model si sursa
void preKmp(char* pattern, int pattern_length, int kmpNext[])
int i, j;
i = 0;
j = -1;
kmpNext[0] = -1;
while (i < pattern_length)
while (j > -1 && pattern[i] != pattern[j])
j = kmpNext[j];
i++;
j++;
if (pattern[i] == pattern[j])
kmpNext[i] = kmpNext[j];
else
kmpNext[i] = j;
void knuth_morris_pratt(char* pattern, int pattern_length, char* source, int source_length)
int i, j;
int kmpNext[1024]; // tabloul kmpNext trebuie sa aiba cate o intrare pentru fiecare caracter al
modelului
/* Faza de precompilare a modelului */
preKmp(pattern, pattern_length, kmpNext);
/* Faza de cautare propriu-zisa */
i = 0;
j = 0;
while (j < source_length)
{
while (i > -1 && pattern[i] != source[j])
i = kmpNext[i];
i++;
j++;
if (i >= pattern_length)
printf("Gasit la pozitia %d\n", j - i);
i = kmpNext[i];
void preBm(char* pattern, int pattern_length, int bmNext[])
int i;
for (i = 0; i < 256; i++)
bmNext[i] = pattern_length;
for (i = 0; i < pattern_length - 1; i++)
bmNext[pattern[i]] = pattern_length - i - 1;
void boyer_moore(char* pattern, int pattern_length, char* source, int source_length)
int i, j;
int bmNext[256];
/* Faza de precompilare a modelului */
preBm(pattern, pattern_length, bmNext);
/* Faza de cautare propriu-zisa */
j = 0;
while (j <= source_length - pattern_length)
for (i = pattern_length - 1; i >= 0 && pattern[i] == source[i + j]; i--);
if (i < 0)
{
printf("Gasit la pozitia %d\n", j);
if (j == 0)
j = 1;
else
j += bmNext[source[i + j]];
else
j += bmNext[source[i + j]];
int main()
scanf("%d %d", &nmax, &mmax);
scanf("%s %s", m, n);
printf("Knuth-Morris-Pratt\n");
knuth_morris_pratt(m, mmax, n, nmax);
printf("Boyer-Moore\n");
boyer_moore(m, mmax, n, nmax);
printf("%s\n%s\n", n, m);
return 0;
//
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
typedef struct colet
char categorie;
int id;
char destinatie[100];
struct colet *urm;
}colet;
typedef struct categorie{
colet *root;
colet *last;
char nume;
}categorie;
categorie t[4];
int n = 0;
void adaugare_categorie(char categorie)
if (n < 4)
t[n].nume = categorie;
t[n].root = NULL;
t[n].last = NULL;
n++;
else
printf("Nu mai exista loc in tabloul de categorii\n");
colet* creeare_colet(char categorie, int id, char destinatie[100])
colet *p;
p = (colet *)malloc(sizeof(colet));
if (!p)
exit(1);
p->categorie = categorie;
p->id = id;
strcpy(p->destinatie, destinatie);
p->urm = NULL;
return p;
void adaugare_colet(colet* c)
for (int i = 0; i < n;i++)
if (c->categorie == t[i].nume)
if (t[i].root == NULL)
t[i].root = c;
t[i].last = c;
else
t[i].last->urm = c;
t[i].last = c;
break;
void livrare_colet(char categorie)
for (int i = 0; i < n; i++)
if (categorie == t[i].nume)
if (t[i].root != NULL)
colet *p;
p = t[i].root;
printf("Coletul %d a fost livrat la destinatie %s\n", p->id,
p->destinatie);
t[i].root = t[i].root->urm;
free(p);
break;
else
printf("Nu exista colete in categoria respectiva\n");
int main()
adaugare_categorie('a');
adaugare_categorie('b');
adaugare_categorie('c');
adaugare_categorie('d');
adaugare_categorie('e');
colet *v[4];
v[0] = creeare_colet('a', 1000, "Matei Cosmin");
v[1] = creeare_colet('a', 100, "Stefan Miron");
v[2] = creeare_colet('a', 50, "Viru Silviu");
v[3] = creeare_colet('a', 49, "Karu Maru");
adaugare_colet(v[0]);
livrare_colet('a');
livrare_colet('a');
livrare_colet('b');
return 0;
}
//
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
# define N 100
typedef struct muncitor{
char cod[100];
}muncitor;
typedef struct echipa{

int id;
int dim;
muncitor t[N];
int n;
struct echipa *urm;
}echipa;
echipa *root=NULL;
echipa *creeare_echipa(int id, int dim)
echipa *p;
p = (echipa*)malloc(sizeof(echipa));
if (!p)
exit(1);
p->id = id;
p->dim = dim;
p->n = -1;
p->urm = NULL;
return p;
muncitor creeare_muncitor(char cod[100])
muncitor p;
strcpy(p.cod, cod);
return p;
void adaugare_echipa(echipa *e)
if (root == NULL)
{
root = e;
else
e->urm = root;
root = e;
void adaugare_membru(int id,muncitor m)
echipa *p;
p = root;
while (p != NULL)
if (p->id == id)
if (p->n +1 < p->dim)
p->n++;
p->t[p->n] = m;
else
printf("Nu mai este loc in aceasta echipa");
break;
p = p->urm;
}
void detasare(int id)
echipa *p;
p = root;
while (p != NULL)
if (p->id == id)
if (p->n > -1)
printf("S-a detasat din echipa %d muncitor %s\n", p->id,

p->t[p->n].cod);
p->n--;
else
printf("Nu exista muncitori in echipa respectiva\n");
break;
p = p->urm;
int main()
echipa *v[4];
v[0] = creeare_echipa(1, 3);
adaugare_echipa(v[0]);
muncitor m1, m2;
m1 = creeare_muncitor("Boss de boss");
m2 = creeare_muncitor("Sef de sef");
adaugare_membru(1, m1);
adaugare_membru(1, m2);
detasare(1);
detasare(1);
detasare(2);
return 0;
//Fie un sistem de gestionare a rezervarii unor bilete la un concert. O rezervare este

caracterizat printr-o categorie (char), un ID (intreg) si un nume solicitant (max 35 caractere). Sa
se scrie si sa se implementeze o structura bazata pe lista inlantuita articulata cu tablouri
(eficienta din punct de vedere al timpului de rulare) pentru a gestiona rezervarile. Structura va
avea urmatoarea componenta: Fiecare categorie reprezinta un nod intr-o lista, si fiecare
categorie contine o coada (FIFO) implementata in mod static, cu cererile de rezervare din acea
categorie.
Sa se implementeze urmatoarele functionalitati:
● Adaugare categorie
● Adaugare cerere rezervare
● Deservire cerere rezervare (scoatere din coada).
● Afisare situatie - afisare categorii cu biletele aferente
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define N 20
typedef struct rezervare
{
char categorie;
int id;
char nume[35];
}rezervare;
typedef struct categorie
char nume;
rezervare coada[N];
int index;
struct categorie *urm;
}categorie;
categorie *root=NULL;
categorie *creeare_categorie(char nume)
categorie *p;
p = (categorie*)malloc(sizeof(categorie));
if (!p)
exit(1);
p->nume = nume;
p->index = 0;
p->urm = NULL;
rezervare creeare_rezervare(char categorie, int id, char nume[35])
rezervare p;
p.categorie = categorie;
p.id = id;
strcpy(p.nume, nume);
return p;
void adaugare_categorie(categorie *c)
if (root == NULL)
root = c;
else
c->urm = root;
root = c;
void adaugare_rezervare(rezervare r)
categorie *p;
p = root;
while (p != NULL)
if (p->nume == r.categorie)
if (p->index < N)
p->coada[p->index] = r;
p->index++;
else
printf("Nu mai exista loc in categoria %c\n", r.categorie);
break;
}
p = p->urm;
void deservire(char c)
categorie *p;
p = root;
while (p != NULL)
if (p->nume == c)
if (p->index > 0)
printf("Biletul %d rezervat de %s din categoria %c a fost deservit\n",

p->coada[0].id, p->coada[0].nume, p->coada[0].categorie);
for (int i = 0; i < p->index-1; i++)
p->coada[i] = p->coada[i + 1];
p->index--;
else
printf("Nu exista bilete rezervate in categoria %c\n", c);
break;
p = p->urm;
void afisare()
{
categorie *p;
p = root;
while (p != NULL)
printf("Categoria %c\n", p->nume);
if (p->index != 0)
for (int i = 0; i < p->index; i++)
printf("Biletul %d rezervat de %s \n", p->coada[i].id, p->coada[i].nume);
else
printf("Nu exista bilete rezervate pentru aceasta categorie\n");
p = p->urm;
int main()
categorie *c1, *c2;
c1 = creeare_categorie('a');
c2 = creeare_categorie('b');
adaugare_categorie(c1);
adaugare_categorie(c2);
rezervare v[4];
v[0] = creeare_rezervare('a', 19, "Popescu Tudor");
v[1] = creeare_rezervare('a', 29, "Popescu Tdor");
v[2] = creeare_rezervare('a', 39, "Popescu Tudr");
v[3] = creeare_rezervare('a', 49, "Popescu Tudo");
adaugare_rezervare(v[0]);
afisare();
deservire('a');
deservire('b');
afisare();
return 0;
//
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
typedef struct client
char nume[100];
int nr_locuri;
struct client *urm;
}client;
typedef struct pensiune
char nume[100];
int categorie, nr_locuri;

client *root;
}pensiune;
pensiune t[10];
int n=3;
client* creeare_client(char nume[100],int nr_locuri)
client *p;
p = (client*)malloc(sizeof(client));
if (!p)
exit(1);
strcpy(p->nume, nume);
p->nr_locuri = nr_locuri;
p->urm = NULL;
return p;
char *rezervare(char nume_client[100], int nr_locuri, int categorie)
for (int i = 0; i < n; i++)
{
if (categorie == t[i].categorie &&t[i].nr_locuri>=nr_locuri)
client *p = creeare_client(nume_client, nr_locuri);
t[i].root = p;
else
p->urm = t[i].root;
t[i].root = p;
t[i].nr_locuri = t[i].nr_locuri - nr_locuri;
return t[i].nume;
return NULL;
void renuntare(char nume_client[100])
for (int i = 0; i < n; i++)

{
client *p,*q;
p = t[i].root;
if (strcmp(p->nume, nume_client) == 0)
t[i].root =t[i].root->urm;
printf("Clientului %s i-a fost anulata rezervarea\n", nume_client);
t[i].nr_locuri = t[i].nr_locuri + p->nr_locuri;
free(p);
return;
q = p;
while (p != NULL)
if (strcmp(p->nume, nume_client) == 0)
q->urm = p->urm;
printf("Clientului %s i-a fost anulata rezervarea\n", nume_client);
t[i].nr_locuri = t[i].nr_locuri + p->nr_locuri;
free(p);
return;
}
q = p;
p = p->urm;
printf("Clientul cautat nu are rezervare");
void afisare(int categorie)
for (int i = 0; i < n; i++)
if (categorie == t[i].categorie)
client *p;
printf("Pensiunea %s,locuri disponibile %d\n", t[i].nume,t[i].nr_locuri);
p = t[i].root;
while (p != NULL)
printf("Clientul %s cu %d locuri rezervate|", p->nume, p->nr_locuri);
p = p->urm;
printf("\n");
}
int main()
t[0].categorie = 1;
t[0].nr_locuri = 10;
strcpy(t[0].nume, "Nume Pensiune1");
t[1].categorie = 2;
t[2].categorie = 3;
rezervare("Nume1", 3, 1);
afisare(1);
renuntare("Nume2");
afisare(1);
return 0;
}
//
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define N 2
typedef struct angajat
char nume[100];
int cod;
int cod_propus;
struct angajat *urm;
}angajat;
typedef struct firma
char nume[100];
int cod;
angajat *root;
}firma;
firma t[N];
int j;
angajat *creeare_angajat(char nume[100], int cod)
angajat *p;
p = (angajat*)malloc(sizeof(angajat));
if (!p)
exit(1);
p->cod = j;
j++;
p->cod_propus = cod;
p->urm = NULL;
return p;
void angajeaza(int cod_firma, char nume[100], int cod)
for (int i = 0; i < N; i++)

{
if (t[i].cod == cod_firma)
angajat *p;
p = creeare_angajat(nume, cod);
t[i].root = p;
else
p->urm=t[i].root;
t[i].root = p;
break;
void mutaangajat(int cod_angajat, int cod_firma)
for (int i = 0; i < N; i++)
{
if (t[i].cod == cod_firma)
angajat *p = t[i].root;
while (p != NULL)
if (p->cod == cod_angajat)
printf("Angajatul respectiv apartine deja firmei\n");
return;
p = p->urm;
angajat *p;
angajat *q;
for (int l = 0; l < N; l++)
p = t[l].root;
q = p;
t[l].root = t[l].root->urm;
angajeaza(cod_firma, q->nume, rand() * 30);
free(p);
return;
p = p->urm;
angajat *y;
y = t[l].root;
while (p != NULL)
q = p;
y->urm = p->urm;
angajeaza(cod_firma, q->nume, rand() * 30);
free(p);
return;
y = p;
p = p->urm;
}
}
char* cauta(int cod)
for (int i = 0; i < N; i++)
angajat *p;
p = t[i].root;
while (p != NULL)
if (p->cod == cod)
return p->nume;
p = p->urm;
char ce[100] = "nu exista";
return ce;
void listare()
for (int i = 0; i < N; i++)
printf("Firma %s cu codul %d\n", t[i].nume, t[i].cod);

angajat *p;
p = t[i].root;
while (p != NULL)
printf("Angajat %s cu codul %d ", p->nume, p->cod);
if (strcmp(cauta(p->cod_propus), "nu exista") != 0)
char nume[100];
strcpy(nume, cauta(p->cod_propus));
printf("recomanda angajatul %s", nume);
p = p->urm;
printf("|");
printf("\n");
int main()
strcpy(t[0].nume, "NumeFirma1");
t[0].cod = 11;
strcpy(t[1].nume, "NumeFirma2");
t[1].cod = 12;
angajeaza(11, "NumeAngajat1", 12);
listare();
mutaangajat(1, 12);
printf("\n");
listare();
return 0;
//
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
typedef struct jucator
char nume[100];
int salar;
struct jucator *urm;
}jucator;
typedef struct echipa
char nume[100];
jucator *root;
struct echipa *urm;
}echipa;
echipa *root;
void initializare()
root = NULL;
void adaugare_echipa(char nume[100])
echipa *p;
p = (echipa*)malloc(sizeof(echipa));
p->root = NULL;
p->urm = NULL;
if (root == NULL)
{
root = p;
else
p->urm = root;
root = p;
void eliminare_echipa(char nume[100])
echipa *p;
p = root;
if (strcmp(p-> nume, nume) == 0)
root = root->urm;
free(p);
return;
p = p->urm;
echipa *q;
q = root;
while (p != NULL)
if (strcmp(p-> nume, nume) == 0)
q->urm = p->urm;
free(p);
return;
q = p;
p = p->urm;
printf("Nu exista echipa %s\n", nume);
int cauta_jucator(nume)
echipa *p;
p = root;
while (p != NULL)
jucator *q;
q = p->root;
while (q != NULL)
if (strcmp(q->nume, nume) == 0)
return 1;
q = q->urm;
p = p->urm;
}
return 0;
void adaugare_jucator(char nume[100], char nume_e[100], int salar)
if (cauta_jucator(nume) == 0)
echipa *p;
p = root;
while (p != NULL)
if (strcmp(p->nume, nume_e) == 0)
jucator *q;
q = (jucator*)malloc(sizeof(jucator));
strcpy(q->nume, nume);
q->salar = salar;
q->urm = NULL;
if (p->root == NULL)
p->root = q;
return;
else
if (p->root->salar < q->salar)
q->urm =p->root;
p->root = q;
return;
jucator *r,*s;
r = p->root->urm;
s = p->root;
while (r != NULL)
if (r->salar < q->salar)
s->urm = q;
q->urm = r;
return;
s = r;
r = r->urm;
s->urm = q;
return;
p = p->urm;
printf("Nu exista echipa %s\n",nume_e);
printf("Jucatorul %s exista deja intr-o echipa\n");

}
void eliminare_jucator(char nume[100])
echipa *p;
p = root;
while (p != NULL)
jucator *q;
if (p->root != NULL)
q = p->root;
if (strcmp(p->root->nume, nume) == 0)
p->root = p->root->urm;
free(q);
return;
//printf("**");
q = p->root->urm;
jucator *r;
r = p->root;
while (q != NULL)
r->urm = q->urm;
free(q);
return;
r = q;
q = q->urm;
p = p->urm;
printf("Jucatorul %s nu exista intr-o echipa\n", nume);
int returneaza_salar(char nume[100])
echipa *p;
p = root;
while (p != NULL)
jucator *q;
q = p->root;
while (q != NULL)
return q->salar;
q = q->urm;
}
p = p->urm;
return 0;
void transfera_jucator(char nume[100],char nume_echipa[100])
if (cauta_jucator(nume) == 1)
int salar = returneaza_salar(nume);
eliminare_jucator(nume);
adaugare_jucator(nume, nume_echipa, salar);
return;
printf("Jucatorul %s nu exista intr-o echipa\n", nume);
void listare(char nume[100])
echipa *p;
p = root;
while (p != NULL)
if (strcmp(p->nume, nume) == 0)
jucator *q;
q = p->root;
while (q != NULL)
{
printf("%s %d|", q->nume, q->salar);
q = q->urm;
printf("\n");
return;
p = p->urm;
printf("Nu exista echipa %s \n", nume);
int main()
initializare();
adaugare_echipa("Fc Vant");
adaugare_echipa("CS Ploaie");
adaugare_echipa("Fc Tunet");
eliminare_echipa("CS Ploaie");
listare("CS Ploaie");
adaugare_jucator("Nume1", "Fc Vant", 100);
listare("Fc Vant");
transfera_jucator("Nume3", "Fc Tunet");
listare("Fc Vant");
listare("Fc Tunet");
return 0;
}
//
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
int n;
int m;
int si, sj;
int a[100][100];
int max;
int dx[4] = { 1, 0, -1, 0 };
int dy[4] = { 0, 1, 0, -1 };
int det()
{
int sum = 0;
for (int i = 0; i < m;i++)
for (int j = 0; j < n;j++)
if (a[i][j] == -1)
sum++;
return sum;
}
void afisare()
{
for (int i = 0; i < m; i++)
{
for (int j = 0; j < n; j++)
if (a[i][j] == -1)
printf("X ");
else
printf("%d ", a[i][j]);
printf("\n");
}
printf("\n");
}
int solutie()
{
//int sum = 0;
for (int i = 0; i < m;i++)
for (int j = 0; j < n;j++)
if (a[i][j] == 0 || a[i][j] == 2)
return 0;
return 1;
}
int valid(int i,int j)
{
return a[i][j] != 1 && a[i][j] != 2 && i >= 0 && i < m && j >= 0 && j <= n && a[i][j]!=-1;
}
{
if (det() < max)
return;
if (solutie())
{
return;
}
int X, Y,val;
for (int l = 0; l < 4; l++)
{
X = i + dx[l];
Y = j + dy[l];
if (valid(X, Y))
{
val = a[X][Y];
a[X][Y] = -1;
back(X, Y);
//a[X][Y] = val;
}
}
}
int main()
{
scanf("%d", &m);
scanf("%d", &n);
for (int i = 0; i < m; i++)
for (int j = 0; j < n; j++)
scanf("%d", &a[i][j]);
printf("Introduceti pozitia robotelului:");
scanf("%d %d", &si, &sj);
//printf("%d %d", si, sj);
a[si][sj] = -1;
back(si, sj);
afisare();
return 0;
}
//Sa se scrie o functie care primeste ca parametru un cuvant si afiseaza toate prefixele acelui
cuvant.
pentru "STUDENT"-> prefixele sunt: S, ST, STU, STUD, STUDE, STUDEN, STUDENT
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
void prefix(char *s)

{
int i = 1;
while (i < strlen(s))
{
for (int j = 0; j < i; j++)
printf("%c", s[j]);
printf(",");
i++;
}
printf("%s\n", s);
}
int main()
{
char s[100];
scanf("%s", &s);
prefix(s);
return 0;
}
//
Completati secventele de cod lipsa pentru a gasi o solutie de parcurgere a unui traseu
intre doua perechi de coordonate cu piesa de sah nebun atunci cand pe tabla de sah
exista spatii libere si obstacole.
#include <stdio.h>
#define nmax 5
typedef struct coordonate

{
int x;
int y;
}coordonate;
coordonate pos[nmax]; //tabloul de posibilitati
coordonate a[nmax*nmax]; //tablou de maxim nmax elemente
int matrice[nmax][nmax] = { { 0, 0, 1, 0, 1 },
{ 0, 0, 0, 0, 1 },
{ 1, 1, 0, 0, 1 },
{ 1, 0, 1, 1, 0 },
{ 0, 1, 0, 1, 0 }, }; //matricea initiala
(0=liber)
void initializare(int n) //int a[] variabila globala

{
pos[0].x = -1;
pos[0].y = -1;
pos[1].x = -1;
pos[1].y = 1;
pos[2].x = 1;
pos[2].y = -1;
pos[3].x = 1;
pos[3].y = 1;
}
void afiseaza_solutia(int n)
{
int i;
for (i = 0; i < n; i++)
printf("X=%d Y=%d\n", a[i].x, a[i].y);
printf("\n");
}
int acceptabil(coordonate pos)
{
return matrice[pos.x][pos.y] != 1 && matrice[pos.x][pos.y] != 2 && pos.x>=0 &&
pos.x<nmax && pos.y>=0 && pos.y<nmax;
}
int solutie(int k, coordonate c, coordonate c_final)
{
return c.x == c_final.x && c.y == c_final.y;
}
void labirint(int k, coordonate c_final) //k pasul, c coordonata curenta
{
int i;
coordonate aux;
if (solutie(k, a[k - 1], c_final)) //solutie completa (avem n elemente)
afiseaza_solutia(k);
else
{
for (i = 0; i < 4; i++) // parcurgem pe rand posibilitatile
{
aux.x = a[k - 1].x + pos[i].x;
aux.y = a[k - 1].y + pos[i].y;
if (acceptabil(aux)) {//daca posibilitatea e acceptabila
a[k] = aux;
matrice[a[k].y][a[k].x] = 2; //marcheaza ca vizitat
labirint(k + 1, c_final); // back1(posibilitate_k+1)
matrice[a[k].y][a[k].x] = 0; //sterge marcajul ca vizitat
}
}
}
} /*labirint*/
int main(void)
{
coordonate c, c2;
initializare(nmax);
printf("Dati valoarea initiala pt x intre (0 si %d): ", nmax);
scanf("%d", &c.x);
printf("Dati valoarea initiala pt y intre (0 si %d): ", nmax);
scanf("%d", &c.y);
printf("Dati valoarea finala pt x intre (0 si %d): ", nmax);
scanf("%d", &c2.x);
printf("Dati valoarea finala pt y intre (0 si %d): ", nmax);
scanf("%d", &c2.y);
if (acceptabil(c) && (acceptabil(c2))) //daca pozitia initala se incadreaza in limitele
hartii si este libera
matrice[c.y][c.x] = 2;
else
printf("Coordonate invalide\n");
a[0] = c; //pasul 0 reprezinta originea
labirint(1, c2);
return 0;
}
//
Să se modeleze un sistem medical în care pacienţii apar la momente aleatoare şi sunt
caracterizaţi printr-o clasă de asigurare (întreg,1,2,...),
un nume şi o prioritate (număr întreg), prioritatea fiind valabilă în cadrul clasei respective. La
anumite momente, medicul-ul tratează câte un
pacient şi anume pe cel de prioritate maximă din clasa ce conţine numărul maxim de pacienţi.
Să se definească o listă înlănţuită principală
pentru clase şi tablouri secundare pentru pacienţi şi să se implementeze operatorii:
actualizare_pacient(nume, clasa_nouă, prioritate_nouă) – funcţia caută un pacient după nume

şi apoi îl mută într-o nouă clasă şi îi atribuie o
nouă prioritate;
listare() – listează toţi pacienţii, pe clase.
Se va descrie în cuvinte rolul fiecărei structuri de date folosite si a fiecărei funcţii implementate.
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
typedef struct pacient
{
int clasa;
char nume[100];
int prio;
}pacient;
typedef struct clasa
{
int nr;
pacient t[100];
int n;
struct clasa *urm;
}clasa;
clasa *root = NULL;
int sterge(char *nume,clasa *p)
{
for (int i = 0; i < p->n; i++)
{
if (strcmp(p->t[i].nume, nume) == 0)
{
for (int j = i; j < p->n - 1; j++)
p->t[j] = p->t[j + 1];
p->n--;
return 1;
}
}
return 0;
}
void inserare(pacient t[100], pacient p, int poz,int *n)
{
(*n)++;
for (int i = (*n)-1; i > poz; i--)
t[i] = t[i - 1];
t[poz] = p;
}
void actualizare_pacient(char *nume, int clasa_noua, int prio)
{
clasa *p;
p = root;
while (p != NULL)
{
if (sterge(nume, p) == 1)
break;
p = p->urm;
}
p = root;
while (p != NULL)
{
if (p->nr == clasa_noua)
{
pacient q;
q.clasa = clasa_noua;
strcpy(q.nume, nume);
q.prio = prio;
for (int i = 0; i < p->n;i++)
if (q.prio>p->t[i].prio)
{
inserare(p->t, q, i,&(p->n));
return;
}
}
p = p->urm;
}
}
void listare()
{
clasa *p;
p = root;
while (p!=NULL)
{
for (int i = 0; i < p->n; i++)
printf("Clasa:%d Nume:%s Prioritate:%d |", p->nr, p->t[i].nume,
p->t[i].prio);
printf("\n");
p = p->urm;
}
}
clasa* creeare(int nr)
{
clasa *p;
p = (clasa*)malloc(sizeof(clasa));
p->n = 0;
p->nr = nr;
p->urm = NULL;
return p;
}
void adauga_clasa(clasa *p)
{
if (root == NULL)
root = p;
else
{
p->urm = root;
root = p;
}
}
void adaugare_pacient(clasa *p, pacient a)
{
p->t[p->n++] = a;
}
pacient creeare_pacient(char *nume, int clasa, int prio)
{
pacient p;
strcpy(p.nume, nume);
p.clasa = clasa;
p.prio = prio;
return p;
}
int main()
{
adauga_clasa(creeare(3));
adaugare_pacient(root->urm, creeare_pacient("Nume1", 2, 3));
adaugare_pacient(root->urm->urm, creeare_pacient("Nume4", 3, 3));
adaugare_pacient(root, creeare_pacient("Nume5", 1, 4));
listare();
actualizare_pacient("Nume2", 1, 5);
listare();
return 0;
}
//
Să se scrie un program folosind liste simplu înlănţuite combinate cu tablouri pentru modelarea
cât mai eficientă din punct de vedere al timpului
de rulare a situaţiei dintr-o firma software în care proiectele pot fi adăugate sau retrase în orice
moment iar angajatii pot fi asignati sau
retrasi de la un anumit proiect în orice moment. Programul va putea efectua operaţii asupra unui
număr arbitrar de proiecte şi va trebui să
implementeze următorii operatori:
* transferă_angajat(nume_angajat, nume_proiect_nou) – transferă angajatul dat prin numele
său la un nou proiect;
* listare_proiecte() – pentru fiecare proiect listează angajatii din echipa de proiect în ordine
invers alfabetica.
Se va descrie în cuvinte rolul fiecărei structuri de date folosite si a fiecărei funcţii implementate.

Sda PDF

Încărcat de

Informații document

Titlu original

Drepturi de autor

Formate disponibile

Partajați acest document

Partajați sau inserați document

Opțiuni de partajare

Vi se pare util acest document?

Este necorespunzător acest conținut?

Drepturi de autor:

Formate disponibile

Sda PDF

Încărcat de

Drepturi de autor:

Formate disponibile

//​Sa se evalueze din punct de vedere al timpului de executie algoritmii de sortare quicksort si

heapsort, folosind functiie din timer.h/timer.c si sa se compare performantele acestora pentru

Algoritm, N2, timp_executie

· Sa se aplice algoritmul de cautare liniara pentru localizarea tuturor studentilor care au

typedef struct fac

int cautare_binara_performanta(student *list)

int m, s, d, count = 0;;

if (strcmp(list[m].nume, "MATEI STEFAN") < 0)

if (strcmp(list[d].nume, "MATEI STEFAN") == 0)

void cautare_liniara(student *list, char op[3])

for (int i = 0; i < 4999; i++)

if ((strcmp(list[i].optional[0], op) == 0) || (strcmp(list[i].optional[1], op) == 0) ||

perror("Fisierul nu a putut fi accesat");

list = (student*)malloc(5000 * sizeof(student));

printf("Alocare dinamica esuata");

for (i = 0; i < 4999; i++)

fgets(list[i].nume, 35, f);

fscanf(f, "%s %s %s %s \n", list[i].optional[0], list[i].optional[1], list[i].optional[2],

printf("Numarul de comparatii pana la gasirea persoanei cautate:%d\n",

typedef struct fac

int cautare_binara_performanta(meserie *list,int n)

int m, s, d, count = 0;;

if (strcmp(list[m].ocupatie, "programator") < 0)

void cautare_liniara(meserie *list,int n)

printf("Ocupatiile al caror cod se afla intre 20000 si 30000 sunt:");

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

if (list[i].cod >= 200000 && list[i].cod <= 300000)

printf("%d ", i);

perror("Fisierul nu a putut fi accesat");

list = (meserie*)realloc(list, n*sizeof(meserie));

fscanf_s(f, "%li ", &list[n - 1].cod);

fgets(list[n - 1].ocupatie, 254, f);

list[n - 1].ocupatie[strlen(list[n - 1].ocupatie) - 1] = '\0';

printf("Numarul de comparatii necesare pentru gasirea meseriei de programator

Sa se citeasca datele din fisier intr-un tablou de 5.000 de elemente de forma

< nume , optional1, optional2, opptional3, optional4 >

· Utilizand algoritmul de sortare prin amestecare (ShakerSort), sa se afiseze studentii

· Utilizand algoritmul de sortare prin insertie (InsertSort), sa se afiseze optionalele unui

typedef struct lis

char nume[36], optionale[4][3];

void shakersort(student *a)

int j, ultim, sus, jos;

int comp = 0,atrb = 0;

sus = 1; jos = 4999; ultim = 4999;

for (j = jos; j >= sus; j--)

temp = a[j - 1]; a[j - 1] = a[j]; a[j] = temp;

for (j = sus; j <= jos; j++)

if (strcmp(a[j - 1].nume, a[j].nume)>0)

temp = a[j - 1]; a[j - 1] = a[j]; a[j] = temp;

fprintf_s(stdout, "Se vor afisa studentii in ordine alfabetica\n");

for (j = 0; j <= 4999; j++)

fprintf_s(stdout, "%s\n", a[j].nume);

fprintf_s(stdout, "Se vor afisa studentii invers\n");

for (j = 4999; j >= 0; j--)

fprintf_s(stdout, "%s\n", a[j].nume);

fprintf_s(stdout, "Numarul de comparatii este:%d\nNumarul de atribuiri este:%d\n",

for (i = 2; i >= 0; i--)

strncpy(a.optionale[4], a.optionale[i], 2);

while (strcmp(a.optionale[j], a.optionale[4]) < 0) {

strncpy(a.optionale[j - 1], a.optionale[j], 2); j++;

strncpy(a.optionale[j - 1], a.optionale[4], 2);

printf_s("Optionalele in ordine alfabetica sunt:\n");

for (i = 0; i < 3; i++)

//Sa se evalueze din punct de vedere al timpului de executie algoritmii de sortare quicksort si

list = (student)malloc(5000 sizeof(student));

list = (meserie)realloc(list, nsizeof(meserie));

● Să se citească elementele într-un tablou de structuri de forma: <an, durata,