Для каждой из следующий функций:
std::pair<int, int> findMinElement(int arr[], int size) {
int minElement = arr[0];
int minIndex = 0;

for (int i = 1; i < size; i++) {
if (arr[i] < minElement) {
minElement = arr[i];
minIndex = i;
}
}

return std::pair<int, int>(minElement, minIndex);
}


int* bubbleSort(int arr[], int size) {
for (int i = 0; i < size - 1; i++) {
for (int j = 0; j < size - i - 1; j++) {
if (arr[j] > arr[j + 1]) {
int temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
}
}
}
return arr;
}

int binarySearch(int arr[], int size, int target) {
int left = 0;
int right = size - 1;

while (left <= right) {
int mid = left + (right - left) / 2;

if (arr[mid] == target) {
return mid;
}
else if (arr[mid] < target) {
left = mid + 1;
}
else {
right = mid - 1;
}
}

return -1;
}

int* findMinElement(int arr[][3], int rows, int cols) {
int minElement = arr[0][0];
int minRow = 0;
int minCol = 0;

for (int i = 0; i < rows; i++) {
for (int j = 0; j < cols; j++) {
if (arr[i][j] < minElement) {
minElement = arr[i][j];
minRow = i;
minCol = j;
}
}
}
return new int[3] {minElement, minRow, minCol};
}

int* reverseArray(int arr[], int size) {
int start = 0;
int end = size - 1;

while (start < end) {
int temp = arr[start];
arr[start] = arr[end];
arr[end] = temp;

start++;
end–;
}
return arr;
}

int* leftRotate(int arr[], int size, int positions) {
for (int i = 0; i < positions; i++) {
int temp = arr[0];

for (int j = 0; j < size - 1; j++) {
arr[j] = arr[j + 1];
}

arr[size - 1] = temp;
}
return arr;
}

int* replaceElements(int arr[], int size, int target, int replacement) {
for
(int i = 0; i < size; i++) {
if (arr[i] == target) {
arr[i] = replacement;
}
}
return arr;
}
Рассчитай следующие параметры:
Для вычисления параметров η2, η1, η2, η, N1, N2 и N используем следующие формулы:

η2 = Σ (количество входных параметров * количество выходных параметров)
η1 = Σ (количество операторов в каждой функции)
η2 = Σ (количество операндов в каждой функции)
η = η1 + η2
N1 = Σ (количество вхождений каждого оператора в каждой функции)
N2 = Σ (количество вхождений каждого операнда в каждой функции)
N = Σ N1 + Σ N2