#include <iostream>
 
int main()
{
    const unsigned int ARR_SIZE = 5;
    int arr[ARR_SIZE] = { 1, 4, 8, 8, 2 };
    for ( unsigned int i = 0; i < ARR_SIZE; ++i )
        std::cout << arr[i] << " ";
}

#include <iostream>
 
int main()
{
    int arr[] { 1, 4, 8, 8, 2 };
    for ( const auto elem : arr )
        std::cout << elem << " ";
}

#include <iostream>
 
void show( int * arr, const unsigned int arr_size )
{
    for ( unsigned int i = 0; i < arr_size; ++i )
        std::cout << arr[i] << " ";
    std::cout << "\n";
}
 
int main()
{
    const unsigned int ARR_SIZE = 5;
    int arr[ARR_SIZE] = { 1, 4, 8, 8, 2 };
    show( arr, ARR_SIZE );
}

#include <iostream>
 
template <class T>
void show( const T & arr )
{
    for ( const auto & elem : arr )
        std::cout << elem << " ";
    std::cout << "\n";
}
 
int main()
{
    int arr[] { 1, 4, 8, 8, 2 };
    show( arr );
}

#include <iostream>
 
void show( int * arr_begin, int * arr_end )
{
    for ( int * iter = arr_begin; iter != arr_end; ++iter )
        std::cout << *iter << " ";
    std::cout << "\n";
}
 
int main()
{
    const unsigned int ARR_SIZE = 5;
    int arr[ARR_SIZE] = { 1, 4, 8, 8, 2 };
    show( arr, arr + ARR_SIZE );
}

#include <iostream>
#include <algorithm>
#include <iterator>
 
int main()
{
    int ar[] { 1, 4, 8, 8, 2 };
    std::copy( std::begin( ar ), std::end( ar ), std::ostream_iterator<int>( std::cout, " " ) );
}

#include <iostream>
#include <algorithm>
#include <numeric>
#include <iterator>
 
int main()
{
    int arr[20];
    std::iota(std::begin(arr), std::end(arr), 10);
    std::ranges::copy(arr, std::ostream_iterator<int>(std::cout, " "));
    std::cout << '\n';
}

#include <iostream>
#include <algorithm>
 
void show( int * arr_begin, int * arr_end )
{
    std::for_each( arr_begin, arr_end, []( int i ){ std::cout << i << " "; } );
    std::cout << "\n";
}
 
int main()
{
    const unsigned int ARR_SIZE = 5;
    int arr[ARR_SIZE] = { 1, 4, 8, 8, 2 };
    show( arr, arr + ARR_SIZE );
}

#include <iostream>
#include <algorithm>
 
void show(const auto &arr)
{
    std::ranges::for_each(arr, [](int i) { std::cout << i << ' '; });
    std::cout << '\n';
}
 
int main()
{
    int arr[] {1, 4, 8, 8, 2};
    show(arr);
}

#include "arrays_functions.h"
#include <iostream>
#include <cstdlib>
 
 
int main()
{
    size_t row_size;
    size_t col_size;
 
    get_number_from_user( "Enter number of rows: ", row_size );
    get_number_from_user( "Enter number of columns: ", col_size );
 
    int ** matrix = create( row_size, col_size );
 
    const size_t from_num = 10;
    const size_t to_num = 99;
 
    fill_rand( matrix, row_size, col_size, from_num, to_num );
    show( matrix, row_size, col_size );
 
    size_t arr_size;
    get_number_from_user( "Enter size of array: ", arr_size );
 
    int * array = create( arr_size );
 
    const size_t begin_row_index = 0;
    const size_t begin_col_index = 0;
 
    fill_array_from_part_of_matrix
        (
            array,
            arr_size,
            matrix,
            row_size,
            col_size,
            begin_row_index,
            begin_col_index
        );
    show( array, arr_size );
 
    std::cout
        << "Arithmetic mean of array's values is: "
        << calc_arithm_mean( array, arr_size );
 
    destroy( matrix, row_size );
    destroy( array );
 
    return 0;
}

#ifndef ARRAYS_FUNCTIONS_H
#define ARRAYS_FUNCTIONS_H
 
#include <cstdlib>
#include <string>
 
// Function prototypes to handle 1-dimensional arrays:
//--------------------------------------------------
int * create
    (
        const size_t arr_size
    );
 
//--------------------------------------------------
void destroy
    (
        int * array
    );
 
//--------------------------------------------------
void fill_rand
    (
        int * array,
        const size_t arr_size,
        const int from_num,
        const int to_num
    );
 
//--------------------------------------------------
void show
    (
        int * array,
        const size_t arr_size
    );
 
//--------------------------------------------------
int calc_sum_of_values
    (
        int * array,
        const size_t arr_size
    );
 
//--------------------------------------------------
int calc_arithm_mean
    (
        int * array,
        const size_t arr_size
    );
 
// Function prototypes to handle matrices:
//--------------------------------------------------
int ** create
    (
        const size_t row,
        const size_t col
    );
 
 
//--------------------------------------------------
void destroy
    (
        int ** matrix,
        const size_t row
    );
 
//--------------------------------------------------
void fill_rand
    (
        int ** matrix,
        const size_t row,
        const size_t col,
        const int from_num,
        const int to_num
    );
 
//--------------------------------------------------
void show
    (
        int ** matrix,
        const size_t row,
        const size_t col
    );
 
//--------------------------------------------------
int calc_sum_of_values
    (
        int ** matrix,
        const size_t row,
        const size_t col
    );
 
//--------------------------------------------------
int calc_arithm_mean
    (
        int ** matrix,
        const size_t row,
        const size_t col
    );
 
// Other function prototypes:
//--------------------------------------------------
void get_number_from_user
    (
        std::string promt,
        size_t & number
    );
 
//--------------------------------------------------
void fill_array_from_part_of_matrix
    (
        int * array,
        const size_t arr_size,
        int ** matrix,
        const size_t row,
        const size_t col,
        const size_t begin_row_index,
        const size_t begin_col_index
    );
 
#endif // ARRAYS_FUNCTIONS_H

#include "arrays_functions.h"
#include <iostream>
#include <ctime>
 
// Function implementations to handle 1-dimensional arrays:
//--------------------------------------------------
int * create
    (
        const size_t arr_size
    )
{
    int * array = new int[arr_size];
    return array;
}
 
//--------------------------------------------------
void destroy
    (
        int * array
    )
{
    delete [] array;
}
 
//--------------------------------------------------
void fill_rand
    (
        int * array,
        const size_t arr_size,
        const int from_num,
        const int to_num
    )
{
    static bool first_time_in_this_program = true;
    if ( first_time_in_this_program )
    {
        srand( time( NULL ) );
        first_time_in_this_program = false;
    }
 
    for ( size_t i = 0; i < arr_size; ++i )
        array[i] = rand() % (to_num - from_num) + from_num;
}
 
//--------------------------------------------------
void show
    (
        int * array,
        const size_t arr_size
    )
{
    std::cout << "\n";
    for ( size_t i = 0; i < arr_size; ++i )
    {
        std::cout << array[i] << " ";
    }
    std::cout << "\n\n";
}
 
//--------------------------------------------------
int calc_sum_of_values
    (
        int * array,
        const size_t arr_size
    )
{
    int sum = 0;
    for ( size_t i = 0; i < arr_size; ++i )
        sum += array[i];
 
    return sum;
}
 
//--------------------------------------------------
int calc_arithm_mean
    (
        int * array,
        const size_t arr_size
    )
{
    int sum = calc_sum_of_values( array, arr_size );
    return sum / arr_size;
}
 
// Function implementations to handle matrices:
//--------------------------------------------------
int ** create
    (
        const size_t row,
        const size_t col
    )
{
    int ** matrix = new int * [row];
    for ( size_t i = 0; i < row; ++i )
        matrix[i] = new int[col];
 
    return matrix;
}
 
//--------------------------------------------------
void destroy
    (
        int ** matrix,
        const size_t row
    )
{
    for ( size_t i = 0; i < row; ++i )
        delete [] matrix[i];
    delete [] matrix;
}
 
//--------------------------------------------------
void fill_rand
    (
        int ** matrix,
        const size_t row,
        const size_t col,
        const int from_num,
        const int to_num
    )
{
    static bool first_time_in_this_program = true;
    if ( first_time_in_this_program )
    {
        srand( time( NULL ) );
        first_time_in_this_program = false;
    }
 
    for ( size_t i = 0; i < row; ++i )
        for ( size_t j = 0; j < col; ++j )
            matrix[i][j] = rand() % (to_num - from_num) + from_num;
}
 
//--------------------------------------------------
void show
    (
        int ** matrix,
        const size_t row,
        const size_t col
    )
{
    std::cout << "\n";
    for ( size_t i = 0; i < row; ++i )
    {
        for ( size_t j = 0; j < col; ++j )
        {
            std::cout << matrix[i][j] << " ";
        }
        std::cout << "\n";
    }
    std::cout << "\n";
}
 
//--------------------------------------------------
int calc_sum_of_values
    (
        int ** matrix,
        const size_t row,
        const size_t col
    )
{
    int sum = 0;
    for ( size_t i = 0; i < row; ++i )
        for ( size_t j = 0; j < col; ++j )
            sum += matrix[i][j];
 
    return sum;
}
 
//--------------------------------------------------
int calc_arithm_mean
    (
        int ** matrix,
        const size_t row,
        const size_t col
    )
{
    int sum = calc_sum_of_values( matrix, row, col );
    return sum / (row * col);
}
 
// Other function implementations:
//--------------------------------------------------
void get_number_from_user
    (
        std::string promt,
        size_t & number
    )
{
    std::cout << promt;
    std::cin >> number;
}
 
//--------------------------------------------------
void fill_array_from_part_of_matrix
    (
        int * array,
        const size_t arr_size,
        int ** matrix,
        const size_t row,
        const size_t col,
        const size_t begin_row_index,
        const size_t begin_col_index
    )
{
    for ( size_t i = begin_row_index, k = 0; i < row; ++i )
    {
        for
            (
                size_t j = begin_col_index;
                j < col && k < arr_size;
                ++j, ++k
            )
        {
            array[k] = matrix[i][j];
        }
    }
}

// requirements: compiler that supports C++11
 
#ifndef MATRIX_H
#define MATRIX_H
 
#include <iostream>
 
typedef double Item;
 
class Matrix
{
private:
    int m_row;
    int m_col;
    Item ** matrix;
 
public:
    Matrix(int row, int col);
    explicit Matrix(int col);
    Matrix(const Matrix & m);
    ~Matrix();
 
    void reset();
    void fill_rand(Item fromNum, Item toNum);
    void fill_by_user();
    Item find_min_value();
    Item find_max_value();
    Item find_sum();
    Item find_avg_value();
 
    int count_value_in_row(const Item chosen_value, const int chosen_row);
 
    Matrix & operator=(const Matrix & m);
    Matrix operator*(const Matrix & m);
    friend std::ostream & operator<<(std::ostream & os, const Matrix & m);
};
 
#endif // MATRIX_H

#include "Matrix.h"
#include <random>
#include <ctime>
#include <iomanip>
 
Matrix::Matrix(int row, int col)
{
    m_row = row;
    m_col = col;
 
    matrix = new Item * [m_row];
    for (int i = 0; i < m_row; ++i)
        matrix[i] = new Item[m_col];
}
 
Matrix::Matrix(int col)
{
    m_row = 1;
    m_col = col;
 
    matrix = new Item * [m_row];
    matrix[0] = new Item[m_col];
}
 
Matrix::Matrix(const Matrix & m)
{
    m_row = m.m_row;
    m_col = m.m_col;
 
    matrix = new Item * [m_row];
    for (int i = 0; i < m_row; ++i)
        matrix[i] = new Item[m_col];
 
    for (int i = 0; i < m_row; ++i)
        for (int j = 0; j < m_col; ++j)
            matrix[i][j] = m.matrix[i][j];
}
 
Matrix::~Matrix()
{
    for (int i = 0; i < m_row; ++i)
        delete [] matrix[i];
    delete [] matrix;
}
 
void Matrix::reset()
{
    for (int i = 0; i < m_row; ++i)
        for (int j = 0; j < m_col; ++j)
            matrix[i][j] = 0;
}
 
void Matrix::fill_rand(Item fromNum, Item toNum)
{
    std::mt19937 gen(time(0));
    std::uniform_real_distribution<double> urd(fromNum, toNum);
    for (int i = 0; i < m_row; ++i)
        for (int j = 0; j < m_col; ++j)
            matrix[i][j] = urd(gen);
}
 
void Matrix::fill_by_user()
{
    for (int i = 0; i < m_row; ++i)
        for (int j = 0; j < m_col; ++j)
        {
            std::cout << "\nEnter a value of the element matrix["
                      << i <<"][" << j << "]: ";
            std::cin >> matrix[i][j];
        }
}
 
Item Matrix::find_min_value()
{
    Item min_value = matrix[0][0];
    for (int i = 0; i < m_row; ++i)
        for (int j = 0; j < m_col; ++j)
            if (min_value > matrix[i][j])
                min_value = matrix[i][j];
    return min_value;
}
 
Item Matrix::find_max_value()
{
    Item max_value = matrix[0][0];
    for (int i = 0; i < m_row; ++i)
        for (int j = 0; j < m_col; ++j)
            if (max_value < matrix[i][j])
                max_value = matrix[i][j];
    return max_value;
}
 
Item Matrix::find_sum()
{
    Item sum = 0;
    for (int i = 0; i < m_row; ++i)
        for (int j = 0; j < m_col; ++j)
            sum += matrix[i][j];
    return sum;    
}
 
Item Matrix::find_avg_value()
{
    return find_sum() / (m_row * m_col);
}
 
int Matrix::count_value_in_row(const Item chosen_value, const int chosen_row)
{
    int counter = 0;
    for (int j = 0; j < m_col; ++j)
        if (matrix[chosen_row][j] == chosen_value)
            counter++;
    return counter;
}
 
Matrix & Matrix::operator=(const Matrix & m)
{
    if (this != &m)
    {
        for (int i = 0; i < m_row; ++i)
            delete [] matrix[i];
        delete [] matrix;
 
        m_row = m.m_row;
        m_col = m.m_col;
 
        matrix = new Item * [m_row];
        for (int i = 0; i < m_row; ++i)
            matrix[i] = new Item[m_col];
 
        for (int i = 0; i < m_row; ++i)
            for (int j = 0; j < m_col; ++j)
                matrix[i][j] = m.matrix[i][j];
    }
 
    return *this;
}
 
Matrix Matrix::operator*(const Matrix & m)
{
    Matrix res(m_row, m.m_col);
    res.reset();
 
    if (m_col == m.m_row)
    {
        for (int i = 0; i < res.m_row; ++i)
            for (int j = 0; j < res.m_col; ++j)
                for (int k = 0; k < m_row; ++k)
                    res.matrix[i][j] += matrix[i][k] * m.matrix[k][j];
    }    
    else
        std::cout << "\nIncorrect arguments in matrices multiplying.\n";
 
    return res;
}
 
std::ostream & operator<<(std::ostream & os, const Matrix & m)
{
    for (int i = 0; i < m.m_row; ++i)
    {
        for (int j = 0; j < m.m_col; ++j)
            os << std::setprecision(3) << m.matrix[i][j] << "\t";
        os << "\n";
    }
 
    return os;
}

#include <iostream>
#include "Matrix.h"
 
int main()
{
    const int rsize1 = 3;
    const int csize1 = 4;
    Matrix matrix1(rsize1, csize1);
    matrix1.fill_rand(0.11, 9.99);
 
    const int rsize2 = 4;
    const int csize2 = 5;
    Matrix matrix2(rsize2, csize2);
    matrix2.fill_rand(0, 9);
    std::cout << "\nThis is the 1st matrix:\n" << matrix1;
 
    std::cout << "\nMaximal element in this matrix is: "
              << matrix1.find_max_value();
    std::cout << "\nMinimal element in this matrix is: "
              << matrix1.find_min_value();
    std::cout << "\nTotal amount of all elements in this matrix is: "
              << matrix1.find_sum();
    std::cout << "\nAverage value in this matrix is: "
              << matrix1.find_avg_value() << "\n";
 
    std::cout << "\nThis is the 2nd matrix:\n" << matrix2;
 
    std::cout << "\nMatrices multyplying: \n" << matrix1 * matrix2;
 
    typedef Matrix Arr;
 
    Arr arr1(csize1);
    arr1.fill_rand(0, 9);
    std::cout << "\nAnd now we'll create the simple array:\n" << arr1;
    std::cout << "\nTotal amount of all elements in this array is: "
              << arr1.find_sum();
 
    return 0;
}