Как найти сумму побочной диагонали квадратной матрицы

Перейти к содержанию

const N = 10;

type

    type_arr = array[1..N, 1..N] of byte;

 
var

    arr: type_arr;

    i, j: byte;

    sum: byte;

    ch: char;

 
function diagonal (var arr1: type_arr; c: char): byte;

    var

        sum1: byte;

        i, j: byte;

    begin

        sum1 := 0;

        if c = '1' then j := 1

        else j:= N;

        for i:=1 to N do begin

            sum1 := sum1 + arr1[i][j];

            if c = '1' then j := j + 1

            else j := j-1;

        end;

        diagonal := sum1;

    end;

 
begin

    randomize;

    for i:=1 to N do begin

        for j:=1 to N do begin

            arr[i,j] := random(10);

            write(arr[i,j]:4);

        end;

        writeln;

    end;

    write('Главная (1) или побочная (2): ');

    readln(ch);

    if (ch = '1') or (ch = '2') then begin

        sum := diagonal(arr, ch);

        writeln(sum);

    end;

end.

Пример(ы) выполнения программы на языке Pascal:


   0   2   0   4   8   0   4   1   5   1

   1   7   7   0   1   7   8   4   7   7

   1   0   7   4   6   5   0   6   4   7

   1   5   3   3   0   4   6   7   8   0

   1   7   3   8   1   6   9   4   4   7

   8   5   7   7   1   7   8   8   8   4

   2   0   1   3   1   5   2   0   0   8

   4   8   3   7   5   6   5   1   3   9

   9   0   9   2   1   0   3   6   1   3

   8   3   7   5   8   8   9   5   1   1

Главная (1) или побочная (2): 2

41



  


                       
  

#include < stdio.h>

#define N 10

int diagonal(char c);

int a[N][N];

 
main() {

    int i, j, sum;

    char ch;

    srand(time(NULL));

    for (i=0; i< N; i++) {

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

            a[i][j] = rand() % 10;

            printf("%3d", a[i][j]);

        }

        printf("n");

    }

    printf("Главная (1) или побочная (2): ");

    scanf("%c", &ch);

    sum = diagonal(ch);

    printf("%dn", sum);

}

 
int diagonal(char c) {

    int s, i, j;

    s = 0;

    if (c == '1') 

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

            s += a[i][i];

    else 

        for (i=0, j=N-1; i< N; i++,j--)

            s += a[i][j];

    return s;    

}

def diagonal(l,c):

    s = 0

    i = 0

    while i < N:

        if c == '1':

            s += l[i][i]

        else:

            s += l[i][N-i-1]

        i += 1

    return s

 
 
from random import random

N = 10

a = []

for i in range(N):

    b = []

    for j in range(N):

        n = int(random()*10)

        b.append(n)

        print("%3d" % n, end='')

    a.append(b)

    print()

 
ch = input("Главная (1) или побочная (2): ")

if ch == '1' or ch == '2':

    summa = diagonal(a,ch)

    print(summa)

цел N = 7

цел таб a[1:N,1:N]

алг 

нач

  цел i, j, sum

  сим ch

  нц для i от 1 до N

    нц для j от 1 до N

      a[i,j] := int(rand(0,10))

      вывод a[i,j], " "

    кц

    вывод нс

  кц

  вывод "Главная (г) или побочная (п): "

  ввод ch

  если ch = "г" или ch = "п" то

    sum := diag(ch)

    вывод sum

  все

кон

 
алг цел diag(сим c)

нач

  цел s, i, j

  s := 0

  нц для i от 1 до N

    если c = "г" то 

      s := s + a[i,i]

     иначе

      s := s + a[i,N-i+1] 

    все

  кц

  знач := s

кон



  


                       
  

Тем, кто знакомым с математическими матрицами, будет не трудно освоить и двумерные массивы в Pascal. Матрица – это математический объект, представляющий собой прямоугольную таблицу. Таблица состоит из элементов, которые находятся на пересечении строк и столбцов, определяющих их, то есть i-ая строка и j-ый столбец задают адрес k-ому элементу матрицы (kij). Двумерные массивы абсолютно аналогичны математическим матрицам.

В отличие от одномерных массивов, двумерные характеризуются в программе парой индексов, один из которых соответствует номеру строки, другой – столбца:

Mas[m, n], где Mas – имя массива, n – номер строки, а m – номер столбца.

Описать матрицу в программе можно несколькими способами:

1) В разделе описания переменных:

Var Mas: Array[1..n, 1..m] of <тип элементов>;

2) При помощи одномерного массива, элементами которого являются одномерные массивы.
Пример:

Const
n = 5; m = 10;
Type
Arr1 = Array[1..m] of <тип элементов >;
Arr2 = Array[1..n] of arr1;
Var Mas: arr2;

Переменная Mas – матрица, состоящая из пяти строк, в каждую из которых включено по десять элементов.

3) Предыдущий способ можно упростить так:

Const n = 5; m = 10;
Турe arr=Array[1..n] Of Аrrау[1..m] of <тип элементов>;
Var Mas: arr;

4) И снова сократив запись, получим:

Const n = 5; m = 10;
Type arr = Array[1..n,1..m] of <тип элементов>;
Var Mas: arr;

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

For i:= 1 To n Do
  For j:= 1 To m Do

Например, для заполнения массива случайнми числами:

for i:=1 to n do
  for j:=1 to n do 
    x[i,j]:=random(100); 

Для вывода двумерного массива вещественных чисел размером n строк, m столбцов:

for i:=1 to n do begin
  for j:=1 to m do 
    write(x[i,j]:5:2);
  writeln;
end;

В следующей программе массив сначала заполняется числами с клавиатуры, а затем выводиться на экран.

program input_and_output_array;
uses crt;
const n=3; m=3;
var i, j: integer;
mas: array[1..n, 1..m] of integer;
begin
  {ввод массива}
  for i:=1 to n do
    for j:=1 to m do
    begin
      write(' Элемент ', i,' строки, ',j,' столбца = ');
      readln(mas[i, j]);
    end;
  writeln(' Получившаяся матрица: ');
  {вывод массива}
  for i:=1 to n do
  begin
    for j:=1 to m do
    begin
      write(mas[i, j]:5);
    end;
  writeln
  end;
end.

Количество элементов в массиве (его размерность) можно узнать, умножив количество строк на количество столбцов.

Сумма всех элементов квадратной матрицы:

sum:=0;

for i:=1 to n do
  for j:=1 to n do 
    sum:=sum+x[i,j];

writeln('Сумма=',sum); 

Сумма элементов главной диагонали квадратной матрицы (элементы главной диагонали имеют одинаковые индексы -x[1,1], x[2,2] и т.д.):

sum:=0;

for i:=1 to n do 
  sum:=sum+x[i,i];

writeln('Сумма=',sum);

Сумма элементов побочной диагонали (диагонали противоположной главной). Индексы элементов побочной диагонали в сумме равны n+1, т.е. i+j=n+1 или j=n+1-i:

sum:=0;

for i:=1 to n do 
  sum:=sum+x[i,n+1-i];

writeln('Сумма=',sum);

Сумма элементов ниже главной диагонали квадратной матрицы (строго ниже):

sum:=0;

for i:=1 to n do
  for j:=1 to n do 
    if i>j then 
      sum:=sum+x[i,j];

writeln('Сумма=',sum);

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

sum:=0;

for i:=2 to n do
  for j:=1 to i-1 do 
    sum:=sum+x[i,j];

writeln('Сумма=',sum);

Сумма элементов выше и на главной диагонали квадратной матрицы:

sum:=0;

for i:=1 to n do
  for j:=1 to n do
    if i<=j then 
      sum:=sum+x[i,j];

writeln('Сумма=',sum);

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

sum:=0;

for i:=1 to n do
  for j:=i to n do 
    sum:=sum+x[i,j];

writeln('Сумма=',sum);

Сумма элементов ниже побочной диагонали квадратной матрицы (строго ниже) :

sum:=0;

for i:=1 to n do
  for j:=1 to n do
    if i+j>n+1 then 
      sum:=sum+x[i,j];

writeln('Сумма=',sum);

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

sum:=0;

for i:=2 to n do
  for j:=n+2-i to n do 
    sum:=sum+x[i,j];

writeln('Сумма=',sum);

Если надо посчитать сумму элемсентов ниже побочной диагонали и на ней, то в предыдущем примере, при просмотре всего массива в предыдущем примере надо заменить знак отношения > на >=, а при просмотре толко нужных элементов применить такой код:

sum:=0;

for i:=1 to n do
  for j:=n+1-i to n do 
    sum:=sum+x[i,j];

writeln('Сумма=',sum);

При подсчете суммы элементов выше и на главной диагонали, выше и на побочной диагонали возможно применине такого кода:

sum:=0;

for i:=1 to n do
  for j:=1 to n do
    if (i<=j) and (i+j<=n+1) then
      sum:=sum+x[i,j];

writeln('Сумма=',sum);

Подсчет сумм элементов по строкам:

for i:=1 to n do begin
  sum:=0;

  for j:=1 to n do 
    sum:=sum+x[i,j];

  writeln('Сумма ',i,'-й строки',sum);
end;

Подсчет сумм элементов по столбцам:

for j:=1 to n do begin
  sum:=0;

  for i:=1 to n do 
    sum:=sum+x[i,j];

  writeln('Сумма ',j,'-го столбца ',sum);
end;

Безусловно суммы по строкам и столбцам можно записывать в одномерный массив. Например, для сумм по столбцам:

for i:=1 to n do 
  sum[j]:=0;

for i:=1 to n do
  for j:=1 to n do 
    zum[j]:=sum[j]+x[i,j];

{вывод сумм по столбцам}
for i:=1 to n do 
  write(sum[i]:4);
writeln; 

Суммы элементов по диагоналям, параллельным главной диагонали.

Очевидно, что таких сумм будет 2n-1. Кроме того, разности индексов эдементов, стоящих на одной диагонали будут равны друг другу. Имеется в виду разность «номер строки минус номер столбца». Эти разности будут меняться от -n+1 для самой верхней диагонали s1, содержащей всего лишь один элемент, до n-1 для диагонали s2N-1, расположенной в самом низу матрицы и содержащей также всего один элемент. Таким образом, для подсчета сумм мы должны объявить массив:

Var sum:array[-n+1..n-1] of integer;

Число элементов в этом массиве будет 2n-1. Код для подсчета этих сумм:

for i:=-n+1 to n-1 do 
  sum[i]:=0;

for i:=1 to n do
  for j:=1 to n do 
    sum[i-j]:=sum[i-j]+x[i,j];

for i:=-n+1 to n-1 do 
  write(sum[i]); 

Суммы элементов по диагоналям, параллельным побочной диагонали.

for i:=2 to 2*n do 
  sum[i]:=0;

for i:=1 to n do
  for j:=1 to n do 
    sum[i+j]:=sum[i+j]+x[i,j];

for i:=2 to 2*n do 
  write(sum[i]);

Суммы элементов по периметрам двумерного массива.

Cледует различать четный или нечетный порядок матрицы n. Число сумм будет равно k=n div 2 при четном n и k=n div 2 +1 при нечетном значении n.

Счет суммы начинается по строке i от столбца j равного i и заканчивается столбцом n-i+1, т.е. начинается с элемена находящегося на главной диагонали и заканчивается элементом на побочной диагонали.

Одновременно учитываются элементы из параллельной строки, индекс которой равен n-i+1.

Затем считаем элементы по двум паралельным столбцам i и n-i+1 (не учитывая элементы, стоящие в строках). Если n -нечетное число, то выводим значение центрального элемента массива x[k+1,k+1].

k:=n div 2;

for i:=1 to k do begin
  sum:=0;

  {строки}
  for j:=i to n-i+1 do
    sum:=sum+x[i,j]+x[n-i+1,j];

  {столбцы}
  for j:=i+1 to n-i do
    sum:=sum+x[j,i]+x[j,n-i+1];

  writeln(sum); {вывод суммы}
end;

if n mod 2=1 then
  writeln(x[k+1,k+1]); 

uses crt;
const Max=100;
var Matrix:array[1..Max,1..Max] of integer;
    i,j,Sum1,Sum2,m:integer;
begin
  clrscr;
  randomize;
  repeat
    writeln('Введите размерность квадратной матрицы ');
    readln(m);
  until m in [1..Max];
  for i:=1 to m do
    for j:=1 to m do
      Matrix[i,j]:=random(25);//при необходимости замените на ручной ввод
  for i:=1 to m do
    begin
      for j:=1 to m do
        write(Matrix[i,j]:4);
        writeln;
    end;
  Sum1:=0; Sum2:=0;
  for i:=1 to m do
    begin
      Sum1:=Sum1+Matrix[i,i];
      Sum2:=Sum2+Matrix[m-i+1,i];
    end;
  writeln('Сумма элементов главной диагонали:',Sum1);
  writeln('Сумма элементов побочной диагонали:',Sum2);
  readln;
end.

Задача — Вычислить сумму элементов главной или побочной диагонали матрицы
— программирование на Pascal, Си, Кумир, Basic-256, Python

Дана квадратная матрица. Вычислить сумму элементов главной или побочной диагонали в зависимости от выбора пользователя. Сумма элементов любой диагонали должна вычисляться в одной и той же функции.

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

Если была выбрана сумма главной диагонали, то при определении ее элементов второй индекс матрицы будет равен первому и начинаться с первого элемента. В случае побочной диагонали второй индекс будет начинаться с последнего элемента и заканчиваться первым. Поэтому в теле функции перед проходом по матрице второму индексу присваивается либо 1 (или 0), либо размерность квадратной матрицы (N или N-1). При проходе второй индекс либо увеличивается на каждой итерации, либо уменьшается.

Pascal

const N = 10;
type
type_arr = array[1..N, 1..N] of byte;

var
arr: type_arr;
i, j: byte;
sum: byte;
ch: char;

function diagonal (var arr1: type_arr; c: char): byte;
var
sum1: byte;
i, j: byte;
begin
sum1 := 0;
if c = ‘1’ then j := 1
else j:= N;
for i:=1 to N do begin
sum1 := sum1 + arr1[i][j];
if c = ‘1’ then j := j + 1
else j := j-1;
end;
diagonal := sum1;
end;

begin
randomize;
for i:=1 to N do begin
for j:=1 to N do begin
arr[i,j] := random(10);
write(arr[i,j]:4);
end;
writeln;
end;
write(‘Главная (1) или побочная (2): ‘);
readln(ch);
if (ch = ‘1’) or (ch = ‘2’) then begin
sum := diagonal(arr, ch);
writeln(sum);
end;
end.

Пример(ы) выполнения программы на языке Pascal:

    0   2   0   4   8   0   4   1   5   1    1   7   7   0   1   7   8   4   7   7    1   0   7   4   6   5   0   6   4   7    1   5   3   3   0   4   6   7   8   0    1   7   3   8   1   6   9   4   4   7    8   5   7   7   1   7   8   8   8   4    2   0   1   3   1   5   2   0   0   8    4   8   3   7   5   6   5   1   3   9    9   0   9   2   1   0   3   6   1   3    8   3   7   5   8   8   9   5   1   1 Главная (1) или побочная (2): 2 41

Язык Си

#include <stdio.h>
#define N 10
int diagonal(char c);
int a[N][N];

main() {
int i, j, sum;
char ch;
srand(time(NULL));
for (i=0; i<N; i++) {
for (j=0; j<N; j++) {
a[i][j] = rand() % 10;
printf(«%3d», a[i][j]);
}
printf(«n»);
}
printf(«Главная (1) или побочная (2): «);
scanf(«%c», &ch);
sum = diagonal(ch);
printf(«%dn», sum);
}

int diagonal(char c) {
int s, i, j;
s = 0;
if (c == ‘1’)
for (i=0; i<N; i++)
s += a[i][i];
else
for (i=0, j=N-1; i<N; i++,j—)
s += a[i][j];
return s;
}

Python

def diagonal(l,c):
s = 0
i = 0
while i < N:
if c == ‘1’:
s += l[i][i]
else:
s += l[i][N-i-1]
i += 1
return s

from random import random
N = 10
a = []
for i in range(N):
b = []
for j in range(N):
n = int(random()*10)
b.append(n)
print(«%3d» % n, end=»)
a.append(b)
print()

ch = input(«Главная (1) или побочная (2): «)
if ch == ‘1’ or ch == ‘2’:
summa = diagonal(a,ch)
print(summa)

КуМир

цел N = 7
цел таб a[1:N,1:N]
алг
нач
цел i, j, sum
сим ch
нц для i от 1 до N
нц для j от 1 до N
a[i,j] := int(rand(0,10))
вывод a[i,j], » »
кц
вывод нс
кц
вывод «Главная (г) или побочная (п): »
ввод ch
если ch = «г» или ch = «п» то
sum := diag(ch)
вывод sum
все
кон

алг цел diag(сим c)
нач
цел s, i, j
s := 0
нц для i от 1 до N
если c = «г» то
s := s + a[i,i]
иначе
s := s + a[i,N-i+1]
все
кц
знач := s
кон

Did you find apk for android? You can find new Free Android Games and apps.