#include <iostream>
#include <ctime>
#include <cstdlib>
#include <iomanip>

#define N 4
#define K 4

void fillArray(int array[][K], int howManyRows, int maxValue, int minValue)
{
    for (int rows = 0; rows < howManyRows; rows++)
    {
        for (int columns = 0; columns < K; columns++)
            array[rows][columns] = std::rand() % (maxValue - minValue + 1) + minValue;
    }
}

void printArray(int array[][K], int howManyRows)
{
    for (int rows = 0; rows < howManyRows; rows++)
    {
        for (int columns = 0; columns < K; columns++)
            std::cout << std::setw(5) << array[rows][columns] << " ";

        std::cout << std::endl;
    }
}

bool meanOfOddNumber (int array[][K], int howManyRows, double &meanOfOdds)
{
    int sum = 0;
    int howManyOdds = 0;
    meanOfOdds = 0;
    for (int rows = 0; rows < howManyRows; rows++)
    {
        for (int columns = 0; columns < K; columns++)
            {
                if (array[rows][columns] % 2 != 0)
                {
                    sum = sum + array[rows][columns];
                    howManyOdds++;
                }
            }
    }

    if (howManyOdds == 0) return false;
    else
    {
        meanOfOdds = static_cast<double>(sum)/howManyOdds;
        return true;
    }
}

void fillArrayD(int arrayToBeFiled[], int arrayWithValues[][K], int howManyRows)
{
        int oneDim = 0;
        int sum = 0;
        for (int rows = 0; rows < howManyRows; rows++)
        {
            for(int columns = 0; columns < K; columns++)
            {
                sum = sum + arrayWithValues[rows][columns];
            }
            arrayToBeFiled[oneDim] = sum;
            oneDim++;
            sum = 0;
        }
}

void fillArrayC(int arrayToBeFilled[], int arrayWithValues[][K], int howManyRows)
{
    int oneDim = 0;
    int biggestValue = arrayWithValues[0][0];

    for (int rows = 0; rows < howManyRows; rows++)
    {
        for(int columns = 0; columns < K; columns++)
            {
                if (biggestValue <= arrayWithValues[rows][columns])
                    biggestValue = arrayWithValues[rows][columns];
            }

            arrayToBeFilled[oneDim] = biggestValue;
            oneDim++;
            biggestValue = arrayWithValues[rows + 1][0];
        }
}

void quickSort(int array[][K], int left, int right, int columns)
{
    int i = left;
    int j = right;
    int x = array[(left + right) / 2][columns];

    do
    {
        while (array[i][columns] < x)
            i++;

        while (array[j][columns] > x)
            j--;

        if (i <= j)
        {
            int temp = array[i][columns];
            array[i][columns] = array[j][columns];
            array[j][columns] = temp;
            i++;
            j--;
        }

    } while (i <= j);

    if (left < j) quickSort(array, left, j, columns);
    if (right > i) quickSort(array, i, right, columns);
}

void replaceRows(int A[][K], int row1, int row2)

    for (int columns = 0; columns < K; columns++)
    {
        int temp = array[row1][columns];
        array[row1][columns] = array[row2][columns];
        array[row2][columns] = temp;
    }
int main()
{
    //wywolanie funkcji srand
    std::srand(time(0));

    //zad 1
    int A[N][K], B[N][K], p, k;

    std::cout << "Podaj poczatek przedzialu pseudolosowego (p): ";
    std::cin >> p;

    std::cout << "Podaj koniec przedzialu pseudolosowego (k): ";
    std::cin >> k;

    while (k <= p)
    {
        std::cout << "Koniec przedzialu musi byc wiekszy od poczatku! Sprobuj ponownie: ";
        std::cin >> k;
    }

    fillArray(A, N, k, p);
    fillArray(B, N, k, p);

    //zad 2
    std::cout << "Tablica A: " << std::endl;
    printArray(A, N);

    std::cout << "Tablica B: " << std::endl;
    printArray(B, N);

    //zad 3
    double meanA, meanB;
    bool oddsA = meanOfOddNumber(A, N, meanA);
    bool oddsB = meanOfOddNumber(B, N, meanB);

    if (oddsA == false) std::cout << "W tablicy A brak liczb nieparzystych!" << std::endl;
    else std::cout << "Srednia liczb nieparzystych w tablicy A to " << meanA << "." << std::endl;

    if (oddsB == false) std::cout << "W tablicy B brak liczb nieparzystych!" << std::endl;
    else std::cout << "Srednia liczb nieparzystych w tablicy B to " << meanB << "." << std::endl;

    //zad 4
    int D[N] = { 0 };
    fillArrayD(D, A, N);

    std::cout << "Tablica D: " << std::endl;

    for (int i = 0; i < N; i++)
        std::cout << std::setw(2) << D[i] << " ";

    std::cout << std::endl;

    //zad 5
    int C[N] = { 0 };

    fillArrayC(C, A, N);

    std::cout << "Tablica C: " << std::endl;

    for (int i = 0; i < N; i++)
        std::cout << std::setw(2) << C[i] << " ";

    std::cout << std::endl;

    //zad 6
    for (int columns = 0; columns < K; columns++)
        quickSort(B, 0, (N - 1), columns);

    std::cout << "Tablica B: " << std::endl;
    printArray(B, N);

    //zad 7

    int row1, row2;

    std::cout << "Podaj wiersze w tablicy A do zamiany. Wiersz pierwszy: ";
    std::cin >> row1;

    std::cout << "Wiersz drugi: ";
    std::cin >> row2;

    replaceRows(A, row1, row2);

    std::cout << "Tablica B: " << std::endl;
    printArray(B, N);

}