Как найти минимальный элемент главной диагонали

// main_secondary_diagonal.cpp: определяет точку входа для консольного приложения.

#include "stdafx.h"
#include <iostream>
#include <iomanip>
using namespace std;

int main(int argc, char* argv[])
{
    srand(time(NULL));
    int size_array; // размер квадратной матрицы
    setlocale(LC_ALL, "rus");

    cout << "Введите размер квадратной матрицы: ";
    cin >> size_array;

    // динамическое создание двумерного массива
    int **arrayPtr = new int* [size_array];
    for (int count = 0; count < size_array; count++)
        arrayPtr[count] = new int [size_array];

    for (int counter_rows = 0; counter_rows < size_array; counter_rows++)
    {
        for (int counter_columns = 0; counter_columns < size_array; counter_columns++)
        {
            arrayPtr[counter_rows][counter_columns] = rand() % 100; // заполнение массива случайными числами
            cout << setw(2) << arrayPtr[counter_rows][counter_columns] << "  "; // вывод на экран двумерного массива
        }
        cout << endl;
    }
    cout << endl;

    int min = arrayPtr[1][0], // минимальный елемент массива, ниже главной диагонали
        row_min = 1,          // номер строки минимального элемента
        column_min = 0;       // номер столбца минимального элемента

    // поиск минимального элемента в массиве, ниже главной диагонали
    for (int counter_rows = 1; counter_rows < size_array; counter_rows++)
    {
        for (int counter_columns = 0; counter_columns < counter_rows ; counter_columns++)
        {
            if ( arrayPtr[counter_rows][counter_columns] < min )
            {
                min = arrayPtr[counter_rows][counter_columns];
                row_min = counter_rows;
                column_min = counter_columns;
            }
        }
    }

    cout << "min" << "[" << (row_min + 1) << "][" << (column_min + 1) << "]"  << " = " << min << endl; 

    int max = arrayPtr[0][0], // максимальный элемнет массива, выше побочной диагонали
        row_max = 0,              // номер строки максимального элемента
        column_max = 0;           // номер столбца максимального элемента

    for (int counter_rows = 0; counter_rows < size_array - 1; counter_rows++)
    {
        for (int counter_columns = 0; counter_columns < (size_array - counter_rows - 1); counter_columns++)
        {
            if ( arrayPtr[counter_rows][counter_columns] > max )
            {
                max = arrayPtr[counter_rows][counter_columns];
                row_max = counter_rows;
                column_max = counter_columns;
            }
        }
    }

    cout << "max" << "[" << (row_max + 1) << "][" << (column_max + 1) << "]"  << " = " << max << endl; 

    //////////////////перестановка элементов////////////////////////////////////////////////

    arrayPtr[row_min][column_min] = max;
    arrayPtr[row_max][column_max] = min;

    ////////////////////////////////////////////////////////////////////////////////////////

    cout << "nМассив после перестановки максимального и минимального элементов:n";

    for (int counter_rows = 0; counter_rows < size_array; counter_rows++)
    {
        for (int counter_columns = 0; counter_columns < size_array; counter_columns++)
        {
          cout << setw(2) << arrayPtr[counter_rows][counter_columns] << "  "; // вывод на экран двумерного массива
        }
        cout << endl;
    }
    cout << endl;

    cout << "min" << "[" << (row_max + 1) << "][" << (column_max + 1) << "]"  << " = " << min << endl; 
    cout << "max" << "[" << (row_min + 1) << "][" << (column_min + 1) << "]"  << " = " << max << endl; 

    // удаление двумерного динамического массива
    for (int count = 0; count < size_array; count++)
        delete []arrayPtr[count];

    system("pause");
    return 0;
}

Результат работы программы показан ниже:

Вопрос от пользователя:

Питон. Дана квадратная матрица A порядка M. Найти минимальный элемент для
каждой ее диагонали, параллельной главной (начиная с одноэлементной
диагонали A1,M).

Подождите!

Ответ нейросети:

def min_parallel_diag(A):

    result = [] #список для хранения минимальных элементов    

    for i in range(M-1): #начинаем с одноэлементной диагонали A1,M

        diag = [] #список для хранения элементов диагонали

        for j in range(M-i): #перебираем элементы диагонали

            diag.append(A[j+i][j]) #добавляем элементы диагонали в список

        result.append(min(diag)) #находим минимальный элемент и добавляем в список результатов

    return result

A = [[1, 2, 3, 4, 5],

     [6, 7, 8, 9, 10],

     [11, 12, 13, 14, 15],

     [16, 17, 18, 19, 20],

     [21, 22, 23, 24, 25]]



print(min_parallel_diag(A)) #выводим результат работы функции

[16, 11, 6, 1, 2, 3, 4, 5, 10, 15, 20, 25]

⚠️Зарепортить пост!

Задай любой вопрос нейросети!

она справится с любой поставленной задачей быстрее чем поиск в Яндекс.