После печати случайного двумерного массива мне нужно найти первый минимум и первый максимум в первой строке?

Question

Например, у нас есть random 5 x 5 array
1 5 9 4 2 <===== // необходимо найти минимальное и максимальное значения в этой строке. <br>6 4 3 7 9 ----------- // а затем поменять местами их столбцы индекса
9 4 6 2 5
2 7 8 5 9
4 1 9 7 7

ВВыше массива нам нужно посмотреть на первые row и найти min и max, а затем изменить их columns.Таким образом, минимальные и максимальные значения в первом ряду равны 1 и 9, и ответ должен быть
9 5 1 4 2
3 4 6 7 9
6 4 9 2 5
8 7 2 5 9
9 1 4 7 7
Поменяемые столбцы подсвечиваются.Я попытался решить эту проблему с помощью следующего кода.

#include <iostream>
#include <time.h>
using namespace std;

int main()
{
int array[5] = {0,0,0,0,0};
int max = array[0];
int min = array[0];
int indexOfMax = 0;
int indexOfMin = 0;
int n, m;
cout << "n = "; cin >> n;
cout << "m = "; cin >> m;

int **array = new int *[n]; // for the output of a random array
for(int i = 0; i < n; i++)
   array[i] = new int [m];

srand((unsigned int)time(NULL));   

for(int i = 0; i < n; i++){    // loop for the array
   for(int j = 0; j < m; j++){
       array[i][j] = rand() % 20;
       cout << array[i][j] << " ";
        if(array[i] > max)   // finding the max in first row
        {
           max = array[i];
           indexOfMax = i;
        }
        if(array[i] < min)  // finding the min in the first row
        {
        min = indexOfMin;
        indexOfMin = i;
        }
        cout << indexOfMin << " " << indexOfMax << endl; 
        }
    }
    cout << '\n';
}
return 0;
}

Итак, в первую очередь я получаю это main.cpp:16:11: error: conflicting declaration ‘int** array’.И тогда я хотел бы знать, как поменять местами столбцы min и max?

Answer 1

Вам не нужен дополнительный массив, который вы упомянули в коде.

Рабочее решение:

#include <iostream>
#include <time.h>
#include <limits.h>
using namespace std;

int main()
{
int max = INT_MIN;
int min = INT_MAX;
int indexOfFirstRowMax;
int indexOfFirstRowMin;
int n, m;
cout << "n = "; cin >> n;
cout << "m = "; cin >> m;

int **array = new int *[n]; // for the output of a random array
for(int i = 0; i < n; i++)
    array[i] = new int[m];

srand((unsigned int)time(NULL));   

for(int i = 0; i < n; i++)
{    
for(int j = 0; j < m; j++)
{
    array[i][j] = rand() % 20;
    cout << array[i][j] << " ";
    if(i==0)
    {
    if(array[i][j] > max)   // finding the max in first row
    {
       max = array[i][j];
       indexOfFirstRowMax = j;
    }
    if(array[i][j] < min)  // finding the min in the first row
    {
       min = array[i][j];
       indexOfFirstRowMin = j;
    }
    }
}
cout<<endl;
}
cout<<"indexOfFirstRowMin = "<<indexOfFirstRowMin<<endl;
cout<<"indexOfFirstRowMax = "<<indexOfFirstRowMax<<endl; 

for(int i=0; i<n; i++)
{
    int temp = array[i][indexOfFirstRowMin];
    array[i][indexOfFirstRowMin] = array[i][indexOfFirstRowMax];
    array[i][indexOfFirstRowMax] = temp;
}
cout<<"Output after interchanging the columns"<<endl;
for(int i=0;i<n;i++)
{
for(int j=0;j<m;j++)
{
    cout<<array[i][j]<<" ";
}
cout<<endl;
}
return 0;
}

Answer 2

Используя стандартные библиотеки, как предложено в моем комментарии, вы можете реализовать это примерно так:

#include <iostream>
#include <vector>
#include <iterator>
#include <random>
#include <algorithm>

int main()
{
    int n, m;

    std::cout << "n = ";
    std::cin >> n;

    std::cout << "m = ";
    std::cin >> m;

    // Creates a matrix of N x M elements
    std::vector<std::vector<int>> array(n, std::vector<int>(m));

    // Create a random-number generator for the range 1 to 20 (inclusive)
    std::random_device rd;
    std::mt19937 gen(rd());
    std::uniform_int_distribution<> dis(1, 20);

    // Generate random numbers filling our matrix
    for (auto& v : array)
    {
        std::generate(begin(v), end(v), [&]() { return dis(gen); });
    }

    // Print the matrix before swapping
    for (auto const& v : array)
    {
        std::copy(begin(v), end(v), std::ostream_iterator<int>(std::cout, " "));
        std::cout << '\n';
    }

    // Find the min/max of the first row in the matrix
    auto minmax_pair = std::minmax_element(begin(array[0]), end(array[0]));

    // From the pair of min/max iterators fetched above, get the indexes
    auto min_index = std::distance(begin(array[0]), minmax_pair.first);
    auto max_index = std::distance(begin(array[0]), minmax_pair.second);

    // Now swap the columns of the min and max
    for (auto& v : array)
    {
        std::swap(v[min_index], v[max_index]);
    }

    // Print the matrix after swapping
    std::cout << '\n';
    for (auto const& v : array)
    {
        std::copy(begin(v), end(v), std::ostream_iterator<int>(std::cout, " "));
        std::cout << '\n';
    }
}

Answer 3

#include <cstddef>   // std::size_t
#include <cstdlib>   // std::srand(), std::rand()
#include <ctime>     // std::time()
#include <utility>   // std::swap()
#include <iostream>  // std::cout, std::cin
#include <iomanip>   // std::setw()

int main()
{
    // seed the old, rusty, low entropy random number generator
    std::srand(static_cast<unsigned>(std::time(nullptr)));

    std::cout << "rows = ";
    std::size_t rows;  // name variables with actual names instead of letters
    std::cin >> rows;  // to make them less prone to confusions

    std::cout << "columns = ";
    std::size_t columns;  // declare variables as close to where they're used
    std::cin >> columns;  // as possible

    int **array = new int *[rows];  // allocate the row pointers of our jagged array
    for (size_t row{}; row < rows; ++row) {
        array[row] = new int[columns];
        for (size_t col{}; col < columns; ++col) {
            array[row][col] = rand() % 20;  // fill the array with random numbers 0...19
            std::cout << std::setw(2) << array[row][col] << "  ";  // and also print them
        }
        std::cout.put('\n');  // add a newline after every row
    }
    std::cout.put('\n');

    std::size_t max_index{};
    std::size_t min_index{};

    // find the indexes of the maximum and the minimum in the 1st row:
    // As suggested by Some programmer dude in the comments you could
    // (and should) use std::minmax_element() ... but i guess thats some
    // assignment that wants you to do it on foot.
    for (size_t col{ 1 }; col < columns; ++col) {
        if (array[0][col] > array[0][max_index])
            max_index = col;
        if (array[0][col] < array[0][min_index])
            min_index = col;
    }

    // print them
    std::cout << "min = " << array[0][min_index] << ", max = " << array[0][max_index] << '\n';

    // swap the column min_index with the column max_index:
    for (size_t row{}; row < rows; ++row)
        std::swap(array[row][min_index], array[row][max_index]);

    // print it again:
    for (size_t row{}; row < rows; ++row) {
        for (size_t col{}; col < columns; ++col)
            std::cout << std::setw(2) << array[row][col] << "  ";
        delete[] array[row];  // and in the process clean up the mess we made
        std::cout.put('\n');
    }
    std::cout.put('\n');

    delete[] array;  // delete array of row pointers
}