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

0 / 0 / 0

Регистрация: 15.11.2013

Сообщений: 4

1

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

15.11.2013, 14:17. Показов 17793. Ответов 9

Студворк — интернет-сервис помощи студентам

Помогите, какой должен быть код чтобы программа высчитывала максимальный элемент главной диагонали матрицы Х(5 на 5)



0

Programming

Эксперт

94731 / 64177 / 26122

Регистрация: 12.04.2006

Сообщений: 116,782

 15.11.2013, 14:17

9

ПерС

584 / 487 / 371

Регистрация: 05.11.2013

Сообщений: 1,263

Записей в блоге: 6

15.11.2013, 15:00

2

Цитата
Сообщение от jeka950
Посмотреть сообщение

Помогите, какой должен быть код чтобы программа высчитывала максимальный элемент главной диагонали матрицы Х(5 на 5)

Это секретный код… только для тебя… если X задана, то

C++ 
1
2

int max=x[0][0];
for (int i=1; i<5; i++) if (x[i][i]>max) max=x[i][i];



1

Hoottie_McGOOB

109 / 107 / 44

Регистрация: 04.10.2013

Сообщений: 231

15.11.2013, 15:03

3
C++ 
1
2
3
4
5
6
7
8
9
10
11

    int X[5][5];
    //заполняем матрицу a
 
 
    int max = X[0][0];
 
    for(int i=1; i<5; ++i)
        if(X[i][i]>max)
            max = X[i][i];
 
    cout<<"max = "<<max<<endl;



0

Alexxx7

98 / 34 / 10

Регистрация: 24.04.2012

Сообщений: 151

15.11.2013, 15:14

4
C++ 
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
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65

#include <iostream>
#include <ctime>
#include <iomanip>
using namespace std;
 
int main(int argc, char* argv[])
{
    int n,m,count ;
    float max_el;
    srand(time(0)); // генерация случайных чисел
    // динамическое создание двумерного массива вещественных чисел на десять элементов
    cin >>n;
    cin >>m;
    float **ptrarray = new float* [n]; // две строки в массиве
    for (int count = 0; count < n; count++)
        ptrarray[count] = new float [m]; // и пять столбцов
    // заполнение массива
    for (int count_row = 0; count_row < n; count_row++)
        for (int count_column = 0; count_column < m; count_column++)
            ptrarray[count_row][count_column] = (rand() % 10 + 1) / float((rand() % 10 + 1)); //заполнение массива случайными числами с масштабированием от 1 до 10
    // вывод массива
    for (int count_row = 0; count_row < n; count_row++){
        for (int count_column = 0; count_column < m; count_column++)
            cout << setw(4) <<setprecision(2) << ptrarray[count_row][count_column] << " ";
            cout << endl;
        }
    cout<<endl;
    //для рядов
    for (int col = 0; col < n; col++){
        max_el = ptrarray[col][0];
        int row = 0;
        for (; row < m; row++){
            if( max_el < ptrarray[col][row])
                max_el = ptrarray[col][row];
        }
        cout<<" Max el "<<col<<" row "<<max_el<<endl;
    }
    cout<<endl;
    //для калонн
    for (int row = 0; row < m; row++){
        max_el = ptrarray[0][row];
        int col = 0;
        for (; col < n; col++){
            if( max_el < ptrarray[col][row])
                max_el = ptrarray[col][row];
        }
        cout<<" Max el "<<row<<" col "<<max_el<<endl;
    }
    //для диагонали
    max_el = ptrarray[0][0];
    for (int col = 0; col < n; col++){
        for (int row = 0; row < m; row++){
            if( col == row)
                if(max_el < ptrarray[col][row])
                    max_el = ptrarray[col][row];
        }
    }
    cout<<" Max el diag - "<<max_el<<endl;
    cout<<endl;
    // удаление двумерного динамического массива
    for (int count = 0; count < n; count++)
        delete []ptrarray[count];
    system("pause");
    return 0;
}

только что похожее писал, лишнее удали если не надо



1

jeka950

0 / 0 / 0

Регистрация: 15.11.2013

Сообщений: 4

15.11.2013, 16:08

 [ТС]

5

Цитата
Сообщение от ПерС
Посмотреть сообщение

Это секретный код… только для тебя… если X задана, то

C++ 
1
2

int max=x[0][0];
for (int i=1; i<5; i++) if (x[i][i]>max) max=x[i][i];

получается что Х в данном задании не задана



0

ПерС

584 / 487 / 371

Регистрация: 05.11.2013

Сообщений: 1,263

Записей в блоге: 6

15.11.2013, 16:11

6

это огромная проблема, да
а ты попробуй поступить так: задай секретную матрицу от фонаря

C++ 
1
2
3
4
5
6
7

int x[5][5] = {
 {1,2,3,4,5},
 {5,4,3,2,1},
 {1,2,3,4,5},
 {5,4,3,2,1},
 {1,2,3,4,2}
};

представляешь, я шаман… могу предсказать, что ответ будет 4



1

jeka950

0 / 0 / 0

Регистрация: 15.11.2013

Сообщений: 4

15.11.2013, 16:23

 [ТС]

7

Цитата
Сообщение от ПерС
Посмотреть сообщение

это огромная проблема, да
а ты попробуй поступить так: задай секретную матрицу от фонаря

C++ 
1
2
3
4
5
6
7

int x[5][5] = {
 {1,2,3,4,5},
 {5,4,3,2,1},
 {1,2,3,4,5},
 {5,4,3,2,1},
 {1,2,3,4,2}
};

представляешь, я шаман… могу предсказать, что ответ будет 4

ну это понятно что будет 4, в матрицах я разбираюсь но просто С++ для меня так тяжело даётся а как должен выглядеть полный код для такой программы?



0

ПерС

584 / 487 / 371

Регистрация: 05.11.2013

Сообщений: 1,263

Записей в блоге: 6

15.11.2013, 17:12

8

хм, если не брать в расчёт зависящих от компилятора операторов, то так:

C++ 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

#include <iostream.h>
#include <stdlib.h>
int main () {
int x[5][5] = {
 {1,2,3,4,5},
 {5,4,3,2,1},
 {1,2,3,4,5},
 {5,4,3,2,1},
 {1,2,3,4,2}
};
 int max=x[0][0];
 for (int i=1; i<5; i++) if (x[i][i]>max) max=x[i][i];
 cout << "max=" << max << endl;
 system("pause");
 return 0;
}

у тебя в ветке, кажется, ещё пара версий



0

0 / 0 / 0

Регистрация: 15.11.2013

Сообщений: 4

16.11.2013, 00:57

 [ТС]

9

а какой должен быть код для того чтобы я вводил значения матрицы в готовой проге?
ну в смысле через ту консоль.



0

ПерС

584 / 487 / 371

Регистрация: 05.11.2013

Сообщений: 1,263

Записей в блоге: 6

16.11.2013, 07:28

10

Цитата
Сообщение от jeka950
Посмотреть сообщение

а какой должен быть код для того чтобы я вводил значения матрицы в готовой проге?
ну в смысле через ту консоль.

вместо

C++ 
1
2
3
4
5
6
7

int x[5][5] = {
 {1,2,3,4,5},
 {5,4,3,2,1},
 {1,2,3,4,5},
 {5,4,3,2,1},
 {1,2,3,4,2}
};

напиши

C++ 
1
2
3
4
5
6
7
8
9
10

int x[5][5]; 
int i,j;
cout << "Ввод матрицы 5*5" << endl;
for (i=0; i<5; i++)
for (j=0; j<5; j++) {
 cout << "A[" << i << "," << j <<"]=";
 cin >> x[i][j];
}
int max=x[0][0];
for (i=1; i<5; i++)

дальше без изменений



0

IT_Exp

Эксперт

87844 / 49110 / 22898

Регистрация: 17.06.2006

Сообщений: 92,604

 16.11.2013, 07:28

Помогаю со студенческими работами здесь

Найти максимальный элемент матрицы среди расположенных выше главной диагонали
Помогите, пожалуйста, нужно написать программу в ближайший час…

найти макс элемент матрицы…

Поменять местами максимальный элемент в каждой строке матрицы с элементом главной диагонали
Нужно в заданной квадратной матрице поменять местами максимальный элемент в строке с элементом…

Определить максимальный элемент среди элементов матрицы, расположенных выше главной диагонали
Задание:
Задана матрица A(n,n). Определить максимальный элемент среди элементов матрицы,…

Найти максимальный элемент главной диагонали матрицы, вывести строку и столбец, в которых он содержится
Здравствуйте, собственно бьюсь с решением данной задачи, смог вывести только строку, написал данную…

Искать еще темы с ответами

Или воспользуйтесь поиском по форуму:

10

Источник
Рома

@k4roma

Начал изучать JavaScript

Как найти максимальный элемент матрицы на главной диагонали и ниже её?

Как найти максимальный элемент матрицы на главной диагонали и ниже её?
Матрица 5Х5.
Помогите пожалуйста.


  • Вопрос задан

    более трёх лет назад

  • 2791 просмотр

На PascalABC.NET

program max_element;
var
  matrix: array[0..4, 0..4] of integer;
  i, j: integer;
  max: integer;
begin
  Randomize;
  // Заполнение матрицы
  for i := 0 to 4 do
    begin
      for j := 0 to 4 do
        matrix[i][j] := Random(10, 99);
      WriteLn(matrix[i]);
    end;
  
  i := 0;
  j := 0;
  max := matrix[i][j];
  for j := 0 to 4 do
    for i := j to 4 do
      if max < matrix[i][j] then
        max := matrix[i][j];
  
  WriteLn(max);
end.

Пригласить эксперта


  • Показать ещё
    Загружается…

25 мая 2023, в 19:25

3000 руб./за проект

23 мая 2023, в 17:42

110000 руб./за проект

25 мая 2023, в 18:47

1 руб./за проект

Минуточку внимания

Источник

Improve Article

Save Article

Like Article

  • Read
  • Discuss

    • Improve Article

    Save Article

    Like Article

    Given a square matrix of order n*n, find the smallest and largest elements from both diagonals of the given matrix. 

    Examples: 

    Input : matrix = {
            {1, 2, 3, 4, -10},
            {5, 6, 7, 8, 6},
            {1, 2, 11, 3, 4},
            {5, 6, 70, 5, 8},
            {4, 9, 7, 1, 5}};
Output :
Principal Diagonal Smallest Element:  1
Principal Diagonal Greatest Element :11
Secondary Diagonal Smallest Element: -10
Secondary Diagonal Greatest Element: 11

    The idea behind solving this problem is, First check traverse matrix and reach all diagonals elements (for principal diagonal i == j and secondary diagonal i+j = size_of_matrix-1) and compare diagonal element with min and max variable and take new min and max values. and same thing for secondary diagonals.

    Here is implementation of above approach: 

    Example 1: With O(n^2) Complexity

    C++

    #include<bits/stdc++.h>

    using namespace std;

    void diagonalsMinMax(int mat[5][5])

    {

        int n = sizeof(*mat) / 4;

        if (n == 0)

            return;

        int principalMin = mat[0][0],

            principalMax = mat[0][0];

        int secondaryMin = mat[n - 1][0],

            secondaryMax = mat[n - 1][0];

        for (int i = 1; i < n; i++)

        {

            for (int j = 1; j < n; j++)

            {

                if (i == j)

                {

                    if (mat[i][j] < principalMin)

                    {

                        principalMin = mat[i][j];

                    }

                    if (mat[i][j] > principalMax)

                    {

                        principalMax = mat[i][j];

                    }

                }

                if ((i + j) == (n - 1))

                {

                    if (mat[i][j] < secondaryMin)

                    {

                        secondaryMin = mat[i][j];

                    }

                    if (mat[i][j] > secondaryMax)

                    {

                        secondaryMax = mat[i][j];

                    }

                }

            }

        }

        cout << ("Principal Diagonal Smallest Element: ")

            << principalMin << endl;

        cout << ("Principal Diagonal Greatest Element : ")

            << principalMax << endl;

        cout << ("Secondary Diagonal Smallest Element: ")

            << secondaryMin << endl;

        cout << ("Secondary Diagonal Greatest Element: ")

            << secondaryMax << endl;

    }

    int main()

    {

        int matrix[5][5] = {{ 1, 2, 3, 4, -10 },

                            { 5, 6, 7, 8, 6 },

                            { 1, 2, 11, 3, 4 },

                            { 5, 6, 70, 5, 8 },

                            { 4, 9, 7, 1, -5 }};

        diagonalsMinMax(matrix);

    }

    Java

    public class GFG {

        static void diagonalsMinMax(int[][] mat)

        {

            int n = mat.length;

            if (n == 0)

               return;

            int principalMin = mat[0][0], principalMax = mat[0][0];

            int secondaryMin = mat[n-1][0], secondaryMax = mat[n-1][0];

            for (int i = 1; i < n; i++) {

                for (int j = 1; j < n; j++) {

                    if (i == j) {

                        if (mat[i][j] < principalMin) {

                            principalMin = mat[i][j];

                        }

                        if (mat[i][j] > principalMax) {

                            principalMax = mat[i][j];

                        }

                    }

                    if ((i + j) == (n - 1)) {

                        if (mat[i][j] < secondaryMin) {

                            secondaryMin = mat[i][j];

                        }

                        if (mat[i][j] > secondaryMax) {

                            secondaryMax = mat[i][j];

                        }

                    }

                }

            }

            System.out.println("Principal Diagonal Smallest Element:  "

                               + principalMin);

            System.out.println("Principal Diagonal Greatest Element : "

                               + principalMax);

            System.out.println("Secondary Diagonal Smallest Element: "

                               + secondaryMin);

            System.out.println("Secondary Diagonal Greatest Element: "

                               + secondaryMax);

        }

        static public void main(String[] args)

        {

            int[][] matrix = {

                { 1, 2, 3, 4, -10 },

                { 5, 6, 7, 8, 6 },

                { 1, 2, 11, 3, 4 },

                { 5, 6, 70, 5, 8 },

                { 4, 9, 7, 1, -5 }

            };

            diagonalsMinMax(matrix);

        }

    }

    Python3

    def diagonalsMinMax(mat):

        n = len(mat)

        if (n == 0):

            return

        principalMin = mat[0][0]

        principalMax = mat[0][0]

        secondaryMin = mat[0][n-1]

        secondaryMax = mat[0][n-1]

        for i in range(1, n):

            for j in range(1, n):

                if (i == j):

                    if (mat[i][j] < principalMin):

                        principalMin = mat[i][j]

                    if (mat[i][j] > principalMax):

                        principalMax = mat[i][j]

                if ((i + j) == (n - 1)):

                    if (mat[i][j] < secondaryMin):

                        secondaryMin = mat[i][j]

                    if (mat[i][j] > secondaryMax):

                        secondaryMax = mat[i][j]

        print("Principal Diagonal Smallest Element: ",

                                         principalMin)

        print("Principal Diagonal Greatest Element : ",

                                          principalMax)

        print("Secondary Diagonal Smallest Element: ",

                                         secondaryMin)

        print("Secondary Diagonal Greatest Element: ",

                                         secondaryMax)

    matrix = [[ 1, 2, 3, 4, -10 ],

              [ 5, 6, 7, 8, 6 ],

              [ 1, 2, 11, 3, 4 ],

              [ 5, 6, 70, 5, 8 ],

              [ 4, 9, 7, 1, -5 ]]

    diagonalsMinMax(matrix)

    C#

    using System;

    public class GFG {

        static void diagonalsMinMax(int[,] mat)

        {

            int n = mat.GetLength(0);

            if (n == 0)

            return;

            int principalMin = mat[0,0], principalMax = mat[0,0];

            int secondaryMin = mat[n-1,0], secondaryMax = mat[n-1,0];

            for (int i = 1; i < n; i++) {

                for (int j = 1; j < n; j++) {

                    if (i == j) {

                        if (mat[i,j] < principalMin) {

                            principalMin = mat[i,j];

                        }

                        if (mat[i,j] > principalMax) {

                            principalMax = mat[i,j];

                        }

                    }

                    if ((i + j) == (n - 1)) {

                        if (mat[i,j] < secondaryMin) {

                            secondaryMin = mat[i,j];

                        }

                        if (mat[i,j] > secondaryMax) {

                            secondaryMax = mat[i,j];

                        }

                    }

                }

            }

            Console.WriteLine("Principal Diagonal Smallest Element: "

                            + principalMin);

            Console.WriteLine("Principal Diagonal Greatest Element : "

                            + principalMax);

            Console.WriteLine("Secondary Diagonal Smallest Element: "

                            + secondaryMin);

            Console.WriteLine("Secondary Diagonal Greatest Element: "

                            + secondaryMax);

        }

        static void Main()

        {

            int[,] matrix = {

                { 1, 2, 3, 4, -10 },

                { 5, 6, 7, 8, 6 },

                { 1, 2, 11, 3, 4 },

                { 5, 6, 70, 5, 8 },

                { 4, 9, 7, 1, -5 }

            };

            diagonalsMinMax(matrix);

        }

    }

    PHP

    <?php

    function diagonalsMinMax($mat)

    {

        $n = count($mat);

        if ($n == 0)

            return;

        $principalMin = $mat[0][0];

        $principalMax = $mat[0][0];

        $secondaryMin = $mat[$n - 1][0];

        $secondaryMax = $mat[$n - 1][0];

        for ($i = 1; $i < $n; $i++)

        {

            for ($j = 1; $j < $n; $j++)

            {

                if ($i == $j)

                {

                    if ($mat[$i][$j] < $principalMin)

                    {

                        $principalMin = $mat[$i][$j];

                    }

                    if ($mat[$i][$j] > $principalMax)

                    {

                        $principalMax = $mat[$i][$j];

                    }

                }

                if (($i + $j) == ($n - 1))

                {

                    if ($mat[$i][$j] < $secondaryMin)

                    {

                        $secondaryMin = $mat[$i][$j];

                    }

                    if ($mat[$i][$j] > $secondaryMax)

                    {

                        $secondaryMax = $mat[$i][$j];

                    }

                }

            }

        }

        echo "Principal Diagonal Smallest Element: ",

                                 $principalMin, "n";

        echo "Principal Diagonal Greatest Element : ",

                                  $principalMax, "n";

        echo "Secondary Diagonal Smallest Element: ",

                                 $secondaryMin, "n";

        echo "Secondary Diagonal Greatest Element: ",

                                 $secondaryMax, "n";

    }

    $matrix = array(array ( 1, 2, 3, 4, -10 ),

                    array ( 5, 6, 7, 8, 6 ),

                    array ( 1, 2, 11, 3, 4 ),

                    array ( 5, 6, 70, 5, 8 ),

                    array ( 4, 9, 7, 1, -5 ));

    diagonalsMinMax($matrix);

    ?>

    Javascript

    <script>

    function diagonalsMinMax(mat)

    {

        let n = mat.length;

        if (n == 0)

            return;

        let principalMin = mat[0][0],

            principalMax = mat[0][0];

        let secondaryMin = mat[n - 1][0],

            secondaryMax = mat[n - 1][0];

        for (let i = 1; i < n; i++)

        {

            for (let j = 1; j < n; j++)

            {

                if (i == j)

                {

                    if (mat[i][j] < principalMin)

                    {

                        principalMin = mat[i][j];

                    }

                    if (mat[i][j] > principalMax)

                    {

                        principalMax = mat[i][j];

                    }

                }

                if ((i + j) == (n - 1))

                {

                    if (mat[i][j] < secondaryMin)

                    {

                        secondaryMin = mat[i][j];

                    }

                    if (mat[i][j] > secondaryMax)

                    {

                        secondaryMax = mat[i][j];

                    }

                }

            }

        }

        document.write("Principal Diagonal Smallest Element: "

            + principalMin + "<br>");

        document.write("Principal Diagonal Greatest Element : "

            + principalMax + "<br>");

        document.write("Secondary Diagonal Smallest Element: "

            + secondaryMin + "<br>");

        document.write("Secondary Diagonal Greatest Element: "

            + secondaryMax + "<br>");

    }

        let matrix = [[ 1, 2, 3, 4, -10 ],

                            [ 5, 6, 7, 8, 6 ],

                            [ 1, 2, 11, 3, 4 ],

                            [ 5, 6, 70, 5, 8 ],

                            [ 4, 9, 7, 1, -5 ]];

        diagonalsMinMax(matrix);

    </script>

    Output

    Principal Diagonal Smallest Element: -5
Principal Diagonal Greatest Element : 11
Secondary Diagonal Smallest Element: 4
Secondary Diagonal Greatest Element: 11

    Example 2: With O(n) Complexity

    C++

    #include<bits/stdc++.h>

    using namespace std;

    const int n = 5;

    void diagonalsMinMax(int mat [n][n])

    {

        if (n == 0)

            return;

        int principalMin = mat[0][0],

            principalMax = mat[0][0];

        int secondaryMin = mat[n - 1][0],

            secondaryMax = mat[n - 1][0];

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

        {

            if (mat[i][i] < principalMin)

            {

                principalMin = mat[i][i];

            }

            if (mat[i][i] > principalMax)

            {

                principalMax = mat[i][i];

            }

            if (mat[n - 1 - i][i] < secondaryMin)

            {

                secondaryMin = mat[n - 1 - i][i];

            }

            if (mat[n - 1 - i][i] > secondaryMax)

            {

                secondaryMax = mat[n - 1 - i][i];

            }

        }

        cout << "Principal Diagonal Smallest Element: "

             << principalMin << "n";

        cout << "Principal Diagonal Greatest Element : "

             << principalMax << "n";

        cout << "Secondary Diagonal Smallest Element: "

             << secondaryMin << "n";

        cout << "Secondary Diagonal Greatest Element: "

             << secondaryMax;

    }

    int main()

    {

        int matrix [n][n] = {{ 1, 2, 3, 4, -10 },

                             { 5, 6, 7, 8, 6 },

                             { 1, 2, 11, 3, 4 },

                             { 5, 6, 70, 5, 8 },

                             { 4, 9, 7, 1, -5 }};

        diagonalsMinMax(matrix);

    }

    Java

    public class GFG {

        static void diagonalsMinMax(int[][] mat)

        {

            int n = mat.length;

            if (n == 0)

               return;

            int principalMin = mat[0][0], principalMax = mat[0][0];

            int secondaryMin = mat[n-1][0], secondaryMax = mat[n-1][0];

            for (int i = 0; i < n; i++) {

                if (mat[i][i] < principalMin) {

                    principalMin = mat[i][i];

                }

                if (mat[i][i] > principalMax) {

                    principalMax = mat[i][i];

                }

                if (mat[n - 1 - i][i] < secondaryMin) {

                    secondaryMin = mat[n - 1 - i][i];

                }

                if (mat[n - 1 - i][i] > secondaryMax) {

                    secondaryMax = mat[n - 1 - i][i];

                }

            }

            System.out.println("Principal Diagonal Smallest Element:  "

                               + principalMin);

            System.out.println("Principal Diagonal Greatest Element : "

                               + principalMax);

            System.out.println("Secondary Diagonal Smallest Element: "

                               + secondaryMin);

            System.out.println("Secondary Diagonal Greatest Element: "

                               + secondaryMax);

        }

        static public void main(String[] args)

        {

            int[][] matrix = {

                { 1, 2, 3, 4, -10 },

                { 5, 6, 7, 8, 6 },

                { 1, 2, 11, 3, 4 },

                { 5, 6, 70, 5, 8 },

                { 4, 9, 7, 1, -5 }

            };

            diagonalsMinMax(matrix);

        }

    }

    Python

    n = 5

    def diagonalsMinMax(mat):

        if (n == 0):

            return

        principalMin = mat[0][0]

        principalMax = mat[0][0]

        secondaryMin = mat[n - 1][0]

        secondaryMax = mat[n - 1][0]

        for i in range(n):

            if (mat[i][i] < principalMin):

                principalMin = mat[i][i]

            if (mat[i][i] > principalMax):

                principalMax = mat[i][i]

            if (mat[n - 1 - i][i] < secondaryMin):

                secondaryMin = mat[n - 1 - i][i]

            if (mat[n - 1 - i][i] > secondaryMax):

                secondaryMax = mat[n - 1 - i][i]

        print("Principal Diagonal Smallest Element: ",principalMin)

        print("Principal Diagonal Greatest Element : ",principalMax)

        print("Secondary Diagonal Smallest Element: ",secondaryMin)

        print("Secondary Diagonal Greatest Element: ",secondaryMax)

    matrix= [[ 1, 2, 3, 4, -10 ],

            [ 5, 6, 7, 8, 6 ],

            [ 1, 2, 11, 3, 4 ],

            [ 5, 6, 70, 5, 8 ],

            [ 4, 9, 7, 1, -5 ]]

    diagonalsMinMax(matrix)

    C#

    using System;

    public class GFG {

        static void diagonalsMinMax(int[,] mat)

        {

            int n = mat.GetLength(0);

            if (n == 0)

            return;

            int principalMin = mat[0,0], principalMax = mat[0,0];

            int secondaryMin = mat[n-1,0], secondaryMax = mat[n-1,0];

            for (int i = 0; i < n; i++) {

                if (mat[i,i] < principalMin) {

                    principalMin = mat[i,i];

                }

                if (mat[i,i] > principalMax) {

                    principalMax = mat[i,i];

                }

                if (mat[n - 1 - i,i] < secondaryMin) {

                    secondaryMin = mat[n - 1 - i,i];

                }

                if (mat[n - 1 - i,i] > secondaryMax) {

                    secondaryMax = mat[n - 1 - i,i];

                }

            }

            Console.WriteLine("Principal Diagonal Smallest Element: "

                            + principalMin);

            Console.WriteLine("Principal Diagonal Greatest Element : "

                            + principalMax);

            Console.WriteLine("Secondary Diagonal Smallest Element: "

                            + secondaryMin);

            Console.WriteLine("Secondary Diagonal Greatest Element: "

                            + secondaryMax);

        }

        public static void Main()

        {

            int[,] matrix = {

                { 1, 2, 3, 4, -10 },

                { 5, 6, 7, 8, 6 },

                { 1, 2, 11, 3, 4 },

                { 5, 6, 70, 5, 8 },

                { 4, 9, 7, 1, -5 }

            };

            diagonalsMinMax(matrix);

        }

    }

    Javascript

    <script>

        function diagonalsMinMax(mat)

        {

            let n = mat.length;

            if (n == 0)

            return;

            let principalMin = mat[0][0],

                principalMax = mat[0][0];

            let secondaryMin = mat[n-1][0],

                secondaryMax = mat[n-1][0];

            for (let i = 0; i < n; i++) {

                if (mat[i][i] < principalMin) {

                    principalMin = mat[i][i];

                }

                if (mat[i][i] > principalMax) {

                    principalMax = mat[i][i];

                }

                if (mat[n - 1 - i][i] < secondaryMin) {

                    secondaryMin = mat[n - 1 - i][i];

                }

                if (mat[n - 1 - i][i] > secondaryMax) {

                    secondaryMax = mat[n - 1 - i][i];

                }

            }

            document.write("Principal Diagonal Smallest Element: "

                            + principalMin+"<br>");

            document.write("Principal Diagonal Greatest Element : "

                            + principalMax+"<br>");

            document.write("Secondary Diagonal Smallest Element: "

                            + secondaryMin+"<br>");

            document.write("Secondary Diagonal Greatest Element: "

                            + secondaryMax+"<br>");

        }

            let matrix = [

                [ 1, 2, 3, 4, -10 ],

                [ 5, 6, 7, 8, 6 ],

                [ 1, 2, 11, 3, 4 ],

                [ 5, 6, 70, 5, 8 ],

                [ 4, 9, 7, 1, -5 ]

            ];

            diagonalsMinMax(matrix);

    </script>

    Output

    Principal Diagonal Smallest Element: -5
Principal Diagonal Greatest Element : 11
Secondary Diagonal Smallest Element: -10
Secondary Diagonal Greatest Element: 11

    Complexity Analysis:

    • Time complexity: O(n)
    • Auxiliary space: O(1) because it is using constant space

    Last Updated :
    18 Jan, 2023

    Like Article

    Save Article

    Improved By :

    • 29AjayKumar
    • ihritik
    • ankthon
    • Shashank_Sharma
    • mohit kumar 29
    • sravankumar_171fa07058
    • user_n13p
    • subham348
    • surinderdawra388
    • hardikkoriintern
    • mitalibhola94
    • noviced3vq6
    Источник

    Дана квадратная матрица размером nxn. Найти минимальный элемент среди элементов, расположенных ниже главной диагонали, найти максимальный элемент, среди элементов расположенных выше побочной диагонали. Найденные минимальный и максимальный элементы поменять местами и вывести их индексы.

    // 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;
}

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

    Источник
    program fd;
  uses crt;
  var a:array[1..10,1..10] of integer;
  max:array[1..20,1..10]of integer;
  i,j,m,n,l,k:integer;
  f:string;
  begin
  clrscr;
  randomize;
  read(n,m);
  for i:=1 to n do
  for j:=1 to m do
  a[i,j]:=random(201)-100;
   for i:=1 to n do begin
  for j:=1 to m do
  write(a[i,j]:4); writeln; end;
     i:=1;j:=1;
     repeat
    max[i,j]:=a[i,j];
    if (a[i+1,j+1]>max[i,j]) then max[i,j]:=a[i,j];
    i:=i+1;j:=j+1;
    until (i>n)or (j>m);
    writeln(max[i,j]);
    end.
    Источник

    Понравилась статья? Поделить с друзьями:
  • Как найти второй минимум в последовательности
  • Как можно найти беспроводной наушник дома
  • Даны координаты вершин треугольника как найти медиану
  • Юникод страницы как составить
  • Как составить бизнес план для открытия магазина разливного пива