Вы находитесь на странице: 1из 13

Vectori

void citire(int vector[], int &dimensiune)


{
std::cout << "Introduceti numarul de elemente: \n";
std::cin >> dimensiune;
for (int i = 0; i < dimensiune; i++)
{
std::cout << "Introduceti un element: \n";
std::cin >> vector[i];
}
}

void afisare(int vector[], int dimensiune)


{
for (int i = 0; i < dimensiune; i++)
std::cout << vector[i] << " ";
}

int prim(int x)
{
if (x == 2) return 1;
if (x < 2) return 0;
if (x % 2 == 0) return 0;

for (int i = 3; i*i <= x; i += 2)


if (x%i == 0)
return 0;
return 1;
}
int inserare_minim(int v[], int &n,int pozitie,int minim)
{
n++;
for (int index = n; index > pozitie; index--)
v[index] = v[index - 1];
v[pozitie] = minim;
return 0;
}

int minim (int v[], int n)


{
int minim = v[0];
for (int i = 1; i < n; i++)
{
if (v[i] < minim)
minim = v[i];
}
return minim;
}

void Fibonacci(int vector[], int k)

int a = 0;

int b = 1;

int c = a + b;

for (int index = 0; index < k; index++)


{

vector[index] = a;

a = b;

b = c;

c = a + b;

void CMMDC(int &a, int &b)

while (a != b)

if (a > b)

a = a - b;

else b = b - a;

void cifra_control(int &a)

int s = 0;

do {

int aux = 0;

while (a)

aux+= a % 10;

a /= 10;

s = aux;

a = s;

} while (s >9);

a = s;

void Factori_Primi(int numar)

int divizor = 2;

while (numar > 1)


{

int putere = 0;

while (numar%divizor == 0)

putere++;

numar /= divizor;

if(putere!=0)

std::cout << divizor << "^" << putere << std::endl;

divizor++;

Interschimbare

int i = 0, j = 0;
while (i < dimensiune1 && j < dimensiune2)
{
if (Vector1[i] < Vector2[j])
{
Vector_ordonat[k] = Vector1[i];
k++;
i++;
}
else
if(Vector1[i]== Vector2[j])
{
Vector_ordonat[k] = Vector2[j];
k++;
j++;
i++;
}
else
{
Vector_ordonat[k] = Vector2[j];
k++;
j++;
}
}

if (i <= dimensiune1)
{
for (int p = i; p < dimensiune1; p++)
{
Vector_ordonat[k] = Vector1[p];
k++;
}
}
if (j <= dimensiune2)
{
for (int p = j; p < dimensiune2; p++)
{
Vector_ordonat[k] = Vector2[p];
k++;
}
}
for (int p = 0; p < k; p++)
std::cout << Vector_ordonat[p] << " ";

Bubblesort sortare

void bubblesort(int v[], int dim)


{
bool ok = 0;

while(ok==0)
{
ok = 1;
for (int index = 0; index < dim - 1; index++)
if (v[index] > v[index + 1])
{
int aux = v[index];
v[index] = v[index + 1];
v[index + 1] = aux;
ok = 0;
}
}
}

Sort

bool descr(int a, int b)


{
return a > b;
}

std::sort(vector, vector+dimensiune);

Quicksort

void quickSort(int vector[], int left, int right)


{
int i = left, j = right;
int tmp;
int pivot = vector[(left + right) / 2];

while (i <= j)
{
while (vector[i] < pivot)
i++;
while (vector[j] > pivot)
j--;
if (i <= j)
{
tmp = vector[i];
vector[i] = vector[j];
vector[j] = tmp;
i++;
j--;
}
}
if (left < j)
quickSort(vector, left, j);
if (i < right)
quickSort(vector, i, right);
}

left = 0; right = dimensiune - 1;

quickSort(vector1, left, right);

void quickSort_descrescator(int vector[], int left, int right)


{
int i = left, j = right;
int tmp;
int pivot = vector[(left + right) / 2];

while (i<=j)
{
while (vector[i] > pivot)
i++;
while (vector[j] < pivot)
j--;
if (i <= j)
{
tmp = vector[i];
vector[i] = vector[j];
vector[j] = tmp;
i++;
j--;
}
}

if (left < j)
quickSort_descrescator(vector, left, j);
if (i < right)
quickSort_descrescator(vector, i, right);
}

left = 0; right = dimensiune - 1;

quickSort_descrescator(vector, left, right);

Matrice
void citire(int mat[10][10], int &n, int &m)
{
std::cout << "Numarul de linii = "; std::cin >> n;
std::cout << "Numarul de coloane = "; std::cin >> m;
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++)
{
std::cout << "a[" << i << "," << j << "]= ";
std::cin >> mat[i][j];
}
}

void afisare(int mat[10][10], int n, int m)


{
for (int i = 0; i < n; i++)
{
for (int j = 0; j < m; j++)
std::cout << mat[i][j] << " ";
std::cout << std::endl;
}
}

Matrice patratica

void citire(int matrice[100][100]), int &dimensiune)


{
std::cout<<”introduceti numarul de linii/coloane”;
std::cin >> dimensiune;
for (int i = 0; i < dimensiune; i++)
for(int j=0;j<dimensiune;j++)
std::cin >> matrice[i][j];
}

void afisare(int dimensiune, int matrice[100][100])


{
for (int i = 0; i < dimensiune; i++)
{
for(int j=0; j< dimensiune ;j++)
std::cout << matrice[i][j] << " ";

std::cout << std::endl;


}
}

void produs(int mat1[10][10], int mat2[10][10], int matp[10][10], int n, int m, int p)
{

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


for (int k = 0; k < p; k++)
for (int j = 0; j < n; j++)
matp[i][k] += mat1[i][j] * mat2[j][k];
}

void rotire_90(int Mat[10][10], int n, int m, int Mat2[10][10])


{
for (int i = 1; i <= m; i++)
for (int j = 1; j <= n; j++)
Mat2[i][j] = Mat[j][m - i + 1];
}

void eliminare_diag_princ(int Mat[10][10], int n, int &m)


{
for (int i = 0; i < n - 1; i++)
for (int j = i; j < n; j++)
{
Mat[i][j] = Mat[i][j + 1];
}

m--;
}

void ordonare_elemente_pe_linii (int matrice[10][10], int n, int m, int linie)


{
for(linie =0; linie <n; linie++)
for (int i = 0; i < n - 1; i++)
for (int j = i + 1; j < m; j++)
if (matrice[linie][i] > matrice[linie][j])

{ int aux = matrice[linie][i];


matrice[linie][i] = matrice[linie][j];
matrice[linie][j] = aux;
}
}

Linie==0; f=========================================================================

int cautareBinara(int vector[], int dimensiune, int x)


{
int left = 0, right = dimensiune - 1, mid, sol = -1;
bool ok = 0;
while (left <= right && ok != 1)
{
mid = (left + right) / 2;
if (vector[mid] == x)
{
sol = mid;
break;
}
else
if (vector[mid] > x)
right = mid - 1;
else
left = mid + 1;
}
return sol;

if (cautareBinara(vector, n, x) != -1)

Inserare si stergere eficienta

void cautare_binara(int vector[], int dimensiune, int element_cautat,int &pozitie)

int inceput = 1, sfarsit = dimensiune;

if (element_cautat > vector[dimensiune])

pozitie = dimensiune + 1;

else if (element_cautat < vector[1])

pozitie = 1;

else while (inceput <= sfarsit)


{

int mijloc = (inceput + sfarsit) / 2;

if ((vector[mijloc] < element_cautat && vector[mijloc + 2] >


element_cautat)||(vector[mijloc]==element_cautat))

pozitie = mijloc + 1;

break;

else if (vector[mijloc] < element_cautat)

inceput = mijloc + 1;

else if (vector[mijloc] > element_cautat)

sfarsit = mijloc - 1;

void inserare_element(int vector[], int &dimensiune, int element)

int pozitie;

cautare_binara(vector, dimensiune, element, pozitie);

dimensiune++;

for (int index = dimensiune; index > pozitie; index--)

vector[index] = vector[index - 1];

vector[pozitie] = element;

void stergere_element(int vector[], int &dimensiune, int element)

int pozitie;

cautare_binara(vector, dimensiune, element, pozitie);

for (int index = pozitiepal; index < dimensiune; index++)

vector[index] = vector[index + 1];

dimensiune--;

}
Sortare prin insertie cu cautare binara
void sortare_inserare(int n, int v[])
{

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


{
int aux = v[j];
int i = j - 1;
while (aux < v[i] && i >= 0)
{
v[i + 1] = v[i];
i = i - 1;
}
v[i + 1] = aux;
}
}

QUICKSORT

void quickSort(int vector[], int left, int right)

int i = left, j = right;

int tmp;

int pivot = vector[(left + right) / 2];

while (i <= j)

while (vector[i] < pivot)

i++;

while (vector[j] > pivot)

j--;

if (i <= j)

tmp = vector[i];

vector[i] = vector[j];

vector[j] = tmp;

i++;

j--;

if (left < j)
quickSort(vector, left, j);

if (i < right)

quickSort(vector, i, right);

Sortare matrice

void sortMat(int mat[SIZE][SIZE], int n)

// temporary matrix of size n^2

int temp[n * n];

int k = 0;

// copy the elements of matrix one by one

// into temp[]

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

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

temp[k++] = mat[i][j];

// sort temp[]

sort(temp, temp + k);

// copy the elements of temp[] one by one

// in mat[][]

k = 0;

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

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

mat[i][j] = temp[k++];

void maximMatrice(int m[100][100], int lin, int col)

int max = 0, iMax = 0, jMax = 0;


for (int a = lin; a < lin + 3; a++)

for (int b = col; b < col + 3; b++)

if (m[lin][col] > max)

max = m[lin][col];

iMax = a;

jMax = b;

std::cout << "este " << max << " de pe pozitia [" << iMax << "][" << jMax << "]\n";

void interclasare(int Vector1[], int dimensiune1, int Vector2[], int dimensiune2, int Vector_ordonat[], int &k)

int i = 0, j = 0;

while (i < dimensiune1 && j < dimensiune2)

if (Vector1[i] < Vector2[j])

Vector_ordonat[k] = Vector1[i];

k++;

i++;

else

if (Vector1[i] == Vector2[j])

Vector_ordonat[k] = Vector2[j];

k++;

j++;

i++;

else
{

Vector_ordonat[k] = Vector2[j];

k++;

j++;

if (i <= dimensiune1)

for (int p = i; p < dimensiune1; p++)

Vector_ordonat[k] = Vector1[p];

k++;

if (j <= dimensiune2)

for (int p = j; p < dimensiune2; p++)

Vector_ordonat[k] = Vector2[p];

k++;

void Citire(int vector[], int &nr)


{
int elem, nr = 0, index = 0;
while(f >> elem)
{

vector[index] = elem;
index++;
nr++;
}
}

void afisare(int vector[], int nr)


{
for (int index = 0; index < nr; index++)
g << vector[index] << " ";
}
for ( int index = 0; index < nr-1 ;)
if (viteza[index] == viteza[index + 1])
{
int timp = 0;
int index2 = index;
while (viteza[index2] == viteza[index2 + 1])
{
timp++;
index2++;
}
if (timp >= 1)
{
index = index2;
g << "Viteza este constanta intre " << index << " si " <<
index + timp << '\n';
}
index++;
}

Вам также может понравиться