-----------------------------------------------------------------------------------

-----------

Д З В Ы П О Л Н И Л

Б А Б У Р О В И В А Н

-----------------------------------------------------------------------------------
-----------

-----------------------------------------------------------------------------------
-----------

З А Д А Н И Е 1

int** createArr2D(int rows, int cols) { // создание двумерного динамического

массива - int
int** mas = new int* [rows];
for (int r = 0; r < rows; r++)
mas[r] = new int[cols] {0};
return mas;
}
double** createArr2Ddouble(double rows, double cols) { // создание двумерного
динамического массива - double
double** mas = new double* [rows];
for (int r = 0; r < rows; r++)
mas[r] = new double[cols] {0};
return mas;
}
char** createArr2Dchar(int rows, int cols) { // создание двумерного динамического
массива - char
char** mas = new char* [rows];
for (int r = 0; r < rows; r++)
mas[r] = new char[cols] {0};
return mas;
}
void SetRndArray2D(int** arr, int n, int m, int a = 1, int b = 9) // заполнение
двумерного динамического массива - int
{
 for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++)
arr[i][j] = a + rand() % (b - a + 1);
}
void SetRndArray2Ddouble(double** arr, int n, int m, int a = 1, int b = 9) //
заполнение двумерного динамического массива - double
{
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++)
arr[i][j] = a + rand() % (b - a + 1) / static_cast<double>(rand() % 10
+ 1);
}
void SetRndArray2Dchar(char** arr, int n, int m) // заполнение двумерного
динамического массива - char
{
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++)
arr[i][j] = 97 + rand() % 26;
}
void PrintArray2D(int** arr, int n, int m) // вывод двумерного динамического
массива - int
{
for (int i = 0; i < n; i++)
{
for (int j = 0; j < m; j++)
cout << arr[i][j] << "\t";
cout << endl;
}
}
void PrintArray2Ddouble(double** arr, int n, int m) // вывод двумерного
динамического массива - double
{
for (int i = 0; i < n; i++)
{
for (int j = 0; j < m; j++)
cout << arr[i][j] << "\t";
cout << endl;
}
}
void PrintArray2Dchar(char** arr, int n, int m) // вывод двумерного динамического
массива - char
{
for (int i = 0; i < n; i++)
{
for (int j = 0; j < m; j++)
cout << arr[i][j] << "\t";
cout << endl;
}
}
void SortingArray2D(int** arr, int n, int m) // сортировка двумерного динамического
массива - int
{
for (int i = 0; i < n; i++)
{
for (int j = 0; j < m - 1; j++)
{
int index = j;
int minElement = arr[i][j];
for (int p = j; p < m; p++)
 {
if (minElement > arr[i][p])
{
index = p;
minElement = arr[i][p];
}
}
swap(arr[i][j], arr[i][index]);
}
}
}
void SortingArray2Ddouble(double** arr, int n, int m) // сортировка двумерного
динамического массива - double
{
for (int i = 0; i < n; i++)
{
for (int j = 0; j < m - 1; j++)
{
int index = j;
double minElement = arr[i][j];
for (int p = j; p < m; p++)
{
if (minElement > arr[i][p])
{
index = p;
minElement = arr[i][p];
}
}
swap(arr[i][j], arr[i][index]);
}
}
}
void SortingArray2Dchar(char** arr, int n, int m) // сортировка двумерного
динамического массива - char
{
for (int i = 0; i < n; i++)
{
for (int j = 0; j < m - 1; j++)
{
int index = j;
int minElement = arr[i][j];
for (int p = j; p < m; p++)
{
if (minElement > arr[i][p])
{
index = p;
minElement = arr[i][p];
}
}
swap(arr[i][j], arr[i][index]);
}
}
}
int MinElOnTheMainDiagonalArray2D(int** arr, int n) // определение минимального
элемента на главной диагонали матрицы - int
{
int min = arr[0][0];
for (int i = 1; i < n; i++)
if (min > arr[i][i]) min = arr[i][i];
 return min;
}
double MinElOnTheMainDiagonalArray2Ddouble(double** arr, int n) // определение
минимального элемента на главной диагонали матрицы - double
{
double min = arr[0][0];
for (int i = 1; i < n; i++)
if (min > arr[i][i]) min = arr[i][i];
return min;
}
char MinElOnTheMainDiagonalArray2Dchar(char** arr, int n) // определение
минимального элемента на главной диагонали матрицы - char
{
int min = arr[0][0];
for (int i = 1; i < n; i++)
if (min > arr[i][i]) min = arr[i][i];
return min;
}
int MaxElOnTheMainDiagonalArray2D(int** arr, int n) // определение максимального
элемента на главной диагонали матрицы - int
{
int max = arr[0][0];
for (int i = 1; i < n; i++)
if (max < arr[i][i]) max = arr[i][i];
return max;
}
double MaxElOnTheMainDiagonalArray2Ddouble(double** arr, int n) // определение
максимального элемента на главной диагонали матрицы - double
{
double max = arr[0][0];
for (int i = 1; i < n; i++)
if (max < arr[i][i]) max = arr[i][i];
return max;
}
char MaxElOnTheMainDiagonalArray2Dchar(char** arr, int n) // определение
максимального элемента на главной диагонали матрицы - char
{
int max = arr[0][0];
for (int i = 1; i < n; i++)
if (max < arr[i][i]) max = arr[i][i];
return max;
}
void DeleteArray2D(int** arr, int n) // удаление двумерного динамического массива -
int
{
for (int i = 0; i < n; i++)
delete[] arr[i];
delete[] arr;
}
void DeleteArray2Ddouble(double** arr, int n) // удаление двумерного динамического
массива - double
{
for (int i = 0; i < n; i++)
delete[] arr[i];
delete[] arr;
}
void DeleteArray2Dchar(char** arr, int n) // удаление двумерного динамического
массива - char
{
 for (int i = 0; i < n; i++)
delete[] arr[i];
delete[] arr;
}
int main()
{
// char работает
int n = 4, m = n;
char** arr = createArr2Dchar(n, m);
srand(time(0));
SetRndArray2Dchar(arr, n, m);
cout << "Source array:\n";
PrintArray2Dchar(arr, n, m);
SortingArray2Dchar(arr, n, m);
cout << "Sorted array:\n";
PrintArray2Dchar(arr, n, m);
cout << "Minimal element on the main diagonal of the matrix: " <<
MinElOnTheMainDiagonalArray2Dchar(arr, n) << endl;
cout << "Maximum element on the main diagonal of the matrix: " <<
MaxElOnTheMainDiagonalArray2Dchar(arr, n) << endl;
DeleteArray2Dchar(arr, n);

-----------------------------------------------------------------------------------
-----------

-----------------------------------------------------------------------------------
-----------

З А Д А Н И Е 2

int gcd(int a, int b) {

if (b == 0)
return a;
else
return gcd(b, a % b);
}

-----------------------------------------------------------------------------------
-----------
-----------------------------------------------------------------------------------
-----------

З А Д А Н И Е 3

struct game
{
int q[4];
int a[4];

void init()
{
for (int i = 0; i < 4; ++i)
{
q[i] = rand() % 10;
}
}

void proceed(int n)
{
++n;
int num;

std::cout << "\nInput num: ";

std::cin >> num;

if (check(num))
{
std::cout << "\n******\n\nOK, attempts = " << n;

char x;
do
{
std::cout << "\n\nAnother run? (y/n) ";
std::cin >> x;
} while (x != 'y' && x != 'n');

if (x == 'y') run();

}
else {
proceed(n);
}
}

bool check(int num)

{
for (int i = 3; i >= 0; --i)
{
a[i] = num % 10;
 num /= 10;
}

int b = 0;
int c = 0;
bool c_check[4] = { false };

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

{
if (q[i] == a[i])
{
++b;
c_check[i] = true;
}
}

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

{
for (int j = 0; j < 4; ++j)
{
if (i == j || c_check[j]) continue;
if (a[i] == q[j])
{
++c;
c_check[j] = true;
break;
}
}
}

if (b == 4) return true;

std::cout << "\n b = " << b << " c = " << c << "\
n------------------------";

return false;
}

void run()
{
init();
proceed(0);
}
};

int main()
{
srand(time(0));

game A;

A.run();

system("pause");
return 0;
}
-----------------------------------------------------------------------------------
-----------