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

2 / 2 / 0

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

Сообщений: 23

1

Найти наибольший элемент главной диагонали

22.04.2009, 00:48. Показов 5337. Ответов 3

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

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



0

24 / 24 / 2

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

Сообщений: 118

22.04.2009, 01:36

2

Код

uses crt;
var
a: array[1..3,1..3] of integer;
i,j,nstr,max: integer;
begin
for i:=1 to 3 do
for j:=1 to 3 do
begin
read(a[i,j]);
end;
max:=a[1,1];
for i:=1 to 3 do
begin
if a[i,i]>max
then
begin
max:=a[i,i];
nstr:=i;
end;
end;
writeln('Наибольший элемент = ', max,' он расположен в ',nstr,'-й строке');
readln
end.



0

Homa

3 / 3 / 1

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

Сообщений: 35

22.04.2009, 01:40

3
Pascal 
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

program Project1;
 
{$APPTYPE CONSOLE}
var a: array[1..3,1..3] of integer;
    b: array [1..3] of integer;
   max,maxs,min,k,i,j:integer;
begin
for i:=1 to 3 do begin                      {ввод массива}
    for j:=1 to 3 do  begin
     Write('Mas[',i,',',j,']=');
     readln(a[i,j]);
    end;
    writeln;
  end;
 for i:=1 to 3 do begin                      {вывод массива}
    for j:=1 to 3 do  begin
     Write(a[i,j]:3);
     end;
     writeln;
   end;
   writeln;
   i:=1;
   j:=1;
   k:=1;
   writeln ('main diagonal: ');
repeat                                      {главная диагональ}
   write(a[i,j]:3);
   i:=i+1;
   J:=j+1;
   K:=i+1;
until i=4;
 for i := 1 to 3 do begin
  read(b[i]);
 end;                                        {поиск мах элемента}
   max:=b[1];
    for i:=1 to 3 do
      if max<b[i] then max:=b[i];
      b[i]:=max;
     write('max: ',max);
     readln;
      end.



0

c00le®

138 / 138 / 65

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

Сообщений: 235

22.04.2009, 02:01

4
Pascal 
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

uses crt;
 
const n=5;
 
type
    mas=array [1..10,1..10] of integer;
var
   e:mas;
   i,j,k,max,p,q:integer;
begin
   clrscr;
       randomize;
       for i:= 1 to n do
   begin
    for j:=1 to n do
   begin
     e[i,j]:=random(20);
                write(e[i,j]:3);
     end; writeln; end;
 
{поиск максимального}
max:=e[1,1];  p:=1; q:=1;
    for i:= 1 to n do
    for j:= 1 to n do
         if e[i,j]>max then 
         begin
    if i=j then
    max:= e[i,j]; p:=i; q:=j; end;
write('Максимальный: ',max,' ','находится в ',q, ' строке ');
readkey;
end.



0
Источник

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

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

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

    @k4roma

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

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

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


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

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

    • 2792 просмотра

    На 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.

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


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

    28 мая 2023, в 17:41

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

    28 мая 2023, в 17:31

    1200 руб./в час

    28 мая 2023, в 17:26

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

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

    Источник

    CLS
DO
    INPUT "vvedite kol-vo strok ", m
    INPUT "vvedite kol-vo stolbcov ", n
    IF m <> n THEN PRINT "matrica ne kvadratnaya povtorite vvod"
LOOP UNTIL m = n
DIM a(m, n)
FOR i = 1 TO m
    FOR j = 1 TO n
        PRINT "vvedite element a("; i; ","; j; ")=";
        INPUT a(i, j)
    NEXT
NEXT
PRINT "matrica"
FOR i = 1 TO m
    FOR j = 1 TO n
        PRINT a(i, j);
    NEXT
    PRINT
NEXT
PRINT "glavnaya diagonal"
max = a(1, 1)
FOR i = 1 TO n
    PRINT a(i, i);
    IF a(i, i) > max THEN max = a(i, i): k = i
NEXT
PRINT
PRINT "maximalnyj element glavnoj diagonali="; max
PRINT "on nahoditsya v stroke nomer "; k
PRINT "stroka nomer "; k
FOR i = 1 TO m
    PRINT a(k, i);
NEXT

    Следующий вариант

    CLS
DO
    INPUT "vvedite kol-vo strok ", m
    INPUT "vvedite kol-vo stolbcov ", n
    IF m <> n THEN PRINT "matrica ne kvadratnaya povtorite vvod"
LOOP UNTIL m = n
DIM a(m, n)
RANDOMIZE TIMER
FOR i = 1 TO m
    FOR j = 1 TO n
        a(i, j) = INT(RND * 20)
    NEXT
NEXT
PRINT "matrica"
FOR i = 1 TO m
    FOR j = 1 TO n
        PRINT a(i, j);
    NEXT
    PRINT
NEXT
PRINT "glavnaya diagonal"
max = a(1, 1)
FOR i = 1 TO n
    PRINT a(i, i);
    IF a(i, i) > max THEN max = a(i, i): k = i
NEXT
PRINT
PRINT "maximalnyj element glavnoj diagonali="; max
PRINT "on nahoditsya v stroke nomer "; k
PRINT "stroka nomer "; k
FOR i = 1 TO m
    PRINT a(k, i);
NEXT

    Тестирование выполнено в программе QB64 ( Скачать )

    Источник

    Понравилась статья? Поделить с друзьями:
  • Как нас найти в поисковой набираете
  • Как найти кто прописан в квартире
  • Как найти миссию человека
  • Как найти линию глаз
  • Как найти косинус 137