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

catauggie

24 / 5 / 0

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

Сообщений: 310

1

Найти сумму элементов над и под главной и побочной диагоналями

28.06.2019, 16:16. Показов 18179. Ответов 15

Метки нет (Все метки)


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

Дана матрица размером NxN. найти сумму элементов над и под главной и побочной диагоналями:

Python
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
from random import randint
N = int(input())
lst=[[randint(1, 9) for i in range(N)] for i in range(N)]
for i in lst:
    print()
    for j in i:
        print (j, end=" ")
sum=0
for i in range(1, N):
    for j in range(i):
        sum = sum+lst[i][j]
print('nсумма под главной диагональю', sum)
sum1=0
for i in range(i):
    for j in range(j):
        if i<N-j-1:
            sum1 = sum1+lst[i][j]
print('nсумма выше побочной', sum1)
sum2=0
for i in range(i):
    for j in range(j):
        if i>N-j-1:
            sum2 = sum2+lst[i][j]
print('nсумма ниже побочной', sum2)

Проблема в том, что суммы над и под побочной диагональю неправильно ищет:

Найти сумму элементов над и под главной и побочной диагоналями

Подскажите, как исправить это. Заранее большое спасибо.



0



Автоматизируй это!

Эксперт Python

7064 / 4380 / 1177

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

Сообщений: 12,815

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

28.06.2019, 16:23

2

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

Подскажите, как исправить это.

включить дебаггер, голову , и построчно проверять программу — эта способность пригодится и в будущем. Неужели проще по каждому фейлу бежать на форум?



0



24 / 5 / 0

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

Сообщений: 310

28.06.2019, 16:33

 [ТС]

3

НЕ вижу тут каких-либо ошибок, и я по этому поводу

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

Неужели проще по каждому фейлу бежать на форум

уже все сказал



0



Автоматизируй это!

Эксперт Python

7064 / 4380 / 1177

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

Сообщений: 12,815

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

28.06.2019, 16:35

4

debugger! use it!



0



24 / 5 / 0

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

Сообщений: 310

28.06.2019, 19:09

 [ТС]

5

и все-таки цикл обработки вроде бы правильный



0



24 / 5 / 0

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

Сообщений: 310

28.06.2019, 19:19

 [ТС]

6

Найти сумму элементов над и под главной и побочной диагоналями

Можно конечно знак меньше поменять на меньше ли равно. Но результат все равно неправильный:
5 7 6
1 2 6
1 6 9
произведение под главной диагональю 6

произведение над главной диагональю 252

сумма над главной диагональю 19

сумма под главной диагональю 8

сумма выше побочной 5



0



24 / 5 / 0

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

Сообщений: 310

28.06.2019, 19:33

 [ТС]

7

в общем случае считает сумму над побочной, не включая соседнюю выше диагональ:
9 6 3 1
1 3 9 6
3 8 8 4
8 3 8 1
произведение под главной диагональю 4608

произведение над главной диагональю 3888

сумма над главной диагональю 29

сумма под главной диагональю 31

сумма выше побочной 16

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



0



Эксперт Python

4607 / 2028 / 359

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

Сообщений: 10,086

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

29.06.2019, 11:51

8

Советы.
1. Не используйте случайные числа для поиска ошибки. Вам нужен повторяющийся детерминированный процесс.
2. Выводите в лог, что суммируете. Так-то гадать можно долго, что там именно не так суммируется.
3. Дебаггер — хорошая вещь.



0



iSmokeJC

Am I evil? Yes, I am!

Эксперт PythonЭксперт Java

16112 / 8998 / 2605

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

Сообщений: 20,699

29.06.2019, 12:52

9

Лучший ответ Сообщение было отмечено catauggie как решение

Решение

Python
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
from random import randint
 
N = int(input())
lst = [[randint(1, 9) for _ in range(N)] for _ in range(N)]
for i in lst:
    print(*i)
summ = 0
for i in range(1, N):
    summ += sum(lst[i][:i])
print('nсумма под главной диагональю', summ)
sum1 = 0
for i in range(N):
    sum1 += sum(lst[i][:N-1-i])
print('nсумма выше побочной', sum1)
sum2 = 0
for i in range(1, N):
    sum2 += sum(lst[i][-i:])
print('nсумма ниже побочной', sum2)

Добавлено через 21 минуту

Python
1
2
3
4
5
6
7
8
9
from random import randint
 
N = int(input())
lst = [[randint(1, 9) for _ in range(N)] for _ in range(N)]
for i in lst:
    print(*i)
print(f'nсумма под главной диагональю: {sum(sum(lst[i][:i]) for i in range(1, N))}')
print(f'nсумма выше побочной: {sum(sum(lst[i][:N - 1 - i]) for i in range(N))}')
print(f'nсумма ниже побочной: {sum(sum(lst[i][-i:]) for i in range(1, N))}')



2



24 / 5 / 0

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

Сообщений: 310

30.06.2019, 15:43

 [ТС]

10

А что такое дебаггер?



0



Эксперт Python

4607 / 2028 / 359

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

Сообщений: 10,086

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

30.06.2019, 16:46

12

catauggie, поставьте PyCharm или другую ide, там встроен.



0



24 / 5 / 0

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

Сообщений: 310

01.07.2019, 14:28

 [ТС]

13

dondublon , у меня стоит Pycharm. Только я вообще не понимаю, как им пользоваться. Не посоветуете какой-нибудь курс или нормальную статью для новичков, а то документацию на английском мне в лом в читать



0



Welemir1

01.07.2019, 14:30

Не по теме:

catauggie, в программировании без английского делать нечего, все доки, статьи и стоящие книги на нем, так что…



0



Am I evil? Yes, I am!

Эксперт PythonЭксперт Java

16112 / 8998 / 2605

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

Сообщений: 20,699

01.07.2019, 14:31

15

catauggie, по ссылке, которую я тебе привел мануал с картинками в Intellij IDEA. Это тот же самый PyCharm



1



VistaSV30

496 / 276 / 72

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

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

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

24.06.2022, 23:32

16

Python
1
2
3
4
5
6
7
8
9
10
import numpy as np
n = 3 
 
ar = np.random.randint(0, 9, size=(n,n))
print('Исходная матрица:n', ar)
print('Сумма элементов под главной диагональю:')
print(sum(np.sum([[j for j in np.diag(ar, k = -i)] for i in range(1, n)])) )
ar1 = np.rot90(ar)
print('Сумма элементов под побочной диагональю:')
print(sum(np.sum([[j for j in np.diag(ar1, k = i)] for i in range(1, n)])) )

Наверняка, строки 7 и 10 можно оптимизировать, только пока не могу сообразить как именно



0



IT_Exp

Эксперт

87844 / 49110 / 22898

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

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

24.06.2022, 23:32

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

В массиве С(Р, Р) определить произведения элементов, расположенных одновременно под побочной и над главной диагоналями
В массиве С(Р, Р) определить произведения элементов, расположенных одновременно под побочной и над…

В массиве А(М, М) определить максимальный элемент среди элементов, расположенных одновременно над побочной и под главной диагоналями.
В массиве А(М, М) определить максимальный элемент среди элементов, расположенных одновременно над…

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

Поменять местами элементы, расположенные над главной и побочной диагоналями с расположенными под ними
Дана матрица А(5,5). Поменять местами элементы , расположенные над главной и побочной диагоналями …

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

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

16

Use numpy library which is powerful for any matrix calculations. For your specific case:

import numpy as np
a = [[11,2,4],[4,5,6],[10,8,-12]]
b = np.asarray(a)
print('Diagonal (sum): ', np.trace(b))
print('Diagonal (elements): ', np.diagonal(b))

You can easily install numpy with pip or other ways that you will find on many webs.

If you want all the diagonals, and not just the main diagonal, check this that also uses numpy.

EDIT

mhawke, if you want to calculate antidiagonal (secondary diagonal), as explained in wikipedia, you can flip the matrix in numpy

import numpy as np
a = [[11,2,4],[4,5,6],[10,8,-12]]
b = np.asarray(a)
b = np.fliplr(b)
print('Antidiagonal (sum): ', np.trace(b))
print('Antidiagonal (elements): ', np.diagonal(b))

answered Feb 7, 2016 at 11:52

iblasi's user avatar

iblasiiblasi

1,2499 silver badges21 bronze badges

1

Try this for summing your second diagonal:

sum(a[i][n-i-1] for i in range(n))

The inner loop accesses these entries:

>>> n = 3
>>> [(i, n-i-1) for i in range(n)]
[(0, 2), (1, 1), (2, 0)]

And the summed value of this diagonal for your sample matrix is:

>>> n = 3
>>> sum(a[i][n-i-1] for i in range(n))
19

The mistake in your code is to use the same expression for both dimensions:

a[n-i-1][n-i-1]

which will process the first diagonal again in reverse order [(2, 2), (1, 1), (0, 0)] giving you the same sum twice.

answered Feb 7, 2016 at 11:46

mhawke's user avatar

mhawkemhawke

83.9k9 gold badges115 silver badges136 bronze badges

0

getting total and diagonal sum from a squared matrix

squared_matrix = [[2,3,4],[4,3,3],[3,3,4]]
s, ds = get_sum(squared_matrix)

def get_sum(diag_mat):
    n = len(diag_mat)
    total = sum([diag_mat[i][j] for i in range(n) for j in range(j)]
    d_sum = sum([diag_mat[i][j] if i==j else 0 for i in range(n) for j in range(j)]
   return d_sum, total

answered May 18, 2020 at 15:16

Samir Paul's user avatar

try this:

n=3
sum_second_diagonal=sum([a[i][j] for i in range(n) for j in range(n) if i==j]) #it will add when i==j

Lokesh Sharma's user avatar

answered Feb 7, 2016 at 12:30

Binyamin Even's user avatar

Binyamin EvenBinyamin Even

3,3001 gold badge16 silver badges44 bronze badges

def sum_up_diagonals(li):
index = len(li)
first_dia =  sum(li[i][i]for i in range(index))
second_dia = sum(li[i][index-i-1]for i in range(index))
return (first_dia,second_dia)

Pass in your list.
This should work for you :)

answered Jun 7, 2020 at 14:38

greyk0's user avatar

O(n) time solution to find the diagonal difference of given multidimensional array.

def diagonalDifference(arr):
        # arr[0][0], arr[1][1], arr[2][2]
        # arr[0][2], arr[1][1], arr[2][0]
        sumOfDiagonalFromLeft = 0
        sumOfDiagonalFromRight = 0
        pointIndexFromLeft = 0
        pointIndexFromLast = len(arr)-1
        for i in range(len(arr)):
            sumOfDiagonalFromLeft += arr[i][pointIndexFromLeft]
            # print(arr[i][pointIndexFromLeft])
            pointIndexFromLeft += 1
        
        for i in range(len(arr)):
            sumOfDiagonalFromRight += arr[i][pointIndexFromLast]
            # print(arr[i][pointIndexFromLast])
            if pointIndexFromLast < 0:
                break
            else:
                pointIndexFromLast -= 1
    
        diagonalDifference = abs(sumOfDiagonalFromLeft - sumOfDiagonalFromRight)
        return diagonalDifference
    
arr = [[11, 2, 4], [4, 5, 6], [10, 8, -12]]
print(diagonalDifference(arr))

answered Jun 29, 2020 at 3:18

Joydeep Roychowdhury's user avatar

//we simply swap  corner elements of matrix

def diagonalDifference(arr):

    c=0;d=0
    for i in range(len(arr)):
        for j in range(len(arr)):
            if i==j :
                c = c+ arr[i][j]
        for k in range(len(arr)):
            arr[i][k-1],arr[i][k-2] = arr[i][k-2],arr[i][k-1]
        

        for j in range(len(arr)):
            if i==j :
                d = d + arr[i][j]
        for k in range(len(arr)):
            arr[i][k-1],arr[i][k-2] = arr[i][k-2],arr[i][k-1]
            
    
    
    print(c,d)  
    result = abs(c-d)
    print(result)

Chris's user avatar

Chris

126k99 gold badges268 silver badges250 bronze badges

answered Aug 29, 2021 at 16:44

Darshan Mistry's user avatar

1

Python 3 Solution with dynamic inputs of matrix as list inputs

#Even matrix size is dynamic in this code as "n".

n=int(input())
s1=0
s2=0
a =[]
for i in range(n):

    # x here take input of size n and as separate lists to act like a matrix.

    x=list(map(int,input().strip().split()))[:n]
    a.append(x)
for i in range(n):
    s1+=a[i][i]
    s2+=a[i][n-i-1]

# If use abs() only if non-negative output is needed!!
print(abs(s1-s2)) 
# First enter the size of matrix then enter the matrix vales with spaces in each line

answered Sep 18, 2021 at 5:10

I'm a Pro-Grammer's user avatar

Assuming a square matrix (nxn), you can compute the sums of both primary and secondary diagonals with only 1 iteration through the rows of the matrix; by keeping track of the indices involved in each computation.

mat = [
    [1,2,3],
    [4,5,6],
    [9,8,9]
]

primary = 0
secondary = 0
low = 0 # start index for primary
high = len(mat)-1 # end index for secondary

for row in mat:
    primary += row[low]
    secondary += row[high]
    low += 1
    high -= 1

print(f'Primary Sum = {primary}', f'Secondary Sum = {secondary}', sep='n')

answered Nov 26, 2021 at 15:20

Ioannis Michailidis's user avatar

Let’s suppose, you have a matrix A n×m.

  A = [[random.rand() for i in range(n+1)] for i in range(m+1)]
  
  d = m+n-1 # that's the overall number of different diagonals
  sumrow = [0]*d # I'd like to create a list of all the sums of those
  for diag in range(d): # iterate by diagonal number
      # A difference of two related spike functions, so that it was a spike without the top
      diaglength = int(max(0,1+d/2-abs(diag+1/2-d/2)) - max(0,1+d/2-n-abs(diag+1/2-d/2)))
      # initial coordinates for further iteration inside sum() function
      x = max(0, diag-m+1)
      y = max(0, m-diag-1)
      # iterating values along the current diagonal
      sumrow[diag]=sum(A[x+i][y+i] for i in range(0,diaglength))

Thus, sumrow[] is a list of every sum of every diagonal, choose and don’t get puddled up. I think, it’s obvious what to cut off this code to get some specific value immediately.
Technically, this code could be compressed in one line. Really long line.

But why?

answered Feb 21, 2022 at 5:53

Зинаида Измайлова's user avatar

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

def isSquare(mat):
if len(mat) == 1:
return True
for i in range(len(mat)):
if len(mat[i]) != len(mat):
print(«Matrix is not Squared»)
return False
return True

def sumOfLeftDiagonal(mat):
d1 = 0
size = len(mat)
for i in range(0,size):
for j in range(0,size):
if i == j:
d1 = d1 + mat[i][j]
return d1

def sumOfRightDiagonal(mat):
d2 = 0
size = len(mat)
for i in range(0,size):
d2 = d2 + mat[i][(size-1)-i]
return d2

if isSquare(mat):
if len(mat) == 1:
print(«Difference: «,mat[0])
else:
print(«sumOfLeftDiagonal: «,sumOfLeftDiagonal(mat))
print(«sumOfRightDiagonal: «,sumOfRightDiagonal(mat))
print(«Difference: «,abs(sumOfLeftDiagonal(mat)-sumOfRightDiagonal(mat)))

answered Jun 15, 2022 at 21:04

Muhammad Sajjad Mustafa's user avatar

1

Here is a simpler way to get the full primary diagonal and secondary diagonal

squared_matrix = [
    [2, 3, 4],
    [4, 3, 3],
    [3, 3, 4]
]


def primary_diagonal(matrix):
    sum = 0
    for i in range(len(matrix)):
        sum += matrix[i][i]
    return sum

def secondary_left_diagonal(matrix):
    sum = 0
    for i in range(len(matrix)):
        sum += matrix[i][len(matrix) - i - 1]
    return sum


print(primary_diagonal(squared_matrix))
print(secondary_left_diagonal(squared_matrix))

Result

9
10

answered Oct 30, 2022 at 8:39

Dhia Shalabi's user avatar

Dhia ShalabiDhia Shalabi

1,26711 silver badges27 bronze badges

Here is one way one how to do it:

Since the matrix is square we can get sum of a diagonal and anti-diagonal by using a original and reversed lists.

matrix = [[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12], [13, 14, 15, 16]]

to_sum =[]                             # an empty list for collection values

for i in range(len(matrix)):           # diagonal coordinats [0][0], [1][1].... [n][n]
    to_sum.append(matrix[i][i])        # append value of diagonal
    rev = matrix[i][::-1]              # for anti-diagonal reverse list
    to_sum.append(rev[i])              # append value of anti-diagonal
                                       # to_sum list [1, 4, 6, 7, 11, 10, 16, 13]
return sum(to_sum)                     # return sum of all values in list (68)

answered Nov 17, 2022 at 6:17

iGRiK's user avatar

iGRiKiGRiK

134 bronze badges

Since you know the positions of the diagonal elements for row i, you can write it quite densely like:

d = sum(row[i] + row[-1-i] for i, row in a)

And, for odd sized matrices, you shouldn’t add the center element twice:

if len(a)%2:
    centre = len(a)//2
    d -= a[centre][centre]

answered Feb 7, 2016 at 12:47

xtofl's user avatar

xtoflxtofl

40.5k12 gold badges105 silver badges191 bronze badges

def sum_diagnol():
    import random
    sum=0
    r1=int(input("row"))
    c1=int(input("col"))
    a=[[random.random()for col in range(c1)]for row in range(r1)]
    print("enter elements")
    for i in range(r1):
        for j in range(c1):
            a[i][j]=int(input("enter elements"))
    r2=int(input("row"))
    c2=int(input("col"))
    b=[[random.random()for col in range(c2)]for row in range(r2)]
    print("enter elements")
    for i in range(r2):
        for j in range(c2):
            b[i][j]=int(input("enter elements"))
    c=[[random.random()for col in range(c2)]for row in range(r1)]
    if(c1==r2):
        for i in range(r1):
            for j in range(c2):
                c[i][j]=0
                for k in range(c2):
                    c[i][j]=a[j][k]*b[k][j]
    else:
        print("multiplication not possible")
    for i in range(r1):
        for j in range(c2):
            print(c[i][j],end=" ")
        print()
sum_diagnol()

Suraj Rao's user avatar

Suraj Rao

29.3k11 gold badges94 silver badges103 bronze badges

answered Feb 8, 2019 at 11:00

Sathvik Andela's user avatar

1

I found a simple algorithm to accomplish this task.

  1. Store the square matrix in a single one dimensional array.

  2. Let ‘n’ be the order of square matrix.

  3. There are two diagonals , one that starts from the leftmost element in top row and
    another that starts from nth element of the top row.

  4. To get the indexes of numbers on the diagonal that starts from left most element in top row ,from the array containing all the numbers in the matrix; just add (n+1) recursively starting from index 1.
    That is, indexes of elements in left to right diagonal in the array are, 1, 1+(n+1) , (n+2)+(n+1) , (2n+3)+(n+1) till the last index of array.

  5. To get the indexes of another diagonal’s numbers from the array containing all the numbers in the matrix ; just add (n-1) recursively to the indexes starting from index equals to the ‘n’, which is the order of the square matrix.
    That is, indexes of elements in right to left diagonal in the array are, n, n+(n-1), (2n-1)+(n-1) and so on till the index equals to ‘length of the array — (n-1)’.

  6. If the order is odd then subtract the middle number in the array from the final sum.

The example ‘c++’ code is as follows:

 #include<iostream>
 using namespace std;

int sumOfDiagonalNumbersInSquareMatrix(int numberArray[],int order){
int sumOfLeftToRightDiagonal = 0;
int sumOfRightToLeftDiagonal = 0;
int length = order*order;
for(int i=0; i<length;i+=(order+1)){
    //cout<<numberArray[i]<<"t";
    sumOfLeftToRightDiagonal = sumOfLeftToRightDiagonal + numberArray[i];

}
for(int i=(order-1);i<=length-order;i+=(order-1)){
    //cout<<numberArray[i]<<"t";
    sumOfRightToLeftDiagonal = sumOfRightToLeftDiagonal + numberArray[i];
}
if(order % 2 != 0){
    return (sumOfLeftToRightDiagonal + sumOfRightToLeftDiagonal) - numberArray[(length/2)];
}
return (sumOfLeftToRightDiagonal + sumOfRightToLeftDiagonal);
}

 int main(){
 int nums[] = {1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16};
 cout<<sumOfDiagonalNumbersInSquareMatrix(nums,4);
 return 0;
 }

You can run it here: http://cpp.sh/6cmdp

answered Dec 9, 2019 at 16:28

Deepeshkumar's user avatar

I don’t understand why no one posted any good solution.
Here is as descent solution:

length = len(arr)
r1 = 0
r2 = 0
for i in range(length):
    r1 += arr[i][length - i - 1]
    r2 += arr[i][i]
print(r1 + r2)
# If you want sum of there absolute values
print(abs(r1) + abs(r2))

Here arr is a 2d list.

answered Feb 28, 2020 at 17:32

Akshat Tamrakar's user avatar

Akshat TamrakarAkshat Tamrakar

2,1232 gold badges13 silver badges20 bronze badges

»’

a = [[],[],[]] #your matrix
s = 0
for i in range(len(a)):
    for j in range(len(a[0])):
           if i == j:
               s += a[i][j]
print('sum ='s)

»’
here is a simple approach.
Thanks

answered Nov 19, 2020 at 6:57

Vinayak Verma's user avatar

In this article, we will learn a python program to efficiently compute sums of diagonals of a matrix.

Methos Used

The following are the various methods to accomplish this task −

  • Using Nested For Loops

  • Using Only Single Loop

In a matrix we have two diagonals −

  • Principal diagonal

  • Secondary diagonal

Example

Let us take a 3×3 matrix as shown below −

A00 A01 A02 
A10 A11 A12 
A20 A21 A22 

Principal Diagonal Condition − The row-column condition is row = column. The principal diagonal is formed by A00, A11, and A22 elements in a 3×3 matrix.

Secondary Diagonal Condition − The row-column condition is row = numberOfRows – column -1. The principal diagonal is formed by A02, A11, and A22 elements in a 3×3 matrix.

Method 1: Using Nested For Loops

Algorithm (Steps)

Following are the Algorithms/steps to be followed to perform the desired task. −

  • Create a function sumOfDiagonals() to print the sum of diagonals of a matrix by accepting the input matrix, rows as arguments.

  • Initialize a variable with 0 to store the principal diagonal sum.

  • Initialize another variable with 0 to store the secondary diagonal sum.

  • Use the for loop to traverse through the rows of a matrix.

  • Use another nested for loop, to traverse through all the columns of a current row.

  • Check if the row number is equal to the column number(Principal Diagonal Condition) using the if conditional statement and if it is true then the matrix element value to the principal diagonal sum.

  • Similarly, Check if the sum of the row number and column number is the number of rows(Secondary Diagonal Condition) using the if conditional statement and if it is true then the matrix element value to secondary diagonal sum.

  • Print the resultant sum of principaldiagonal elements of an input matrix.

  • Print the resultant sum of secondary diagonal elements of an input matrix.

  • Create a variable to store the input matrix.

  • Call the above-defined sumOfDiagonals() function by passing the input matrix and no of rows(dimensions) as arguments to print the sum of diagonals.

Example

The following program returns the sum of diagonals of an input matrix using the nested for loops −

# creating a function to print the sum of diagonals
# of a matrix by accepting input matrix, rows as arguments
def sumOfDiagonals(inputMatrix, rows):
   # Initializing with 0 to store the principal diagonal sum
      principal_diag = 0
   # Initializing with 0 to store the secondary diagonal sum
      secondary_diag = 0
   # Traversing through the rows of a matrix
      for p in range(0, rows):
         # Traversing through the columns of the current row
            for q in range(0, rows):
            # Principal diagonal condition
               if (p == q):
                  principal_diag += inputMatrix[p][q]
            # Secondary diagonal condition(row -1 because index starts from 0)
            if ((p + q) == (rows - 1)):
                  secondary_diag += inputMatrix[p][q]
      # Printing the sum of principal diagonal elements
      print("Sum of principal diagonal elements:", principal_diag)
      # Printing the sum of secondary diagonal elements
      print("Sum of secondary diagonal elements:", secondary_diag)
# input matrix(3x3 matrix)
inputMatrix = [[5, 1, 3],
               [9, 6, 8],
               [4, 2, 7]]
rows = 3
print("Given Matrix is:")
# traversing through the rows of a matrix
for p in range(rows):
   # Traversing through the columns of a current row
      for q in range(rows):
         # printing the corresponding element at the current row and column of the matrix
         print(inputMatrix[p][q], end=" ")
      # Printing a new line
      print()
# calling sumOfDiagonals() function by passing input matrix
# and no of rows(dimensions) to it
sumOfDiagonals(inputMatrix, rows)

Output

On execution, the above program will generate the following output −

Given Matrix is:
5 1 3 
9 6 8 
4 2 7 
Sum of principal diagonal elements: 18
Sum of secondary diagonal elements: 13

Time Complexity − O(N*N), Since we used nested loops to traverse N*N times.

Auxiliary Space − O(1). Since we are not using any additional space.

Method 2: Using Only Single Loop

Example

The following program returns the sum of diagonals of an input matrix using the only one for loop(Single Loop) −

# Creating a function to print the sum of diagonals
# of a matrix by accepting input matrix, rows as arguments
def sumOfDiagonals(inputMatrix, rows):
   # Initializing with 0 to store the principal diagonal sum
      principal_diag = 0
   # Initializing with 0 to store the secondary diagonal sum
      secondary_diag = 0
   # Traversing the rows of a matrix
      for p in range(0, rows):
         # Adding the principal Diagonal element of the current row
         principal_diag += inputMatrix[p][p]
         # Adding the secondary Diagonal element of the current row
         secondary_diag += inputMatrix[p][rows - p - 1]
      # printing the sum of principal diagonal elements
      print("Sum of principal diagonal elements:", principal_diag)
   # printing the sum of secondary diagonal elements
      print("Sum of secondary diagonal elements:", secondary_diag)
# input matrix(3x3 matrix)
inputMatrix = [[5, 1, 3],
               [9, 6, 8],
               [4, 2, 7]]
rows = 3
print("The Given Matrix is:")
# traversing through the rows of a matrix
for p in range(rows):
   # Traversing through the columns of a current row
      for q in range(rows):
         # printing the corresponding element at the current row and column of the matrix
         print(inputMatrix[p][q], end=" ")
      # Printing a new line
      print()
# calling sumOfDiagonals() function by passing input matrix
# and no of rows(dimensions) to it
sumOfDiagonals(inputMatrix, rows)

Output

On execution, the above program will generate the following output −

Given Matrix is:
5 1 3 
9 6 8 
4 2 7 
Sum of principal diagonal elements: 18
Sum of secondary diagonal elements: 13

Time Complexity − O(N). Since we used a loop to traverse N times.

Auxiliary Space − O(1). Since we are not using any additional space.

Conclusion

In this article, we learned about matrix diagonals and two different methods for computing the sums of matrix diagonals (primary and secondary). We learned an efficient method for computing this that requires only a single traversal of the matrix (O(N) Time Complexity).

Skip to content

Задача «Побочная диагональ»

Условие

Дано число n. Создайте массив размером n×n и заполните его по следующему правилу:

Числа на диагонали, идущей из правого верхнего в левый нижний угол равны 1.

Числа, стоящие выше этой диагонали, равны 0.

Числа, стоящие ниже этой диагонали, равны 2.

Полученный массив выведите на экран. Числа в строке разделяйте одним пробелом.

Решение задачи от разработчиков на Python:

Еще одно решение задачи на Python:

Смотреть видео — Задача «Побочная диагональ» решение на Python

Делитесь с друзьями ссылкой на ответ и задавайте вопросы в комментариях! 👇

Related Posts

Посмотреть все комментарии

wpDiscuz

0

Оставьте комментарий! Напишите, что думаете по поводу статьи.x

2.4 Обработка двумерных массивов (матриц)

Двумерные массивы являются аналогами матриц и имеют «прямоугольную» (табличную) структуру. Описываются массивы так же, как одномерные. Разница состоит в том, что у элемента двумерного массива две координаты (два индекса) — номер строки и номер столбца, в которых находится элемент.

Ввод массива осуществляется построчно при помощи двух циклов. Пусть M — количество столбцов, N — количество строк. Элементы массива обозначим как mas[i, j], первый индекс — номер строки, второй — номер столбца.

ввод M,N
нц для i от 1 до N
	нц для j от 1 до M
		ввод mas[i, j]
	кц
кц

Вывод массива на экран осуществляется при помощи аналогичных циклов.

нц для i от 1 до N
	нц для j от 1 до M
		вывод mas[i, j]
	кц
	вывод
кц

Здесь «пустой» оператор вывода обеспечивает переход на новую строку.

В Python для работы с многомерными (когда используется два и более индексов) массивами можно использовать вложенные списки (списки списков, списки списков списков и т. д.).

Однако Python предоставляет более удобный инструмент создания и преобразования многомерных массивов — библиотеку numpy (Numeric Python).

Создание двумерного массива в Python может выглядеть так:

# -*- coding: utf-8 -*-

#

import numpy

n=input(‘Количество строк: ‘)

m=input(‘Количество столбцов: ‘)

# Создаём «нулевую» матрицу

a=numpy.zeros([n-1,m-1])

# Заполняем матрицу

for i in range(n-1) :

    for j in range(m-1) :

        print‘Элемент матрицы[‘,i,’][‘,j,’]’

        a[i, j]=input(‘Введите элемент: ‘)

#

Сначала с помощью функции (метода) numpy.zeros() создаётся двумерный массив (матрица), заполненный нулями, а потом вместо нулей подставляются реальные значения. Индексы элементов, так же как в строках, кортежах и списках, начинаются с 0 (первый — верхний левый — элемент матрицы в Python имеет индекс [0,0]). Оператор print выводит индексы очередного элемента матрицы, который нужно ввести.

Задача 1. Выполнить обработку элементов прямоугольной матрицы A, имеющей N строк и M столбцов. Найти среднее арифметическое элементов массива.

Постановка задачи:

Дано:

Найти:

Блок-схема алгоритма вычисления среднего значения матрицы

Рис.
2.15.
Блок-схема алгоритма вычисления среднего значения матрицы

Блок-схема алгоритма решения показана на рис. 2.15.

Текст программы на «псевдоязыке»:

ввод n,m
S=0
нц для i от 1 до n
	нц для j от 1 до m
		ввод A[i, j]
		S=S+A[i, j]
	кц
кц
K=n*m
C=S/K
вывод C

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

# -*- coding: utf-8 -*-

#

import numpy

n=input(‘Количество строк: ‘)

m=input(‘Количество столбцов: ‘)

S=0.0

# Создаём нулевую матрицу

a=numpy.zeros([n-1,m-1])

# Заполняем матрицу

for i in range(n-1) :

    for j in range(m-1) :

        print ‘Элемент матрицы [‘,i,’][‘,j,’]’

        a[i, j]=input(‘Введите элемент: ‘)

        S=S+a[i, j]

#

K=n*m

C=S/K

print ‘Среднее значение по строкам:’,C

2.4.1 Задачи для самостоятельного решения

  1. Выполнить обработку элементов прямоугольной матрицы A, имеющей N строк и M столбцов. Найти наибольший элемент столбца матрицы A, для которого сумма абсолютных значений элементов максимальна.
  2. Выполнить обработку элементов прямоугольной матрицы A, имеющей N строк и M столбцов. Найти наибольшее значение среди средних значений для каждой строки матрицы.
  3. Выполнить обработку элементов прямоугольной матрицы A, имеющей N строк и M столбцов. Найти наименьший элемент столбца матрицы A, для которого сумма абсолютных значений элементов максимальна.
  4. Выполнить обработку элементов прямоугольной матрицы A, имеющей N строк и M столбцов. Найти наименьшее значение среди средних значений для каждой строки матрицы.
  5. Выполнить обработку элементов прямоугольной матрицы A, имеющей N строк и M столбцов. Определить средние значения по всем строкам и столбцам матрицы. Результат оформить в виде матрицы из N +1 строк и M +1 столбцов.
  6. Выполнить обработку элементов прямоугольной матрицы A, имеющей N строк и M столбцов. Найти сумму элементов всей матрицы. Определить, какую долю в этой сумме составляет сумма элементов каждого столбца. Результат оформить в виде матрицы из N + 1 строк и M столбцов.
  7. Выполнить обработку элементов прямоугольной матрицы A, имеющей N строк и M столбцов. Найти сумму элементов всей матрицы. Определить, какую долю в этой сумме составляет сумма элементов каждой строки. Результат оформить в виде матрицы из N строк и M+1 столбцов.
  8. Выполнить обработку элементов прямоугольной матрицы A, имеющей N строк и M столбцов. Определить, сколько отрицательных элементов содержится в каждом столбце и в каждой строке матрицы. Результат оформить в виде матрицы из N + 1 строк и M + 1 столбцов.
  9. Выполнить обработку элементов прямоугольной матрицы A, имеющей N строк и M столбцов. Определить, сколько нулевых элементов содержится в верхних L строках матрицы и в левых К столбцах матрицы.
  10. Выполнить обработку элементов прямоугольной матрицы A, имеющей N строк и M столбцов. Перемножить элементы каждого столбца матрицы с соответствующими элементами K-го столбца.
  11. Выполнить обработку элементов прямоугольной матрицы A, имеющей N строк и M столбцов. Просуммировать элементы каждой строки матрицы с соответствующими элементами L-й строки.
  12. Выполнить обработку элементов прямоугольной матрицы A, имеющей N строк и M столбцов. Разделить элементы каждой строки на элемент этой строки с наибольшим значением.
  13. Выполнить обработку элементов прямоугольной матрицы A, имеющей N строк и M столбцов. Разделить элементы каждого столбца матрицы на элемент этого столбца с наибольшим значением.
  14. Выполнить обработку элементов прямоугольной матрицы A, имеющей N строк и M столбцов. Разделить элементы матрицы на элемент матрицы с наибольшим значением.
  15. Выполнить обработку элементов прямоугольной матрицы A, имеющей N строк и M столбцов. Все элементы имеют целый тип. Дано целое число H. Определить, какие столбцы имеют хотя бы одно такое число, а какие не имеют.
  16. Выполнить обработку элементов прямоугольной матрицы A, имеющей N строк и M столбцов. Исключить из матрицы строку с номером L. Сомкнуть строки матрицы.
  17. Выполнить обработку элементов прямоугольной матрицы A, имеющей N строк и M столбцов. Добавить к матрице строку и вставить ее под номером L.
  18. Выполнить обработку элементов квадратной матрицы A, имеющей N строк и N столбцов. Найти сумму элементов, стоящих на главной диагонали, и сумму элементов, стоящих на побочной диагонали (элементы главной диагонали имеют индексы от [0,0] до [N,N], а элементы побочной диагонали – от [N,0] до [0,N]).
  19. Выполнить обработку элементов квадратной матрицы A, имеющей N строк и N столбцов. Определить сумму элементов, расположенных параллельно главной диагонали (ближайшие к главной). Элементы главной диагонали имеют индексы от [0,0] до [N,N].
  20. Выполнить обработку элементов квадратной матрицы A, имеющей N строк и N столбцов. Определить произведение элементов, расположенных параллельно побочной диагонали (ближайшие к побочной). Элементы побочной диагонали имеют индексы от [N,0] до [0,N].
  21. Выполнить обработку элементов квадратной матрицы A, имеющей N строк и N столбцов. Каждой паре элементов, симметричных относительно главной диагонали (ближайшие к главной), присвоить значения, равные полусумме этих симметричных значений (элементы главной диагонали имеют индексы от [0,0] до [N,N]).
  22. Выполнить обработку элементов прямоугольной матрицы A, имеющей N строк и M столбцов. Исходная матрица состоит из нулей и единиц. Добавить к матрице еще один столбец, каждый элемент которого делает количество единиц в каждой строке чётным.
  23. Выполнить обработку элементов квадратной матрицы A, имеющей N строк и N столбцов. Найти сумму элементов, расположенных выше главной диагонали, и произведение элементов, расположенных выше побочной диагонали (элементы главной диагонали имеют индексы от [0,0] до [N,N], а элементы побочной диагонали — от [N,0] до [0,N]).
  24. Выполнить обработку элементов прямоугольной матрицы A, имеющей N строк и M столбцов. Дан номер строки L и номер столбца K, при помощи которых исходная матрица разбивается на четыре части. Найти сумму элементов каждой части.
  25. Выполнить обработку элементов прямоугольной матрицы A, имеющей N строк и M столбцов. Определить, сколько нулевых элементов содержится в каждом столбце и в каждой строке матрицы. Результат оформить в виде матрицы из N + 1 строк и M + 1 столбцов.
  26. Выполнить обработку элементов прямоугольной матрицы A, имеющей N строк и M столбцов. Дан номер строки L и номер столбца K, при помощи которых исходная матрица разбивается на четыре части. Найти среднее арифметическое элементов каждой части.
  27. Выполнить обработку элементов прямоугольной матрицы A, имеющей N строк и M столбцов. Все элементы имеют целый тип. Дано целое число H. Определить, какие строки имеют хотя бы одно такое число, а какие не имеют.
  28. Выполнить обработку элементов прямоугольной матрицы A, имеющей N строк и M столбцов. Исключить из матрицы столбец с номером K. Сомкнуть столбцы матрицы.
  29. Выполнить обработку элементов прямоугольной матрицы A, имеющей N строк и M столбцов. Добавить к матрице столбец чисел и вставить его под номером K.
  30. Выполнить обработку элементов прямоугольной матрицы A, имеющей N строк и M столбцов. Добавить к элементам каждого столбца такой новый элемент, чтобы сумма положительных элементов стала бы равна модулю суммы отрицательных элементов. Результат оформить в виде матрицы из N + 1 строк и M столбцов.
  31. Выполнить обработку элементов прямоугольной матрицы A, имеющей N строк и M столбцов. Добавить к элементам каждой строки такой новый элемент, чтобы сумма положительных элементов стала бы равна модулю суммы отрицательных элементов. Результат оформить в виде матрицы из N строк и M + 1 столбцов

Понравилась статья? Поделить с друзьями:
  • Как найти предметы для вов
  • Как найти экстремум функции двух переменных онлайн
  • Как исправить залысины на потолке после покраски
  • Как найти денег срочно без кредита
  • Как найти магазин где купили телефон