Как найти четную строку матрицы в с

namespace matrix
{
class Program
{
    static void Main(string[] args)
    {
        Random rand = new Random();
        Console.WriteLine("Введите размерность матрицы MxM :");
        int M = Convert.ToInt32(Console.ReadLine());
        int[,] matrix = new int[M, M];
        int sum = 0;
        for (int j = 0; j < M; j++)
        {
            for (int m = 0; m < M; m++)
            {
                matrix[j, m] = rand.Next(-10, 10);
                Console.Write(matrix[j, m] + " ");

            }
            Console.WriteLine();
            if((j + 1) % 2 == 0)

            {
                for (int i = 0; i < M; i++)
                {
                    sum += matrix[j, i];
                }
            }
        }
        Console.Write(" Сумма четных строк матрицы = {0}", sum);
        Console.ReadKey();
    }


}
}

2

39 В данном случае массив указателей на float.

40 Можно между элементы каждой строки можно разделять пробелами или символами табуляции, а в конце строки нажимать Enter.

Рисунок 6.5. Вывод матрицы в виде таблицы.

Далее на примерах решения практических задач будут рассмотрены основные алгоритмы обработки матриц и их реализация в C++. Перед этим, напомним некоторые свойства матриц (рис. 6.6):

• если номер строки элемента совпадает с номером столбца ( i= j ), это означает что элемент лежит на главной диагонали матрицы;

Рисунок 6.6 Свойства элементов матрицы

•если номер строки превышает номер столбца ( i> j ), то элемент находится ниже главной диагонали;

•если номер столбца больше номера строки ( i< j ), то элемент находится выше главной диагонали.

•элемент лежит на побочной диагонали, если его индексы удовлетворяют

равенству i+ j=n−1 ;

• неравенство i+ j<n−1 характерно для элемента находящегося выше побочной диагонали;

•соответственно, элементу лежащему ниже побочной диагонали соответствует выражение i+ j>n−1 .

ЗАДАЧА 6.1. Найти сумму элементов матрицы, лежащих выше главной диагонали.

Алгоритм решения данной задачи (рис. 6.7) построен следующим образом: обнуляется ячейка для накапливания суммы (переменная s). Затем с помощью двух

циклов (первый по строкам, второй по столбцам) просматривается каждый элемент матрицы, но суммирование происходит только в том случае если, этот элемент находится выше главной диагонали (при выполнении условия i< j ).

Рисунок 6.7: Блок–схема задачи 6.1 (алгоритм 1)

Текст программы:

#include <iostream> using namespace std; int main()

{

int s,i,j,n,m,a[20][20]; cout<<“N=”; cin>>n; cout<<“M=”; cin>>m; cout<<“Input Matrix A”<<endl; for(i=0;i<n;i++)

for(j=0;j<m;j++)

cin>>a[i][j];

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

for(j=0;j<m;j++)

if (j>i) s+=a[i][j]; //Если элемент выше //главной диагонали, //то наращиваем сумму.

cout<<“S=”<<s<<endl;

}

На рисунке 6.8 изображен еще один вариант решения данной задачи. В нем проверка условия i< j не выполняется, но, тем не менее, в нем так же суммируются элементы матрицы, находящиеся выше главной диагонали. В нулевой строке заданной матрицы необходимо сложить все элементы, начиная с первого. Во первой – все, начиная со второго, в i–й строке процесс начнется с (i+1)–го элемента и так далее.

Таким образом, внешний цикл работает от 0 до N-1, а второй от i+1 до M. Авторы

надеются, что читатель самостоятельно составит программу, соответствующую описанному алгоритму.

Рисунок 6.8: Блок–схема задачи 6.1 (алгоритм 2)

ЗАДАЧА 6.2. Вычислить количество положительных элементов квадратной матрицы, расположенных по ее периметру и на диагоналях. Напомним, что в квадратной матрице число строк равно числу столбцов.

Прежде чем преступить к решению задачи рассмотрим рисунок 6.9, на котором изображена схема квадратных матриц различной размерности.

Рисунок 6.9:Рисунок к задаче 6.2

Из условия задачи понятно, что не нужно рассматривать все элементы заданной матрицы. Достаточно просмотреть первую и последнюю строки, первый и последний столбцы, а так же диагонали. Все эти элементы отмечены на схеме, причем черным цветом выделены элементы, обращение к которым может произойти дважды. Например, элемент с номером (0,0) принадлежит как к нулевой строке, так и к нклевому столбцу, а элемент с номером (N-1,N-1) находится в последней строке и последнем столбце одновременно. Кроме того, если N – число нечетное (на рисунке 7.8 эта матрица расположена слева), то существует элемент с номером (N/2, N/2), который находится на пересечении главной и побочной диагоналей. При нечетном значении N (матрица справа на рис. 6.9) диагонали не пересекаются.

Итак, разобрав подробно постановку задачи, рассмотрим алгоритм ее решения. Для обращения к элементам главной диагонали вспомним, что номера строк этих элементов всегда равны номерам столбцов. Поэтому, если параметр i изменяется

Единичной называют матрицу, у которой элементы главной диагонали – единицы, а все остальные – нули. Например,

Для решения данной задачи необходимо найти в каждой строке сумму элементов,

которую разделить на их количество. Полученный результат записать в нулевой

элемент соответствующей строки. Текст программы:

#include <iostream> using namespace std; int main()

{

int i,j,N,M; double S, **a;

//Ввод размерности матрицы. cout<<“N=”; cin>>N; cout<<“M=”; cin>>M; //Выделение памяти под матрицу a=new double *[N];

for(i=0;i<N;a[i]=new double [M],i++); cout<<“Ввод элементов матрицы A”<<endl; for(i=0;i<N;i++)

for(j=0;j<M;cin>>a[i][j],j++);

//Цикл по i завершается записью среднего значения в //нулевой элемент строки и наращиванием i. for(i=0;i<N;a[i][0]=S/M,i++)

cout<<“Output Matrix A”<<endl; for(i=0;i<N;cout<<endl,i++)

for(j=0;j<M;cout<<a[i][j]<<“t”,j++);

}

ЗАДАЧА 6.5. Задана матрица A(n,m). Поменять местами ее максимальный и минимальный элементы.

Алгоритм решения этой задачи следующий: находим максимальный элемент матрицы (max) и его индексы (imax, jmax), а также минимальный (min) и его индексы (imin, jmin). После чего элементы A[imax][jmax] и A[imin][jmin] поменяем местами. Для поиска максимального элемента и его индексов в переменную max запишем A[0][0], в переменные imax, jmax, (номер строки и столбца, где находятся максимальный элемент) запишем 0. Затем в двойном цикле (цикл по переменной i – по строкам, цикл по переменной j – по столбцам) перебираем все элементы, и каждый из них сравниваем с максимальным (со значением переменной max). Если текущий элемент массива оказывается больше максимального, то его переписываем в переменную max, а в переменную imax – текущее значение индекса i, в переменную jmax – текущее значение j. Поиск минимального элемента матрицы аналогичен, и отличается только знаком.

Далее представлен текст программы решения задачи 6.5.

#include <iostream> using namespace std; int main()

{

int i,j,imax,jmax,imin,jmin,N,M; double min,max,b, **a; cout<<“N=”; cin>>N;

cout<<“M=”; cin>>M; a=new double *[N]; for(i=0;i<N;i++)

a[i]=new double [M];

cout<<“Ввод элементов матрицы A”<<endl; for(i=0;i<N;i++)

for(j=0;j<M;j++)

cin>>a[i][j];

//Двойной цикл для поиска максимального элемента для

//поиска максимального, минимального элементов и их

//индексов.

for(max=min=a[0][0],imax=jmax=imin=jmin=i=0;i<N;i++)

for(j=0;j<M;j++)

{

if (a[i][j]>max) {max=a[i][j]; imax=i;jmax=j;} if (a[i][j]<min) {min=a[i][j]; imin=i;jmin=j;}

}

//Обмен двух элементов матрицы. b=a[imax][jmax]; a[imax][jmax]=a[imin][jmin]; a[imin][jmin]=b;

//Вывод преобразованной матрицы. cout<<“Output Matrix A”<<endl; for(i=0;i<N;cout<<endl,i++)

for(j=0;j<M;j++)

cout<<a[i][j]<<“t”;

}

ЗАДАЧА 6.6. Преобразовать матрицу A(m,n) так, чтобы строки с нечетными индексами были упорядочены по убыванию, c четными – по возрастанию.

В связи с нумерацией строк в C++ с 0, необходимо помнить, что нулевая, вторая, четвертая строки упорядочиваются по убыванию, а первая, третья, пятая и т.д. – по возрастанию. Алгоритм решения этой задачи сводится к тому, что уже известный нам по предыдущей главе алгоритм упорядочивания элементов в массиве выполняется для каждой строки матрицы. Блок-схема приведена на рис. 6.10. Текст программы с

комментариями приведён далее.

#include <iostream> using namespace std; int main()

{

int i,j,k,N,M; double b, **a; cout<<“M=”; cin>>M; cout<<“N=”; cin>>N; a=new double *[N]; for(i=0;i<N;i++)

a[i]=new double [M];

cout<<“Ввод элементов матрицы A”<<endl; for(i=0;i<M;i++)

for(j=0;j<N;j++)

cin>>a[i][j];

a[i][j]=a[i][j+1];

a[i][j+1]=b;

}

//Вывод преобразованной матрицы. cout<<“Преобразованная матрица A”<<endl; for(i=0;i<M;cout<<endl,i++)

for(j=0;j<N;cout<<a[i][j]<<“t”,j++);

}

ЗАДАЧА 6.7. Поменять местами элементы главной и побочной диагонали матрицы A(k,k).

Алгоритм решения задачи следующий: перебираем все строки матрицы (цикл по переменной i от 0 до k-1), и в каждой строке меняем местами элементы, расположенные на главной и побочной диагоналях (в i-й строке надо поменять местами элементы A[i]

[i] и А[i][k-i-1]). Текст программы с комментариями:

#include <iostream> using namespace std; int main()

{

int i,j,k; double b,**a;

cout<<“k=”; cin>>k; a=new double *[k];

for(i=0;i<k;a[i]=new double [k],i++); cout<<“Ввод элементов матрицы A”<<endl; for(i=0;i<k;i++)

for(j=0;j<k;cin>>a[i][j],j++); for(i=0;i<k;i++) //Цикл по строкам.

{

//В каждой строке обмен между элементами, лежащими на //главной и побочной диагоналях.

b=a[i][i]; a[i][i]=a[i][k-1-i]; a[i][k-1-i]=b;

}

//Вывод преобразованной матрицы. cout<<“Преобразованная матрица A”<<endl; for(i=0;i<k;cout<<endl,i++)

for(j=0;j<k;cout<<a[i][j]<<“t”,j++);

}

ЗАДАЧА 6.8. Заполнить матрицу A(6,6) числами 1 до 36 следующим образом

Последовательно построчно заполняем матрицу возрастающей арифметической последовательностью 1,2,3,… , 36 . Четные строки заполняем от 0-го элемента